save work before resetting computer

Author: JoeHowarth

remappings.txt

@@ -1,3 +1,5 @@
 ds-test/=lib/forge-std/lib/ds-test/src/
 forge-std/=lib/forge-std/src/
 solmate/=lib/solmate/src/
+openzeppelin/=lib/openzeppelin-contracts/contracts
+

src/Safu.sol

@@ -1,28 +1,97 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.13;
 
+import "openzeppelin/token/ERC20/IERC20.sol";
+
 interface SafuLike {
     // Record that white-hat has deposited funds.
     function deposit(address erc20, uint256 wad) external;
 
     // all eligible bounties for msg.sender are transfered
-    function withdraw() external;
+    function claim() external;
+
+    function bounty(uint16 id) external returns (uint256 amt, bool approved);
+
+    function approveBounty(uint16 id) external;
 }
 
 contract SimpleSafu {
-    struct Deposit {
-        IERC20 token 
-
+    struct Receipt {
+        uint16 id;
+        IERC20 token;
+        uint256 amt;
+        uint256 blockTime;
+        bool rewardApproved;
     }
 
     address[] public depositors;
-    mapping(address => )
+    mapping(address => Receipt[]) depositorToReceipts;
+    mapping(IERC20 => uint256) public tokenToBountyCap;
+    mapping(IERC20 => uint256) public tokenToTotalDeposited;
+    mapping(IERC20 => uint256) public tokenToBountyWithdrawn;
+    uint256 public immutable defaultBountyCap;
+    uint256 public immutable minDelay;
+    uint256 public immutable maxDelay;
+    uint8 public immutable bountyPercent;
+
+    bool public rewardsClaimable;
+    bool public autoApprove;
+
+    constructor(
+        uint256 _defaultBountyCap,
+        uint256 _minDelay,
+        uint256 _maxDelay,
+        uint8 _bountyPercent,
+        bool _rewardsClaimable,
+        bool _autoApprove
+    ) {
+        defaultBountyCap = _defaultBountyCap;
+        minDelay = _minDelay;
+        maxDelay = _maxDelay;
+        bountyPercent = _bountyPercent;
+        rewardsClaimable = _rewardsClaimable;
+        autoApprove = _autoApprove;
+    }
+
+    function deposit(address _erc20, uint256 wad) external {
+        require(wad > 0, "Safu/zero-deposit");
+        depositors.push(msg.sender);
+        IERC20 erc20 = IERC20(_erc20);
+
+        uint256 prevTotalBounty = tokenToTotalDeposited[erc20] -
+            tokenToBountyWithdrawn[erc20];
+        // if (prevTotalBounty + )
+    }
+
+    function bounty(address guy, uint16 id) public view returns (uint256 amt, bool approved) { 
+        Receipt memory receipt = getReceipt(guy, id);
+        approved = receipt.rewardApproved;
+        if ()
+    }
+
+    function bounty(uint16 id) public view returns (uint256 amt, bool approved) {
+        return bounty(msg.sender, id);
+    }
+
+    function getReceipt(address depositor, uint16 id)
+        public
+        view
+        returns (Receipt memory)
+    {
+        Receipt[] storage deposits = depositorToReceipts[depositor];
+        for (uint256 i = 0; i < deposits.length; ++i) {
+            if (deposits[i].id == id) {
+                return deposits[i];
+            }
+        }
+        revert("Safu/deposit-not-found-for-id-address-pair");
+    }
 }
 
 /*
 pro rata with cap per token
 mapping : token -> cap
-mapping : token -> percentOfDepositWithdrawable
+mapping : token -> percentOfReceiptWithdrawable
 
 depositor delay
 
@@ -33,4 +102,4 @@ sender
     
 each deposit keyed by (sender addr, blocktime)
 
-*/
+*/

test/Safu.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+import "openzeppelin/token/ERC20/IERC20.sol";
+import "openzeppelin/token/ERC20/ERC20.sol";
+import "../src/Safu.sol";
+
+contract DummyERC20 is ERC20 {
+    constructor(string memory name_, string memory symbol_)
+        ERC20(name_, symbol_)
+    {}
+
+    function mint(address account, uint256 amount) external {
+        _mint(account, amount);
+    }
+}
+
+contract SimpleSafuTest is Test {
+    SimpleSafu safu;
+    IERC20 erc20;
+
+    function setUp() public {
+        DummyERC20 _erc20 = new DummyERC20("testERC20", "TBD");
+        _erc20.mint(address(this), 1_000_000);
+        erc20 = _erc20;
+    }
+
+    function defaultSafu() SimpleSafu internal {
+        uint256 defaultBountyCap = 10;
+        uint256 minDelay = 10;
+        uint256 maxDelay = 20;
+        uint8 bountyPercent = 50;
+        safu = new SimpleSafu(
+            defaultBountyCap,
+            minDelay,
+            maxDelay,
+            bountyPercent
+        );
+    }
+
+    function testDepositSuccess() public {
+
+        erc20.approve(address(this), 2_000);
+        safu.deposit(address(erc20), 2_000);
+        assertEq(safu.tokenToBountyCap(erc20), defaultBountyCap);
+    }
+}