feat: implement dynamic lifetime fee and withdrawal functionality for deployer

Author: KazanderDad

contracts/src/FeeGate.sol

@@ -36,8 +36,10 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
     using ECDSA for bytes32;
 
     // Constants
-    uint256 public constant LIFETIME_FEE = 100 ether; // 100 GLMR
     uint256 public constant FEE_THRESHOLD = 3; // Fee charged on 3rd attestation
+
+    // Mutable state
+    uint256 public lifetimeFee = 100 ether; // 100 GLMR (can be updated by deployer)
     bytes32 public constant ATTESTATION_TYPEHASH =
         keccak256(
             'Attestation(address issuer,address recipient,bytes32 refUID,bool revocable,uint64 expirationTime,'
@@ -48,6 +50,7 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
     // Immutable state
     IEAS public immutable eas;
     bytes32 public immutable schemaUID;
+    address public immutable deployer;
 
     // Per-issuer state
     mapping(address => uint256) public attestCount;
@@ -62,6 +65,7 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
     event FeeCharged(address indexed issuer, uint256 amount, uint256 count);
     event NonceIncremented(address indexed issuer, uint256 newNonce);
     event LastUIDAnchorSet(address indexed issuer, string cubidId, bytes32 uid);
+    event FeeUpdated(uint256 oldFee, uint256 newFee);
 
     // Errors
     error InvalidNonce();
@@ -73,6 +77,9 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
     error InvalidRecipient();
     error InvalidIssuer();
     error NotImplemented();
+    error OnlyDeployer();
+    error WithdrawalFailed();
+    error InvalidFee();
 
     /**
      * @param _eas Address of the EAS contract
@@ -82,6 +89,7 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
         if (address(_eas) == address(0)) revert InvalidEAS();
         eas = _eas;
         schemaUID = _schemaUID;
+        deployer = msg.sender;
     }
 
     /**
@@ -290,6 +298,32 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
         return '1.0.0';
     }
 
+    /**
+     * @notice Withdraw all accumulated fees to the deployer
+     * @dev Only callable by the deployer address
+     */
+    function withdraw() external nonReentrant {
+        if (msg.sender != deployer) revert OnlyDeployer();
+
+        uint256 balance = address(this).balance;
+        (bool success, ) = deployer.call{value: balance}('');
+        if (!success) revert WithdrawalFailed();
+    }
+
+    /**
+     * @notice Update the lifetime fee amount
+     * @dev Only callable by the deployer address
+     * @param newFee The new lifetime fee amount in wei
+     */
+    function setLifetimeFee(uint256 newFee) external {
+        if (msg.sender != deployer) revert OnlyDeployer();
+        if (newFee == 0) revert InvalidFee();
+
+        uint256 oldFee = lifetimeFee;
+        lifetimeFee = newFee;
+        emit FeeUpdated(oldFee, newFee);
+    }
+
     receive() external payable {}
 
     // Internal helpers
@@ -327,7 +361,7 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
             if (newCount < FEE_THRESHOLD) {
                 if (supplied != 0) revert UnexpectedValue();
             } else if (newCount == FEE_THRESHOLD) {
-                if (supplied != LIFETIME_FEE) revert InsufficientFee();
+                if (supplied != lifetimeFee) revert InsufficientFee();
             } else {
                 revert InsufficientFee();
             }
@@ -346,7 +380,7 @@ contract FeeGate is ISchemaResolver, EIP712, ReentrancyGuard {
         bool paid = lifetimeFeePaid[issuer];
         if (!paid && newCount == FEE_THRESHOLD) {
             lifetimeFeePaid[issuer] = true;
-            emit FeeCharged(issuer, LIFETIME_FEE, newCount);
+            emit FeeCharged(issuer, lifetimeFee, newCount);
         }
     }
 }

contracts/test/FeeGate.t.sol

