refactor: faucet drip updates (#36)

* update drip to be onlyOwner and allow caller to provide rate limiting lookup key

Signed-off-by: Aaron Sutula <[email protected]>

* support multiple keys in drip

Signed-off-by: Aaron Sutula <[email protected]>

* longer rate limit time

Signed-off-by: Aaron Sutula <[email protected]>

* update test for longer rate limit time

Signed-off-by: Aaron Sutula <[email protected]>

* update rate limit interval and drip amount

Signed-off-by: Aaron Sutula <[email protected]>

---------

Signed-off-by: Aaron Sutula <[email protected]>
Co-authored-by: Aaron Sutula <[email protected]>

Author: asutula

src/token/Faucet.sol

@@ -23,11 +23,11 @@ event Funding(address indexed from, uint256 value);
 /// @title Faucet Contract
 /// @dev A simple faucet contract for distributing tokens
 contract Faucet is Ownable {
-    /// @dev Mapping to store the next allowed request time for each address
-    mapping(address => uint256) internal _nextRequestAt;
+    /// @dev Mapping to store the next allowed request time for each key
+    mapping(string => uint256) internal _nextRequestAt;
 
     /// @dev Amount of tokens to drip per request
-    uint256 internal _dripAmount = 100;
+    uint256 internal _dripAmount = 18;
 
     /// @dev Initializes the Faucet contract
     /// @dev Sets the contract deployer as the initial owner
@@ -58,16 +58,22 @@ contract Faucet is Ownable {
     /// @dev Distributes tokens to the specified recipient
     /// @dev Reverts if the recipient has requested tokens too recently
     /// @param recipient The address to receive the tokens
-    function drip(address payable recipient) external {
-        if (_nextRequestAt[recipient] > block.timestamp) {
-            revert TryLater();
+    /// @param keys Array of keys to identify the recipient used in the _nextRequestAt mapping
+    function drip(address payable recipient, string[] calldata keys) external onlyOwner {
+        uint256 keysLength = keys.length;
+        uint256 amount = _dripAmount;
+        for (uint256 i = 0; i < keysLength; i++) {
+            if (_nextRequestAt[keys[i]] > block.timestamp) {
+                revert TryLater();
+            }
         }
-        if (address(this).balance < _dripAmount) {
+        if (address(this).balance < amount) {
             revert FaucetEmpty();
         }
-
-        _nextRequestAt[recipient] = block.timestamp + (5 minutes);
-        recipient.transfer(_dripAmount);
+        for (uint256 i = 0; i < keysLength; i++) {
+            _nextRequestAt[keys[i]] = block.timestamp + (12 hours);
+        }
+        recipient.transfer(amount);
     }
 
     /// @dev Sets the amount of tokens to distribute per request

test/Faucet.t.sol

@@ -14,40 +14,48 @@ contract FaucetTest is Test {
     Faucet internal faucet;
     Vm.Wallet internal wallet;
     Vm.Wallet internal chain;
+    address internal owner;
     address internal constant TESTER = address(0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38);
     uint256 internal constant MINT_AMOUNT = 1000 * 10 ** 18;
+    string[] internal keys = ["test1", "test2"];
 
     function setUp() public virtual {
         chain = vm.createWallet("chain");
         vm.deal(chain.addr, MINT_AMOUNT);
         wallet = vm.createWallet("user");
         FaucetDeployer faucetDeployer = new FaucetDeployer();
         faucet = faucetDeployer.run(MINT_AMOUNT / 2);
+        owner = faucet.owner();
         assertEq(faucet.supply(), MINT_AMOUNT / 2);
     }
 
     function testDripTransfer() public {
         assertEq(wallet.addr.balance, 0);
 
-        faucet.drip(payable(wallet.addr));
+        vm.prank(owner);
+        faucet.drip(payable(wallet.addr), keys);
 
         assertEq(faucet.supply(), MINT_AMOUNT / 2 - faucet.dripAmount());
         assertEq(wallet.addr.balance, faucet.dripAmount());
     }
 
     function testDripTransferNoDelayFail() public {
-        faucet.drip(payable(wallet.addr));
+        vm.prank(owner);
+        faucet.drip(payable(wallet.addr), keys);
 
         vm.expectRevert(TryLater.selector);
-        faucet.drip(payable(wallet.addr));
+        vm.prank(owner);
+        faucet.drip(payable(wallet.addr), keys);
     }
 
     function testDripTransferDelay() public {
-        faucet.drip(payable(wallet.addr));
+        vm.startPrank(owner);
+        faucet.drip(payable(wallet.addr), keys);
 
-        vm.warp(block.timestamp + (5 minutes));
+        vm.warp(block.timestamp + (12 hours));
 
-        faucet.drip(payable(wallet.addr));
+        faucet.drip(payable(wallet.addr), keys);
+        vm.stopPrank();
 
         assertEq(wallet.addr.balance, 2 * faucet.dripAmount());
     }