Upgrade to EntryPoint 0.7

src/CoinbaseSmartWallet.sol

@@ -3,7 +3,8 @@ pragma solidity 0.8.23;
 
 import {IAccount} from "account-abstraction/interfaces/IAccount.sol";
 
-import {UserOperation, UserOperationLib} from "account-abstraction/interfaces/UserOperation.sol";
+import {UserOperationLib} from "account-abstraction/core/UserOperationLib.sol";
+import {PackedUserOperation} from "account-abstraction/interfaces/PackedUserOperation.sol";
 import {Receiver} from "solady/accounts/Receiver.sol";
 import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
 import {UUPSUpgradeable} from "solady/utils/UUPSUpgradeable.sol";
@@ -40,11 +41,12 @@ contract CoinbaseSmartWallet is ERC1271, IAccount, MultiOwnable, UUPSUpgradeable
         bytes data;
     }
 
-    /// @notice Reserved nonce key (upper 192 bits of `UserOperation.nonce`) for cross-chain replayable
+    /// @notice Reserved nonce key (upper 192 bits of `PackedUserOperation.nonce`) for cross-chain replayable
     ///         transactions.
     ///
-    /// @dev MUST BE the `UserOperation.nonce` key when `UserOperation.calldata` is calling
-    ///      `executeWithoutChainIdValidation`and MUST NOT BE `UserOperation.nonce` key when `UserOperation.calldata` is
+    /// @dev MUST BE the `PackedUserOperation.nonce` key when `PackedUserOperation.calldata` is calling
+    ///      `executeWithoutChainIdValidation`and MUST NOT BE `PackedUserOperation.nonce` key when
+    ///      `PackedUserOperation.calldata` is
     ///      NOT calling `executeWithoutChainIdValidation`.
     ///
     /// @dev Helps enforce sequential sequencing of replayable transactions.
@@ -59,12 +61,12 @@ contract CoinbaseSmartWallet is ERC1271, IAccount, MultiOwnable, UUPSUpgradeable
     /// @param selector The selector of the call.
     error SelectorNotAllowed(bytes4 selector);
 
-    /// @notice Thrown in validateUserOp if the key of `UserOperation.nonce` does not match the calldata.
+    /// @notice Thrown in validateUserOp if the key of `PackedUserOperation.nonce` does not match the calldata.
     ///
     /// @dev Calls to `this.executeWithoutChainIdValidation` MUST use `REPLAYABLE_NONCE_KEY` and
     ///      calls NOT to `this.executeWithoutChainIdValidation` MUST NOT use `REPLAYABLE_NONCE_KEY`.
     ///
-    /// @param key The invalid `UserOperation.nonce` key.
+    /// @param key The invalid `PackedUserOperation.nonce` key.
     error InvalidNonceKey(uint256 key);
 
     /// @notice Reverts if the caller is not the EntryPoint.
@@ -130,23 +132,24 @@ contract CoinbaseSmartWallet is ERC1271, IAccount, MultiOwnable, UUPSUpgradeable
     /// @inheritdoc IAccount
     ///
     /// @notice ERC-4337 `validateUserOp` method. The EntryPoint will
-    ///         call `UserOperation.sender.call(UserOperation.callData)` only if this validation call returns
-    ///         successfully.
+    ///         call `PackedUserOperation.sender.call(PackedUserOperation.callData)` only if this validation call
+    ///         returns successfully.
     ///
     /// @dev Signature failure should be reported by returning 1 (see: `this._isValidSignature`). This
     ///      allows making a "simulation call" without a valid signature. Other failures (e.g. invalid signature format)
     ///      should still revert to signal failure.
-    /// @dev Reverts if the `UserOperation.nonce` key is invalid for `UserOperation.calldata`.
+    /// @dev Reverts if the `PackedUserOperation.nonce` key is invalid for `PackedUserOperation.callData`.
     /// @dev Reverts if the signature format is incorrect or invalid for owner type.
     ///
-    /// @param userOp              The `UserOperation` to validate.
-    /// @param userOpHash          The `UserOperation` hash, as computed by `EntryPoint.getUserOpHash(UserOperation)`.
+    /// @param userOp              The `PackedUserOperation` to validate.
+    /// @param userOpHash          The `PackedUserOperation` hash, as computed by
+    ///                            `EntryPoint.getUserOpHash(PackedUserOperation)`.
     /// @param missingAccountFunds The missing account funds that must be deposited on the Entrypoint.
     ///
     /// @return validationData The encoded `ValidationData` structure:
     ///                        `(uint256(validAfter) << (160 + 48)) | (uint256(validUntil) << 160) | (success ? 0 : 1)`
     ///                        where `validUntil` is 0 (indefinite) and `validAfter` is 0.
