Merge branch 'eth-infinitism:develop' into develop

Author: Reallyfe

.depcheckrc

@@ -0,0 +1 @@
+ignores: ["@openzeppelin/contracts", "@uniswap/v3-periphery", " @typechain/ethers-v5" ]

.github/workflows/build.yml

@@ -17,11 +17,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: '22'
-      - uses: actions/checkout@v1
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           path: node_modules
           key: ${{ runner.os }}-${{ hashFiles('yarn.lock') }}
@@ -35,11 +35,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: '22'
-      - uses: actions/checkout@v1
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/cache@v4
         with:
           path: node_modules
           key: ${{ runner.os }}-${{ hashFiles('yarn.lock') }}
@@ -50,25 +52,30 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: '22'
-      - uses: actions/checkout@v1
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/cache@v4
         with:
           path: node_modules
           key: ${{ runner.os }}-${{ hashFiles('yarn.lock') }}
       - run: yarn install
+      - run: yarn depcheck
       - run: yarn lint
 
   coverage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: '22'
-      - uses: actions/checkout@v1
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/cache@v4
         with:
           path: node_modules
           key: ${{ runner.os }}-${{ hashFiles('yarn.lock') }}

.solcover.js

@@ -1,8 +1,8 @@
 module.exports = {
   skipFiles: [
     "test",
-    "samples/bls/lib",
-    "utils/Exec.sol"
+    "utils/Exec.sol",
+    "samples"
   ],
   configureYulOptimizer: true,
 };

contracts/accounts/Simple7702Account.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import "@openzeppelin/contracts/interfaces/IERC1271.sol";
+import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "../core/Helpers.sol";
+import "../core/BaseAccount.sol";
+
+/**
+ * Simple7702Account.sol
+ * A minimal account to be used with EIP-7702 (for batching) and ERC-4337 (for gas sponsoring)
+ */
+contract Simple7702Account is BaseAccount, IERC165, IERC1271, ERC1155Holder, ERC721Holder {
+
+    // temporary address of entryPoint v0.8
+    function entryPoint() public pure override returns (IEntryPoint) {
+        return IEntryPoint(0xda853D8f693A836b2Ac48becC76d1d2e9BDCd1B3);
+    }
+
+    /**
+     * Make this account callable through ERC-4337 EntryPoint.
+     * The UserOperation should be signed by this account's private key.
+     */
+    function _validateSignature(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual override returns (uint256 validationData) {
+
+        return _checkSignature(userOpHash, userOp.signature) ? 0 : SIG_VALIDATION_FAILED;
+    }
+
+    function isValidSignature(bytes32 hash, bytes memory signature) public view returns (bytes4 magicValue) {
+        return _checkSignature(hash, signature) ? this.isValidSignature.selector : bytes4(0);
+    }
+
+    function _checkSignature(bytes32 hash, bytes memory signature) internal view returns (bool) {
+        return ECDSA.recover(hash, signature) == address(this);
+    }
+
+    function _requireForExecute() internal view virtual override {
+        require(
+            msg.sender == address(this) ||
+            msg.sender == address(entryPoint()),
+            "not from self or EntryPoint"
+        );
+    }
+
+    function supportsInterface(bytes4 id) public override(ERC1155Holder, IERC165) pure returns (bool) {
+        return
+            id == type(IERC165).interfaceId ||
+            id == type(IAccount).interfaceId ||
+            id == type(IERC1271).interfaceId ||
+            id == type(IERC1155Receiver).interfaceId ||
+            id == type(IERC721Receiver).interfaceId;
+    }
+
+    // accept incoming calls (with or without value), to mimic an EOA.
+    fallback() external payable {
+    }
+
+    receive() external payable {
+    }
+}

contracts/samples/SimpleAccount.sol renamed to contracts/accounts/SimpleAccount.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
 /* solhint-disable avoid-low-level-calls */
@@ -49,38 +49,6 @@ contract SimpleAccount is BaseAccount, TokenCallbackHandler, UUPSUpgradeable, In
         require(msg.sender == owner || msg.sender == address(this), "only owner");
     }
 
