AA-521 EntryPoint support for eip-7702

.solcover.js

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

contracts/core/Eip7702Support.sol

@@ -0,0 +1,65 @@
+pragma solidity ^0.8;
+
+import "../interfaces/PackedUserOperation.sol";
+import "../core/UserOperationLib.sol";
+// SPDX-License-Identifier: MIT
+
+// EIP-7702 code prefix. Also, we use this prefix as a marker in the initCode. To specify this account is EIP-7702.
+uint256 constant EIP7702_PREFIX = 0xef0100;
+
+    using UserOperationLib for PackedUserOperation;
+
+//get alternate InitCodeHash (just for UserOp hash) when using EIP-7702
+    function _getEip7702InitCodeHashOverride(PackedUserOperation calldata userOp) 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 :]));
+    }
+
+
+    function _isEip7702InitCode(bytes calldata initCode) pure returns (bool) {
+
+        if (initCode.length < 2) {
+            return false;
+        }
+        uint256 initCodeStart;
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            initCodeStart := calldataload(initCode.offset)
+        }
+        // make sure first 20 bytes of initCode are "0xff0100" (padded with zeros)
+        // initCode can be shorter (e.g. only 3), but then it is already zero-padded.
+        return (initCodeStart >> (256 - 160)) == ((EIP7702_PREFIX << (160 - 24)));
+    }
+
+/**
+ * get the EIP-7702 delegate from contract code.
+ * requires EXTCODECOPY pr: https://github.com/ethereum/EIPs/pull/9248 (not yet merged or implemented)
+ **/
+    function _getEip7702Delegate(address sender) view returns (address) {
+
+        uint256 senderCode;
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly ("memory-safe") {
+            extcodecopy(sender, 0, 0, 32)
+            senderCode := mload(0)
+        }
+        // senderCode is the first 32 bytes of the sender's code
+        // If it is an EIP-7702 delegate, then top 24 bits are the EIP7702_PREFIX
+        // next 160 bytes are the delegate address
+        if (senderCode >> (256 - 24) != EIP7702_PREFIX) {
+            // instead of just "not an EIP-7702 delegate", if some info.
+            require(sender.code.length > 0, "sender has no code");
+            //temp: sanity check for current EIP-7702 implementation.
+            require(sender.code.length == 23, "EIP-7702 delegate-length");
+            revert("not an EIP-7702 delegate");
+        }
+        return address(uint160(senderCode >> (256 - 160 - 24)));
+    }

contracts/core/EntryPoint.sol

@@ -14,6 +14,7 @@ import "./NonceManager.sol";
 import "./SenderCreator.sol";
 import "./StakeManager.sol";
 import "./UserOperationLib.sol";
+import "./Eip7702Support.sol";
 
 import "@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol";
 import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
@@ -378,8 +379,9 @@ contract EntryPoint is IEntryPoint, StakeManager, NonceManager, ReentrancyGuardT
     function getUserOpHash(
         PackedUserOperation calldata userOp
     ) public view returns (bytes32) {
+        bytes32 overrideInitCodeHash = _getEip7702InitCodeHashOverride(userOp);
         return
-            MessageHashUtils.toTypedDataHash(getDomainSeparatorV4(), userOp.hash());
+            MessageHashUtils.toTypedDataHash(getDomainSeparatorV4(), userOp.hash(overrideInitCodeHash));
     }
 
     /**
@@ -441,6 +443,13 @@ contract EntryPoint is IEntryPoint, StakeManager, NonceManager, ReentrancyGuardT
     ) internal {
         if (initCode.length != 0) {
             address sender = opInfo.mUserOp.sender;
+            if ( _isEip7702InitCode(initCode) ) {
+                if (initCode.length>20 ) {
+                    //already validated it is an EIP-7702 delegate (and hence, already has code)
+                    senderCreator().initEip7702Sender(sender, initCode[20:]);
+                }
+                return;
+            }
             if (sender.code.length != 0)
                 revert FailedOp(opIndex, "AA10 sender already constructed");
             address sender1 = senderCreator().createSender{

contracts/core/EntryPointSimulations.sol

@@ -215,4 +215,7 @@ contract EntryPointSimulations is EntryPoint, IEntryPointSimulations {
         return __domainSeparatorV4;
     }
 
+    function supportsInterface(bytes4) public view virtual override returns (bool) {
+        return false;
+    }
 }

contracts/core/SenderCreator.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.23;
 
 import "../interfaces/ISenderCreator.sol";
+import "../utils/Exec.sol";
+import {IEntryPoint} from "../interfaces/IEntryPoint.sol";
 
 /**
  * Helper contract for EntryPoint, to call userOp.initCode from a "neutral" address,
@@ -23,10 +25,9 @@ contract SenderCreator is ISenderCreator {
     function createSender(
         bytes calldata initCode
     ) external returns (address sender) {
-        if (msg.sender != entryPoint) {
-            revert("AA97 should call from EntryPoint");
-        }
+        require(msg.sender == entryPoint, "AA97 should call from EntryPoint");
         address factory = address(bytes20(initCode[0:20]));
+
         bytes memory initCallData = initCode[20:];
         bool success;
         /* solhint-disable no-inline-assembly */