@@ -19,6 +19,8 @@ contract FeeGateTest is Test {
     address public issuer = vm.addr(ISSUER_KEY);
     address public recipient = address(0xBEEF);
 
+    receive() external payable {}
+
     string constant SCHEMA =
         'string cubidId,uint8 trustLevel,bool human,bytes32 circle,uint64 issuedAt,uint64 expiry,uint256 nonce';
 
@@ -113,13 +115,13 @@ contract FeeGateTest is Test {
         vm.stopPrank();
 
         vm.startPrank(issuer);
-        bytes32 uid = feeGate.attestDirect{value: feeGate.LIFETIME_FEE()}(_payload('cubidC', 6));
+        bytes32 uid = feeGate.attestDirect{value: feeGate.lifetimeFee()}(_payload('cubidC', 6));
         vm.stopPrank();
 
         assertEq(feeGate.attestCount(issuer), 3);
         assertTrue(feeGate.hasPaidFee(issuer));
         assertEq(feeGate.getLastUID(issuer, 'cubidC'), uid);
-        assertEq(address(feeGate).balance, feeGate.LIFETIME_FEE());
+        assertEq(address(feeGate).balance, feeGate.lifetimeFee());
 
         // fourth attestation requires no additional fee
         AttestationPayload memory payloadFourth = _payload('cubidD', 7);
@@ -136,7 +138,7 @@ contract FeeGateTest is Test {
 
         assertEq(feeGate.attestCount(issuer), 4);
         assertTrue(feeGate.hasPaidFee(issuer));
-        assertEq(address(feeGate).balance, feeGate.LIFETIME_FEE());
+        assertEq(address(feeGate).balance, feeGate.lifetimeFee());
     }
 
     function testInsufficientFeeDelegatedReverts() public {
@@ -169,6 +171,68 @@ contract FeeGateTest is Test {
         assertEq(feeGate.getLastUID(issuer, 'cubidX'), latestUID);
     }
 
+    function testSetLifetimeFeeByDeployer() public {
+        uint256 oldFee = feeGate.lifetimeFee();
+        assertEq(oldFee, 100 ether);
+
+        uint256 newFee = 50 ether;
+        feeGate.setLifetimeFee(newFee);
+
+        assertEq(feeGate.lifetimeFee(), newFee);
+
+        // Verify new fee is enforced
+        vm.startPrank(issuer);
+        feeGate.attestDirect(_payload('cubid1', 5));
+        feeGate.attestDirect(_payload('cubid2', 5));
+
+        // Third attestation should now require the new fee amount
+        vm.expectRevert(FeeGate.InsufficientFee.selector);
+        feeGate.attestDirect{value: oldFee}(_payload('cubid3', 6));
+
+        // Should succeed with new fee
+        feeGate.attestDirect{value: newFee}(_payload('cubid3', 6));
+        vm.stopPrank();
+
+        assertTrue(feeGate.hasPaidFee(issuer));
+        assertEq(address(feeGate).balance, newFee);
+    }
+
+    function testSetLifetimeFeeRevertsForNonDeployer() public {
+        vm.prank(issuer);
+        vm.expectRevert(FeeGate.OnlyDeployer.selector);
+        feeGate.setLifetimeFee(50 ether);
+    }
+
+    function testSetLifetimeFeeRevertsForZero() public {
+        vm.expectRevert(FeeGate.InvalidFee.selector);
+        feeGate.setLifetimeFee(0);
+    }
+
+    function testWithdrawByDeployer() public {
+        // Setup: get issuer to pay fee
+        vm.startPrank(issuer);
+        feeGate.attestDirect(_payload('cubid1', 5));
+        feeGate.attestDirect(_payload('cubid2', 5));
+        feeGate.attestDirect{value: feeGate.lifetimeFee()}(_payload('cubid3', 6));
+        vm.stopPrank();
+
+        uint256 contractBalance = address(feeGate).balance;
+        assertEq(contractBalance, 100 ether);
+
+        uint256 deployerBalanceBefore = address(this).balance;
+        feeGate.withdraw();
+        uint256 deployerBalanceAfter = address(this).balance;
+
+        assertEq(address(feeGate).balance, 0);
+        assertEq(deployerBalanceAfter - deployerBalanceBefore, contractBalance);
+    }
+
+    function testWithdrawRevertsForNonDeployer() public {
+        vm.prank(issuer);
+        vm.expectRevert(FeeGate.OnlyDeployer.selector);
+        feeGate.withdraw();
+    }
+
     function _payload(
         string memory cubidId,
         uint8 trustLevel