-    /**
-     * execute a transaction (called directly from owner, or by entryPoint)
-     * @param dest destination address to call
-     * @param value the value to pass in this call
-     * @param func the calldata to pass in this call
-     */
-    function execute(address dest, uint256 value, bytes calldata func) external {
-        _requireFromEntryPointOrOwner();
-        _call(dest, value, func);
-    }
-
-    /**
-     * execute a sequence of transactions
-     * @dev to reduce gas consumption for trivial case (no value), use a zero-length array to mean zero value
-     * @param dest an array of destination addresses
-     * @param value an array of values to pass to each call. can be zero-length for no-value calls
-     * @param func an array of calldata to pass to each call
-     */
-    function executeBatch(address[] calldata dest, uint256[] calldata value, bytes[] calldata func) external {
-        _requireFromEntryPointOrOwner();
-        require(dest.length == func.length && (value.length == 0 || value.length == func.length), "wrong array lengths");
-        if (value.length == 0) {
-            for (uint256 i = 0; i < dest.length; i++) {
-                _call(dest[i], 0, func[i]);
-            }
-        } else {
-            for (uint256 i = 0; i < dest.length; i++) {
-                _call(dest[i], value[i], func[i]);
-            }
-        }
-    }
-
     /**
      * @dev The _entryPoint member is immutable, to reduce gas consumption.  To upgrade EntryPoint,
      * a new implementation of SimpleAccount must be deployed with the new EntryPoint address, then upgrading
@@ -97,7 +65,7 @@ contract SimpleAccount is BaseAccount, TokenCallbackHandler, UUPSUpgradeable, In
     }
 
     // Require the function call went through EntryPoint or owner
-    function _requireFromEntryPointOrOwner() internal view {
+    function _requireForExecute() internal view override virtual {
         require(msg.sender == address(entryPoint()) || msg.sender == owner, "account: not Owner or EntryPoint");
     }
 
@@ -111,15 +79,6 @@ contract SimpleAccount is BaseAccount, TokenCallbackHandler, UUPSUpgradeable, In
         return SIG_VALIDATION_SUCCESS;
     }
 
-    function _call(address target, uint256 value, bytes memory data) internal {
-        (bool success, bytes memory result) = target.call{value: value}(data);
-        if (!success) {
-            assembly {
-                revert(add(result, 32), mload(result))
-            }
-        }
-    }
-
     /**
      * check current account deposit in the entryPoint
      */

contracts/samples/SimpleAccountFactory.sol renamed to contracts/accounts/SimpleAccountFactory.sol

@@ -1,11 +1,13 @@
-// SPDX-License-Identifier: GPL-3.0
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
 /* solhint-disable avoid-low-level-calls */
 /* solhint-disable no-empty-blocks */
+/* solhint-disable no-inline-assembly */
 
 import "../interfaces/IAccount.sol";
 import "../interfaces/IEntryPoint.sol";
+import "../utils/Exec.sol";
 import "./UserOperationLib.sol";
 
 /**
@@ -16,6 +18,14 @@ import "./UserOperationLib.sol";
 abstract contract BaseAccount is IAccount {
     using UserOperationLib for PackedUserOperation;
 
+    struct Call {
+        address target;
+        uint256 value;
+        bytes data;
+    }
+
+    error ExecuteError(uint256 index, bytes error);
+
     /**
      * Return the account nonce.
      * This method returns the next sequential nonce.
@@ -31,6 +41,40 @@ abstract contract BaseAccount is IAccount {
      */
     function entryPoint() public view virtual returns (IEntryPoint);
 
+    /**
+     * execute a single call from the account.
+     */
+    function execute(address target, uint256 value, bytes calldata data) virtual external {
+        _requireForExecute();
+
+        bool ok = Exec.call(target, value, data, gasleft());
+        if (!ok) {
+            Exec.revertWithReturnData();
+        }
+    }
+
+    /**
+     * execute a batch of calls.
+     * revert on the first call that fails.
+     * If the batch reverts, and it contains more than a single call, then wrap the revert with ExecuteError,
+     *  to mark the failing call index.
+     */
+    function executeBatch(Call[] calldata calls) external {
+        _requireForExecute();
+
+        for (uint256 i = 0; i < calls.length; i++) {
+            Call calldata call = calls[i];
+            bool ok = Exec.call(call.target, call.value, call.data, gasleft());
+            if (!ok) {
+                if (calls.length == 1) {
+                    Exec.revertWithReturnData();
+                } else {
+                    revert ExecuteError(i, Exec.getReturnData(0));
+                }
+            }
+        }
+    }
+
     /// @inheritdoc IAccount
     function validateUserOp(
         PackedUserOperation calldata userOp,
@@ -53,6 +97,10 @@ abstract contract BaseAccount is IAccount {
         );
     }
 
