(test) Getters of Paymaster V3

Author: 0xkoiner

test/foundry/paymasterV3/AdminActionsTest.t.sol

@@ -5,14 +5,6 @@ pragma solidity ^0.8.29;
 import {BasePaymasterTest as Base} from "test/foundry/paymasterV3/BasePaymasterTest.t.sol";
 import {IStakeManager} from "lib/account-abstractionV8/contracts/interfaces/IStakeManager.sol";
 
-struct DepositInfo {
-    uint256 deposit;
-    bool staked;
-    uint112 stake;
-    uint32 unstakeDelaySec;
-    uint48 withdrawTime;
-}
-
 uint256 constant stakeAmount = 0.1 ether;
 uint32 constant unstakeDelay = 8600;
 

test/foundry/paymasterV3/BasePaymasterTest.t.sol

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.29;
 
+import {console2 as console} from "lib/forge-std/src/test.sol";
 import {PaymasterDataTest as Data} from "test/foundry/paymasterV3/PaymasterDataTest.t.sol";
 import {OPFPaymasterV3 as Paymaster} from "contracts/paymaster/PaymasterV3/OPFPaymasterV3.sol";
+import {PackedUserOperation} from "@account-abstraction-v8/interfaces/PackedUserOperation.sol";
 
 contract BasePaymasterTest is Data {
     Paymaster PM;
@@ -44,4 +46,34 @@ contract BasePaymasterTest is Data {
     function _warp(uint256 _time) internal {
         vm.warp(block.timestamp + _time);
     }
+
+    function _getHash(PackedUserOperation calldata _userOp, uint256 paymasterDataLength)
+        internal
+        view
+        returns (bytes32)
+    {
+        bytes32 userOpHash = keccak256(
+            abi.encode(
+                _getSender(_userOp),
+                _userOp.nonce,
+                _userOp.accountGasLimits,
+                _userOp.preVerificationGas,
+                _userOp.gasFees,
+                keccak256(_userOp.initCode),
+                keccak256(_userOp.callData),
+                keccak256(_userOp.paymasterAndData[:PAYMASTER_DATA_OFFSET + paymasterDataLength])
+            )
+        );
+
+        return keccak256(abi.encode(userOpHash, block.chainid));
+    }
+
+    function _getSender(PackedUserOperation calldata userOp) internal pure returns (address) {
+        address data;
+        //read sender from userOp, which is first userOp member (saves 800 gas...)
+        assembly {
+            data := calldataload(userOp)
+        }
+        return address(uint160(data));
+    }
 }

test/foundry/paymasterV3/GettersTest.t.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.29;
+
+import {IEntryPoint} from "@account-abstraction-v8/interfaces/IEntryPoint.sol";
+import {BasePaymasterTest as Base} from "test/foundry/paymasterV3/BasePaymasterTest.t.sol";
+import {PackedUserOperation} from "@account-abstraction-v8/interfaces/PackedUserOperation.sol";
+import {console2 as console} from "lib/forge-std/src/test.sol";
+
+contract GettersTest is Base {
+    function test_signerCount() public {
+        uint256 sC = _signerCount();
+        assertEq(sC, signers.length);
+    }
+
+    function test_signerAt() public {
+        uint256 sC = _signerCount();
+
+        for (uint256 i = 0; i < sC;) {
+            address signer = PM.signerAt(i);
+            assertEq(signer, signers[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function test_getSigners() public {
+        address[] memory getSigners = PM.getSigners();
+
+        for (uint256 i = 0; i < getSigners.length;) {
+            assertEq(getSigners[i], signers[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function test_OnwerAndManager() public {
+        address getOwner = PM.OWNER();
+        address getManager = PM.MANAGER();
+
+        assertEq(owner, getOwner);
+        assertEq(manager, getManager);
+    }
+
+    function test_getEP() public {
+        IEntryPoint EP = PM.ENTRY_POINT_V8();
+        assertEq(address(EP), address(ENTRY_POINT_V8));
+    }
+
+    function test_getDeposit() public {
+        uint256 getDeposit = PM.getDeposit();
+        assertEq(getDeposit, 0);
+    }
+
+    function test_getCostInToken() public {
+        uint256 _actualGasCost = 100_000;
+        uint256 _postOpGas = 80_000;
+        uint256 _actualUserOpFeePerGas = 200_000;
+        uint256 _exchangeRate = 4000_000;
+
+        uint256 actualRate = ((_actualGasCost + (_postOpGas * _actualUserOpFeePerGas)) * _exchangeRate) / 1e18;
+
+        uint256 getcost = PM.getCostInToken(_actualGasCost, _postOpGas, _actualUserOpFeePerGas, _exchangeRate);
+
+        assertEq(actualRate, getcost);
+    }
+
+    function test_getHashModeVERIFYING_MODE() public {
+        PackedUserOperation memory userOp = _getFreshUserOp();
+        bytes memory paymasterAndData =
+            new bytes(PAYMASTER_DATA_OFFSET + MODE_AND_ALLOW_ALL_BUNDLERS_LENGTH + VERIFYING_PAYMASTER_DATA_LENGTH);
+
+        bytes20 paymasterAddress = bytes20(address(PM));
+        for (uint256 i = 0; i < 20; i++) {
+            paymasterAndData[i] = paymasterAddress[i];
+        }
+
+        userOp.paymasterAndData = paymasterAndData;
+        this._testFetHashModeVERIFYING_MODE(userOp);
+    }
+
+    function _testFetHashModeVERIFYING_MODE(PackedUserOperation calldata _userOp) external {
+        bytes32 computeHash = _getHash(_userOp, MODE_AND_ALLOW_ALL_BUNDLERS_LENGTH + VERIFYING_PAYMASTER_DATA_LENGTH);
+        bytes32 hash = PM.getHash(uint8(0), _userOp);
+        assertEq(computeHash, hash);
+    }
+
+    function _signerCount() internal view returns (uint256 counter) {
+        counter = PM.signerCount();
+    }
+}

test/foundry/paymasterV3/PaymasterDataTest.t.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.29;
 
 import {Test} from "lib/forge-std/src/Test.sol";
 import {IEntryPoint} from "@account-abstraction-v8/interfaces/IEntryPoint.sol";
+import {UserOperationLib} from "@account-abstraction-v8/core/UserOperationLib.sol";
+import {PackedUserOperation} from "@account-abstraction-v8/interfaces/PackedUserOperation.sol";
 
 contract PaymasterDataTest is Test {
     IEntryPoint ENTRY_POINT_V8 = IEntryPoint(0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108);
@@ -14,16 +16,24 @@ contract PaymasterDataTest is Test {
     uint256[] signersPK;
     address[] signers;
 
+    uint256 senderPk;
+    address sender;
+
     uint256 constant signersLength = 3;
 
     uint256 forkId;
     string SEPOLIA_RPC_URL = "https://eth-sepolia.g.alchemy.com/v2/EIOmdDtOw7ulufI5S27isOfZfW51PQXB";
 
+    uint8 immutable VERIFYING_PAYMASTER_DATA_LENGTH = 12;
+    uint8 immutable MODE_AND_ALLOW_ALL_BUNDLERS_LENGTH = 1;
+    uint256 immutable PAYMASTER_DATA_OFFSET = UserOperationLib.PAYMASTER_DATA_OFFSET;
+
     function setUp() public virtual {
         forkId = vm.createFork(SEPOLIA_RPC_URL);
         vm.selectFork(forkId);
 
         (owner, ownerPK) = makeAddrAndKey("owner");
+        (sender, senderPk) = makeAddrAndKey("sender");
         (manager, managerPK) = makeAddrAndKey("manager");
 
         for (uint256 i = 0; i < signersLength;) {
@@ -35,4 +45,16 @@ contract PaymasterDataTest is Test {
             }
         }
     }
+
+    function _getFreshUserOp() internal view returns (PackedUserOperation memory userOp) {
+        userOp.sender = sender;
+        userOp.nonce = 0;
+        userOp.initCode = hex"";
+        userOp.callData = hex"";
+        userOp.accountGasLimits = hex"";
+        userOp.preVerificationGas = 0;
+        userOp.gasFees = hex"";
+        userOp.paymasterAndData = hex"";
+        userOp.signature = hex"";
+    }
 }