@@ -40,10 +41,24 @@ contract SenderCreator is ISenderCreator {
                 0,
                 32
             )
-            sender := mload(0)
+            if success {
+                sender := mload(0)
+            }
         }
+    }
+
+    // use initCode to initialize an EIP-7702 account
+    // caller (EntryPoint) already verified it is an EIP-7702 account.
+    function initEip7702Sender(
+        address sender,
+        bytes calldata initCallData
+    ) external {
+        require(msg.sender == entryPoint, "AA97 should call from EntryPoint");
+        // solhint-disable-next-line avoid-low-level-calls
+        bool success = Exec.call(sender, 0, initCallData, gasleft());
         if (!success) {
-            sender = address(0);
+            bytes memory result = Exec.getReturnData(2048);
+            revert IEntryPoint.FailedOpWithRevert(0,"AA13 EIP7702 sender init failed", result);
         }
     }
 }

contracts/core/UserOperationLib.sol

@@ -55,13 +55,15 @@ library UserOperationLib {
     /**
      * Pack the user operation data into bytes for hashing.
      * @param userOp - The user operation data.
+     * @param overrideInitCodeHash - If set, encode this instead of the initCode field in the userOp.
      */
     function encode(
-        PackedUserOperation calldata userOp
+        PackedUserOperation calldata userOp,
+        bytes32 overrideInitCodeHash
     ) internal pure returns (bytes memory ret) {
         address sender = getSender(userOp);
         uint256 nonce = userOp.nonce;
-        bytes32 hashInitCode = calldataKeccak(userOp.initCode);
+        bytes32 hashInitCode = overrideInitCodeHash != 0 ? overrideInitCodeHash : calldataKeccak(userOp.initCode);
         bytes32 hashCallData = calldataKeccak(userOp.callData);
         bytes32 accountGasLimits = userOp.accountGasLimits;
         uint256 preVerificationGas = userOp.preVerificationGas;
@@ -136,10 +138,12 @@ library UserOperationLib {
     /**
      * Hash the user operation data.
      * @param userOp - The user operation data.
+     * @param overrideInitCodeHash - If set, the initCode hash will be replaced with this value just for UserOp hashing.
      */
     function hash(
-        PackedUserOperation calldata userOp
+        PackedUserOperation calldata userOp,
+        bytes32 overrideInitCodeHash
     ) internal pure returns (bytes32) {
-        return keccak256(encode(userOp));
+        return keccak256(encode(userOp, overrideInitCodeHash));
     }
 }

contracts/interfaces/ISenderCreator.sol

@@ -8,4 +8,7 @@ interface ISenderCreator {
      * @return sender Address of the newly created sender contract.
      */
     function createSender(bytes calldata initCode) external returns (address sender);
+
+    // call initCode to initialize an EIP-7702 account
+    function initEip7702Sender(address sender, bytes calldata initCode) external;
 }

contracts/samples/Simple7702Account.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+// based on: https://gist.github.com/frangio/e40305b9f99de290b73750dff5ebe50a
+pragma solidity ^0.8;
+
+import "../interfaces/PackedUserOperation.sol";
+import "../core/Helpers.sol";
+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/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(0x6F4F5099a64044D69EB7419d66760fD4106fcE3C);
+    }
+
+    /**
+     * 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) {
+
+        if (address(this) != ECDSA.recover(userOpHash, userOp.signature)) {
+            return SIG_VALIDATION_FAILED;
+        }
+        return 0;
+    }
+
+    function _requireFromSelfOrEntryPoint() internal view virtual {
+        require(
+            msg.sender == address(this) ||
+            msg.sender == address(entryPoint()),
+            "not from self or EntryPoint"
+        );
+    }
+
+    struct Call {
+        address target;
+        uint256 value;
+        bytes data;
+    }
+
+    function execute(Call[] calldata calls) external {
+        _requireFromSelfOrEntryPoint();
+
+        for (uint256 i = 0; i < calls.length; i++) {
+            Call calldata call = calls[i];
+            (bool ok, bytes memory ret) = call.target.call{value: call.value}(call.data);
+            if (!ok) {
+                // solhint-disable-next-line no-inline-assembly
+                assembly { revert(add(ret, 32), mload(ret)) }
+            }
+        }
+    }
+
+    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;
+    }
+
+    //deliberately return the same signature as returned by the EOA itself: This way,
+    // ERC-1271 can be used regardless if the account currently has this code or not.
+    function isValidSignature(bytes32 hash, bytes memory signature) public view returns (bytes4 magicValue) {
+        return ECDSA.recover(hash, signature) == address(this) ? this.isValidSignature.selector : bytes4(0);
+    }
+
+    receive() external payable {
+    }
+}

contracts/test/TestEip7702DelegateAccount.sol

@@ -0,0 +1,53 @@
+pragma solidity ^0.8.23;
+// SPDX-License-Identifier: MIT
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "../core/BaseAccount.sol";
+import "../core/Eip7702Support.sol";
+
+contract TestEip7702DelegateAccount is BaseAccount {
+
+    IEntryPoint private immutable _entryPoint;
+    bool public testInitCalled;
+
+    constructor(IEntryPoint anEntryPoint) {
+        _entryPoint = anEntryPoint;
+    }
+
+    function testInit() public {
+        testInitCalled = true;
+    }
+
+    function entryPoint() public view override virtual returns (IEntryPoint) {
+        return _entryPoint;
+    }
+
+    // Require the function call went through EntryPoint or owner
+    function _requireFromEntryPointOrOwner() internal view {
+        require(msg.sender == address(this) || msg.sender == address(entryPoint()), "account: not Owner or EntryPoint");
+    }
+
+    /**
+     * 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();
+        (bool success,) = dest.call{value: value}(func);
+        require(success, "call failed");
+    }
+
+    function _validateSignature(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash
+    ) internal virtual override returns (uint256 validationData) {
+        if (userOp.initCode.length > 20) {
+            require(testInitCalled, "testInit not called");
+        }
+        if (ECDSA.recover(userOpHash, userOp.signature) == address(this)) {
+            return 0;
+        }
+        return 1;
+    }
+}

contracts/test/TestUtil.sol

@@ -2,13 +2,16 @@
 pragma solidity ^0.8.23;
 
 import "../interfaces/PackedUserOperation.sol";
-import "../core/UserOperationLib.sol";
+import "../core/Eip7702Support.sol";
 
 contract TestUtil {
     using UserOperationLib for PackedUserOperation;
 
     function encodeUserOp(PackedUserOperation calldata op) external pure returns (bytes memory){
-        return op.encode();
+        return op.encode(0);
     }
 
+    function isEip7702InitCode(bytes calldata initCode) external pure returns (bool) {
+        return _isEip7702InitCode(initCode);
+    }
 }