+    function _requireForExecute() internal view virtual {
+        _requireFromEntryPoint();
+    }
+
     /**
      * Validate the signature is valid for this message.
      * @param userOp          - Validate the userOp.signature field.
@@ -102,9 +150,9 @@ abstract contract BaseAccount is IAccount {
      */
     function _payPrefund(uint256 missingAccountFunds) internal virtual {
         if (missingAccountFunds != 0) {
-            (bool success, ) = payable(msg.sender).call{
-                value: missingAccountFunds
-            }("");
+            (bool success,) = payable(msg.sender).call{
+                    value: missingAccountFunds
+                }("");
             (success);
             //ignore failure (its EntryPoint's job to verify, not account.)
         }

contracts/samples/callback/TokenCallbackHandler.sol renamed to contracts/accounts/callback/TokenCallbackHandler.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-3.0
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
 /* solhint-disable reason-string */

contracts/core/BaseAccount.sol

@@ -0,0 +1,67 @@
+pragma solidity ^0.8;
+// SPDX-License-Identifier: MIT
+// solhint-disable no-inline-assembly
+
+import "../interfaces/PackedUserOperation.sol";
+import "../core/UserOperationLib.sol";
+
+library Eip7702Support {
+
+    // EIP-7702 code prefix before delegate address.
+    bytes3 internal constant EIP7702_PREFIX = 0xef0100;
+
+    // EIP-7702 initCode marker, to specify this account is EIP-7702.
+    bytes2 internal constant INITCODE_EIP7702_MARKER = 0x7702;
+
+    using UserOperationLib for PackedUserOperation;
+
+    //get alternate InitCodeHash (just for UserOp hash) when using EIP-7702
+    function _getEip7702InitCodeHashOverride(PackedUserOperation calldata userOp) internal view returns (bytes32) {
+        bytes calldata initCode = userOp.initCode;
+        if (!_isEip7702InitCode(initCode)) {
+            return 0;
+        }
+        address delegate = _getEip7702Delegate(userOp.getSender());
+        if (initCode.length <= 20)
+            return keccak256(abi.encodePacked(delegate));
+        else
+            return keccak256(abi.encodePacked(delegate, initCode[20 :]));
+    }
+
+    // check if this initCode is EIP-7702: starts with INITCODE_EIP7702_MARKER.
+    function _isEip7702InitCode(bytes calldata initCode) internal pure returns (bool) {
+
+        if (initCode.length < 2) {
+            return false;
+        }
+        bytes20 initCodeStart;
+        // non-empty calldata bytes are always zero-padded to 32-bytes, so can be safely casted to "bytes20"
+        assembly ("memory-safe") {
+            initCodeStart := calldataload(initCode.offset)
+        }
+        // make sure first 20 bytes of initCode are "0x7702" (padded with zeros)
+        return initCodeStart == bytes20(INITCODE_EIP7702_MARKER);
+    }
+
+    /**
+     * get the EIP-7702 delegate from contract code.
+     * must only be used if _isEip7702InitCode(initCode) is true.
+     */
+    function _getEip7702Delegate(address sender) internal view returns (address) {
+
+        bytes32 senderCode;
+
+        assembly ("memory-safe") {
+            extcodecopy(sender, 0, 0, 23)
+            senderCode := mload(0)
+        }
+        // To be a valid EIP-7702 delegate, the first 3 bytes are EIP7702_PREFIX
+        // followed by the delegate address
+        if (bytes3(senderCode) != EIP7702_PREFIX) {
+            // instead of just "not an EIP-7702 delegate", if some info.
+            require(sender.code.length > 0, "sender has no code");
+            revert("not an EIP-7702 delegate");
+        }
+        return address(bytes20(senderCode << 24));
+    }
+}