-    function validateUserOp(UserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds)
+    function validateUserOp(PackedUserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds)
         external
         virtual
         onlyEntryPoint
@@ -180,7 +183,7 @@ contract CoinbaseSmartWallet is ERC1271, IAccount, MultiOwnable, UUPSUpgradeable
     /// @dev Can only be called by the Entrypoint.
     /// @dev Reverts if the given call is not authorized to skip the chain ID validtion.
     /// @dev `validateUserOp()` will recompute the `userOpHash` without the chain ID before validating
-    ///      it if the `UserOperation.calldata` is calling this function. This allows certain UserOperations
+    ///      it if the `PackedUserOperation.callData` is calling this function. This allows certain UserOperations
     ///      to be replayed for all accounts sharing the same address across chains. E.g. This may be
     ///      useful for syncing owner changes.
     ///
@@ -228,18 +231,18 @@ contract CoinbaseSmartWallet is ERC1271, IAccount, MultiOwnable, UUPSUpgradeable
     ///
     /// @return The address of the EntryPoint v0.6
     function entryPoint() public view virtual returns (address) {
-        return 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789;
+        return 0x0000000071727De22E5E9d8BAf0edAc6f37da032;
     }
 
-    /// @notice Computes the hash of the `UserOperation` in the same way as EntryPoint v0.6, but
+    /// @notice Computes the hash of the `PackedUserOperation` in the same way as EntryPoint v0.7, but
     ///         leaves out the chain ID.
     ///
     /// @dev This allows accounts to sign a hash that can be used on many chains.
     ///
-    /// @param userOp The `UserOperation` to compute the hash for.
+    /// @param userOp The `PackedUserOperation` to compute the hash for.
     ///
