refactor: change immutable MINIMUM_DEPOSIT to MAXIMUM_DEPOSIT

Author: passandscore

contracts/contracts/core/GasTankDepositor.sol

@@ -8,7 +8,7 @@ import {Errors} from "../utils/Errors.sol";
 /// @dev This contract implicitly trusts the RPC_SERVICE address.
 contract GasTankDepositor {
     address public immutable RPC_SERVICE;
-    uint256 public immutable MINIMUM_DEPOSIT;
+    uint256 public immutable MAXIMUM_DEPOSIT;
 
     event FundsRecovered(address indexed owner, uint256 indexed amount);
     event GasTankFunded(address indexed smartAccount, address indexed caller, uint256 indexed amount);
@@ -21,7 +21,7 @@ contract GasTankDepositor {
     error NotRPCService(address caller);
     error InsufficientFunds(uint256 currentBalance, uint256 requiredBalance);
     error NotThisEOA(address msgSender, address thisAddress);
-    error MinimumDepositNotMet(uint256 amountToTransfer, uint256 minimumDeposit);
+    error MaximumDepositNotMet(uint256 amountToTransfer, uint256 maximumDeposit);
 
     modifier onlyThisEOA() {
         require(msg.sender == address(this), NotThisEOA(msg.sender, address(this)));
@@ -33,11 +33,13 @@ contract GasTankDepositor {
         _;
     }
 
-    constructor(address rpcService, uint256 _minDeposit) {
+    /// @dev Writes the variables into the contract bytecode.
+    /// @dev No storage is used in this contract.
+    constructor(address rpcService, uint256 _maxDeposit) {
         require(rpcService != address(0), RPCServiceNotSet(rpcService));
-        require(_minDeposit > 0, MinimumDepositNotMet(0, _minDeposit));
+        require(_maxDeposit > 0, MaximumDepositNotMet(0, _maxDeposit));
         RPC_SERVICE = rpcService;
-        MINIMUM_DEPOSIT = _minDeposit;
+        MAXIMUM_DEPOSIT = _maxDeposit;
     }
 
     receive() external payable { /* ETH transfers allowed. */ }
@@ -60,14 +62,13 @@ contract GasTankDepositor {
     /// @param _amount The amount to fund the gas tank with.
     /// @dev Only the EOA can call this function.
     function fundGasTank(uint256 _amount) external onlyThisEOA {
-        require(_amount >= MINIMUM_DEPOSIT, MinimumDepositNotMet(_amount, MINIMUM_DEPOSIT));
         _fundGasTank(_amount);
     }
 
-    /// @notice Transfers the minimum deposit amount of ETH from the EOA's balance to the Gas RPC Service.
+    /// @notice Transfers the maximum deposit amount of ETH from the EOA's balance to the Gas RPC Service.
     /// @dev Only the RPC Service can call this function.
     function fundGasTank() external onlyRPCService {
-        _fundGasTank(MINIMUM_DEPOSIT);
+        _fundGasTank(MAXIMUM_DEPOSIT);
     }
 
     /// @dev `fundGasTank` Internal function to fund the gas tank.

contracts/doc/GasTankDepositor.md

@@ -30,13 +30,13 @@ The contract facilitates a custodial gas tank system where:
 
 2. **Initial Funding**:
    - User calls `fundGasTank(uint256 _amount)` with their desired initial deposit
-   - Amount must be >= `MINIMUM_DEPOSIT`
+   - Amount must be >= `MAXIMUM_DEPOSIT`
    - ETH is transferred from user's EOA to the RPC service EOA
    - RPC service updates off-chain ledger to reflect the deposit
 
 3. **Automatic Top-Ups**:
    - When a user's off-chain ledger balance drops below threshold, RPC service calls `fundGasTank()`
-   - This always transfers exactly `MINIMUM_DEPOSIT` amount
+   - This always transfers exactly `MAXIMUM_DEPOSIT` amount
    - Transfer occurs directly from user's EOA balance (if sufficient funds available)
    - No user interaction required - fully automated
    - No need for `maxTransferAllowance` as RPC is restricted to minimum amount only

contracts/test/core/GasTankDepositorTest.sol

@@ -8,7 +8,7 @@ contract GasTankDepositorTest is Test {
     uint256 public constant ALICE_PK = uint256(0xA11CE);
     uint256 public constant BOB_PK = uint256(0xB0B);
     uint256 public constant RPC_SERVICE_PK = uint256(0x1234567890);
-    uint256 public constant MINIMUM_DEPOSIT = 0.01 ether;
+    uint256 public constant MAXIMUM_DEPOSIT = 0.01 ether;
     address public constant ZERO_ADDRESS = address(0);
     bytes32 public constant EMPTY_CODEHASH = keccak256("");
 
@@ -22,7 +22,7 @@ contract GasTankDepositorTest is Test {
         vm.deal(alice, 10 ether);
         vm.deal(bob, 10 ether);
         vm.deal(rpcService, 10 ether);
-        _gasTankDepositorImpl = new GasTankDepositor(rpcService, MINIMUM_DEPOSIT);
+        _gasTankDepositorImpl = new GasTankDepositor(rpcService, MAXIMUM_DEPOSIT);
     }
 
     //=======================TESTS=======================
@@ -108,16 +108,16 @@ contract GasTankDepositorTest is Test {
 
     //=======================TESTS FOR FUNDING THE GAS TANK=======================
 
-    function testRpcServiceFundsMinimumDeposit() public {
+    function testRpcServiceFundsMaximumDeposit() public {
         _delegate();
 
         uint256 rpcBalanceBefore = rpcService.balance;
-        _expectGasTankFunded(rpcService, MINIMUM_DEPOSIT);
+        _expectGasTankFunded(rpcService, MAXIMUM_DEPOSIT);
 
         vm.prank(rpcService);
         GasTankDepositor(payable(alice)).fundGasTank();
 
-        assertEq(rpcService.balance, rpcBalanceBefore + MINIMUM_DEPOSIT, "rpc balance not increased");
+        assertEq(rpcService.balance, rpcBalanceBefore + MAXIMUM_DEPOSIT, "rpc balance not increased");
     }
 
     function testRpcServiceFundRevertsWhenCallerNotRpcService() public {
@@ -129,12 +129,12 @@ contract GasTankDepositorTest is Test {
     }
 
     function testRpcServiceFundRevertsWhenInsufficientBalance() public {
-        vm.deal(alice, MINIMUM_DEPOSIT - 1);
+        vm.deal(alice, MAXIMUM_DEPOSIT - 1);
         _delegate();
 
         vm.prank(rpcService);
         vm.expectRevert(
-            abi.encodeWithSelector(GasTankDepositor.InsufficientFunds.selector, MINIMUM_DEPOSIT - 1, MINIMUM_DEPOSIT)
+            abi.encodeWithSelector(GasTankDepositor.InsufficientFunds.selector, MAXIMUM_DEPOSIT - 1, MAXIMUM_DEPOSIT)
         );
         GasTankDepositor(payable(alice)).fundGasTank();
     }
@@ -152,34 +152,34 @@ contract GasTankDepositorTest is Test {
         assertEq(rpcService.balance, rpcBalanceBefore + amount, "rpc balance not increased");
     }
 
-    function testEOAFundRevertsBelowMinimumDeposit() public {
+    function testEOAFundRevertsBelowMaximumDeposit() public {
         _delegate();
-        uint256 belowMinimumDeposit = MINIMUM_DEPOSIT - 1 wei;
+        uint256 belowMaximumDeposit = MAXIMUM_DEPOSIT - 1 wei;
 
         vm.prank(alice);
         vm.expectRevert(
-            abi.encodeWithSelector(GasTankDepositor.MinimumDepositNotMet.selector, belowMinimumDeposit, MINIMUM_DEPOSIT)
+            abi.encodeWithSelector(GasTankDepositor.MaximumDepositNotMet.selector, belowMaximumDeposit, MAXIMUM_DEPOSIT)
         );
-        GasTankDepositor(payable(alice)).fundGasTank(belowMinimumDeposit);
+        GasTankDepositor(payable(alice)).fundGasTank(belowMaximumDeposit);
     }
 
     function testEOAFundRevertsWhenCallerNotEOA() public {
         _delegate();
 
         vm.prank(rpcService);
         vm.expectRevert(abi.encodeWithSelector(GasTankDepositor.NotThisEOA.selector, rpcService, alice));
-        GasTankDepositor(payable(alice)).fundGasTank(MINIMUM_DEPOSIT);
+        GasTankDepositor(payable(alice)).fundGasTank(MAXIMUM_DEPOSIT);
     }
 
     function testEOAFundRevertsWhenInsufficientBalance() public {
-        vm.deal(alice, MINIMUM_DEPOSIT - 1);
+        vm.deal(alice, MAXIMUM_DEPOSIT - 1);
         _delegate();
 
         vm.prank(alice);
         vm.expectRevert(
-            abi.encodeWithSelector(GasTankDepositor.InsufficientFunds.selector, MINIMUM_DEPOSIT - 1, MINIMUM_DEPOSIT)
+            abi.encodeWithSelector(GasTankDepositor.InsufficientFunds.selector, MAXIMUM_DEPOSIT - 1, MAXIMUM_DEPOSIT)
         );
-        GasTankDepositor(payable(alice)).fundGasTank(MINIMUM_DEPOSIT);
+        GasTankDepositor(payable(alice)).fundGasTank(MAXIMUM_DEPOSIT);
     }
 
     //=======================HELPERS=======================