-    /// @return The `UserOperation` hash, which does not depend on chain ID.
-    function getUserOpHashWithoutChainId(UserOperation calldata userOp) public view virtual returns (bytes32) {
+    /// @return The `PackedUserOperation` hash, which does not depend on chain ID.
+    function getUserOpHashWithoutChainId(PackedUserOperation calldata userOp) public view virtual returns (bytes32) {
         return keccak256(abi.encode(UserOperationLib.hash(userOp), entryPoint()));
     }
 

test/CoinbaseSmartWallet/Execute.t.sol

@@ -12,7 +12,7 @@ contract TestExecuteWithoutChainIdValidation is SmartWalletTestBase {
 
     function test_revertsWithReservedNonce() public {
         userOpNonce = account.REPLAYABLE_NONCE_KEY() << 64;
-        UserOperation memory userOp = _getUserOpWithSignature();
+        PackedUserOperation memory userOp = _getUserOpWithSignature();
         vm.expectRevert();
         _sendUserOperation(userOp);
     }

test/CoinbaseSmartWallet/ExecuteWithoutChainIdValidation.t.sol

@@ -73,7 +73,7 @@ contract TestExecuteWithoutChainIdValidation is SmartWalletTestBase {
         account.executeWithoutChainIdValidation(calls);
     }
 
-    function _sign(UserOperation memory userOp) internal view override returns (bytes memory signature) {
+    function _sign(PackedUserOperation memory userOp) internal view override returns (bytes memory signature) {
         bytes32 toSign = account.getUserOpHashWithoutChainId(userOp);
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivateKey, toSign);
         signature = abi.encode(CoinbaseSmartWallet.SignatureWrapper(0, abi.encodePacked(r, s, v)));

test/CoinbaseSmartWallet/SmartWalletTestBase.sol

@@ -16,49 +16,47 @@ contract SmartWalletTestBase is Test {
     uint256 passkeyPrivateKey = uint256(0x03d99692017473e2d631945a812607b23269d85721e0f370b8d3e7d29a874fd2);
     bytes passkeyOwner =
         hex"1c05286fe694493eae33312f2d2e0d0abeda8db76238b7a204be1fb87f54ce4228fef61ef4ac300f631657635c28e59bfb2fe71bce1634c81c65642042f6dc4d";
-    IEntryPoint entryPoint = IEntryPoint(0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789);
+    IEntryPoint entryPoint = IEntryPoint(0x0000000071727De22E5E9d8BAf0edAc6f37da032);
     address bundler = address(uint160(uint256(keccak256(abi.encodePacked("bundler")))));
 
     // userOp values
     uint256 userOpNonce;
     bytes userOpCalldata;
 
     function setUp() public virtual {
-        vm.etch(0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789, Static.ENTRY_POINT_BYTES);
+        vm.etch(0x0000000071727De22E5E9d8BAf0edAc6f37da032, Static.ENTRY_POINT_BYTES);
         account = new MockCoinbaseSmartWallet();
         owners.push(abi.encode(signer));
         owners.push(passkeyOwner);
         account.initialize(owners);
     }
 
-    function _sendUserOperation(UserOperation memory userOp) internal {
-        UserOperation[] memory ops = new UserOperation[](1);
+    function _sendUserOperation(PackedUserOperation memory userOp) internal {
+        PackedUserOperation[] memory ops = new PackedUserOperation[](1);
         ops[0] = userOp;
         entryPoint.handleOps(ops, payable(bundler));
     }
 
-    function _getUserOp() internal view returns (UserOperation memory userOp) {
-        userOp = UserOperation({
+    function _getUserOp() internal view returns (PackedUserOperation memory userOp) {
+        userOp = PackedUserOperation({
             sender: address(account),
             nonce: userOpNonce,
             initCode: "",
             callData: userOpCalldata,
-            callGasLimit: uint256(1_000_000),
-            verificationGasLimit: uint256(1_000_000),
+            accountGasLimits: bytes32(abi.encodePacked(uint128(1_000_000), uint128(1_000_000))),
+            gasFees: bytes32(0),
             preVerificationGas: uint256(0),
-            maxFeePerGas: uint256(0),
-            maxPriorityFeePerGas: uint256(0),
             paymasterAndData: "",
             signature: ""
         });
     }
 
-    function _getUserOpWithSignature() internal view returns (UserOperation memory userOp) {
+    function _getUserOpWithSignature() internal view returns (PackedUserOperation memory userOp) {
         userOp = _getUserOp();
         userOp.signature = _sign(userOp);
     }
 
-    function _sign(UserOperation memory userOp) internal view virtual returns (bytes memory signature) {
+    function _sign(PackedUserOperation memory userOp) internal view virtual returns (bytes memory signature) {
         bytes32 toSign = entryPoint.getUserOpHash(userOp);
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivateKey, toSign);
         signature = abi.encodePacked(uint8(0), r, s, v);

test/CoinbaseSmartWallet/ValidateUserOp.t.sol

@@ -31,7 +31,7 @@ contract TestValidateUserOp is SmartWalletTestBase {
         vm.etch(account.entryPoint(), address(new MockEntryPoint()).code);
         MockEntryPoint ep = MockEntryPoint(payable(account.entryPoint()));
 
-        UserOperation memory userOp;
+        PackedUserOperation memory userOp;
         // Success returns 0.
         userOp.signature = abi.encode(CoinbaseSmartWallet.SignatureWrapper(0, abi.encodePacked(t.r, t.s, t.v)));
         assertEq(ep.validateUserOp(address(account), userOp, t.userOpHash, t.missingAccountFunds), 0);
@@ -72,14 +72,14 @@ contract TestValidateUserOp is SmartWalletTestBase {
         vm.etch(account.entryPoint(), address(new MockEntryPoint()).code);
         MockEntryPoint ep = MockEntryPoint(payable(account.entryPoint()));
 
-        UserOperation memory userOp;
+        PackedUserOperation memory userOp;
         // Success returns 0.
         userOp.signature = sig;
         assertEq(ep.validateUserOp(address(account), userOp, t.userOpHash, t.missingAccountFunds), 0);
     }
 
     function test_reverts_whenSelectorInvalidForReplayableNonceKey() public {
-        UserOperation memory userOp;
+        PackedUserOperation memory userOp;
         userOp.nonce = 0;
         userOp.callData = abi.encodeWithSelector(CoinbaseSmartWallet.executeWithoutChainIdValidation.selector, "");
         vm.startPrank(account.entryPoint());
@@ -88,7 +88,7 @@ contract TestValidateUserOp is SmartWalletTestBase {
     }
 
     function test_reverts_whenReplayableNonceKeyInvalidForSelector() public {
-        UserOperation memory userOp;
+        PackedUserOperation memory userOp;
         userOp.nonce = account.REPLAYABLE_NONCE_KEY() << 64;
         userOp.callData = abi.encodeWithSelector(CoinbaseSmartWallet.execute.selector, "");
         vm.startPrank(account.entryPoint());

test/mocks/MockEntryPoint.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.4;
 
-import {CoinbaseSmartWallet, UserOperation} from "../../src/CoinbaseSmartWallet.sol";
+import {CoinbaseSmartWallet, PackedUserOperation} from "../../src/CoinbaseSmartWallet.sol";
 
 contract MockEntryPoint {
     mapping(address => uint256) public balanceOf;
@@ -18,7 +18,7 @@ contract MockEntryPoint {
 
     function validateUserOp(
         address account,
-        UserOperation memory userOp,
+        PackedUserOperation memory userOp,
         bytes32 userOpHash,
         uint256 missingAccountFunds
     ) public payable returns (uint256 validationData) {