include actual interfaces for ICoinbaseSmartWallet (ourzora#457)

Author: oveddan

packages/smart-wallet/src/ZoraAccountManager.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 
 contract ZoraAccountManager is ERC1967Proxy {
-    constructor(address _logic, bytes memory _data) ERC1967Proxy(_logic, _data) { }
+    constructor(address _logic, bytes memory _data) ERC1967Proxy(_logic, _data) {}
 }

packages/smart-wallet/src/ZoraAccountManagerImpl.sol

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import { UUPSUpgradeable, ERC1967Utils } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {UUPSUpgradeable, ERC1967Utils} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
-import { IEntryPoint } from "./interfaces/IEntryPoint.sol";
-import { ISmartWalletFactory } from "./interfaces/ISmartWalletFactory.sol";
+import {IEntryPoint} from "./interfaces/IEntryPoint.sol";
+import {ICoinbaseSmartWalletFactory} from "./interfaces/ICoinbaseSmartWalletFactory.sol";
 
 contract ZoraAccountManagerImpl is UUPSUpgradeable, OwnableUpgradeable {
     IEntryPoint public constant entryPoint = IEntryPoint(0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789);
-    ISmartWalletFactory public constant smartWalletFactory = ISmartWalletFactory(0x0BA5ED0c6AA8c49038F819E587E2633c4A9F428a);
+    ICoinbaseSmartWalletFactory public constant smartWalletFactory = ICoinbaseSmartWalletFactory(0x0BA5ED0c6AA8c49038F819E587E2633c4A9F428a);
 
-    constructor() initializer { }
+    constructor() initializer {}
 
     function initialize(address initialOwner) public initializer {
         __Ownable_init(initialOwner);
@@ -51,5 +51,5 @@ contract ZoraAccountManagerImpl is UUPSUpgradeable, OwnableUpgradeable {
         return ERC1967Utils.getImplementation();
     }
 
-    function _authorizeUpgrade(address) internal override onlyOwner { }
+    function _authorizeUpgrade(address) internal override onlyOwner {}
 }

packages/smart-wallet/src/interfaces/IAccount.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.7.5;
+
+/**
+ * User Operation struct
+ * @param sender                - The sender account of this request.
+ * @param nonce                 - Unique value the sender uses to verify it is not a replay.
+ * @param initCode              - If set, the account contract will be created by this constructor/
+ * @param callData              - The method call to execute on this account.
+ * @param accountGasLimits      - Packed gas limits for validateUserOp and gas limit passed to the callData method call.
+ * @param preVerificationGas    - Gas not calculated by the handleOps method, but added to the gas paid.
+ *                                Covers batch overhead.
+ * @param gasFees               - packed gas fields maxPriorityFeePerGas and maxFeePerGas - Same as EIP-1559 gas parameters.
+ * @param paymasterAndData      - If set, this field holds the paymaster address, verification gas limit, postOp gas limit and paymaster-specific extra data
+ *                                The paymaster will pay for the transaction instead of the sender.
+ * @param signature             - Sender-verified signature over the entire request, the EntryPoint address and the chain ID.
+ */
+struct PackedUserOperation {
+    address sender;
+    uint256 nonce;
+    bytes initCode;
+    bytes callData;
+    bytes32 accountGasLimits;
+    uint256 preVerificationGas;
+    bytes32 gasFees;
+    bytes paymasterAndData;
+    bytes signature;
+}
+
+interface IAccount {
+    /**
+     * Validate user's signature and nonce
+     * the entryPoint will make the call to the recipient only if this validation call returns successfully.
+     * signature failure should be reported by returning SIG_VALIDATION_FAILED (1).
+     * This allows making a "simulation call" without a valid signature
+     * Other failures (e.g. nonce mismatch, or invalid signature format) should still revert to signal failure.
+     *
+     * @dev Must validate caller is the entryPoint.
+     *      Must validate the signature and nonce
+     * @param userOp              - The operation that is about to be executed.
+     * @param userOpHash          - Hash of the user's request data. can be used as the basis for signature.
+     * @param missingAccountFunds - Missing funds on the account's deposit in the entrypoint.
+     *                              This is the minimum amount to transfer to the sender(entryPoint) to be
+     *                              able to make the call. The excess is left as a deposit in the entrypoint
+     *                              for future calls. Can be withdrawn anytime using "entryPoint.withdrawTo()".
+     *                              In case there is a paymaster in the request (or the current deposit is high
+     *                              enough), this value will be zero.
+     * @return validationData       - Packaged ValidationData structure. use `_packValidationData` and
+     *                              `_unpackValidationData` to encode and decode.
+     *                              <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
+     *                                 otherwise, an address of an "authorizer" contract.
+     *                              <6-byte> validUntil - Last timestamp this operation is valid. 0 for "indefinite"
+     *                              <6-byte> validAfter - First timestamp this operation is valid
+     *                                                    If an account doesn't use time-range, it is enough to
+     *                                                    return SIG_VALIDATION_FAILED value (1) for signature failure.
+     *                              Note that the validation code cannot use block.timestamp (or block.number) directly.
+     */
+    function validateUserOp(PackedUserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds) external returns (uint256 validationData);
+}

packages/smart-wallet/src/interfaces/ICoinbaseSmartWallet.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {IAccount} from "./IAccount.sol";
+import {UserOperation} from "./UserOperation.sol";
+import {IUUPSUpgradeable} from "./IUUPSUpgradeable.sol";
+
+import {IERC1271} from "./IERC1271.sol";
+import {IMultiOwnable} from "./IMultiOwnable.sol";
+
+/// @title Coinbase Smart Wallet - extracted interface
+///
+/// @notice ERC-4337-compatible smart account, based on Solady's ERC4337 account implementation
+///         with inspiration from Alchemy's LightAccount and Daimo's DaimoAccount.
+/// @dev This interface is the conversion of the CoinbaseSmartWallet.sol contract into an interface,
+// with all of its inherited classes converted into interfaces and included in this repo to minimize external dependencies.
+// The original contract was located at https://github.com/coinbase/smart-wallet/blob/6579faa7f7f7a7de75db92f93e92584764ae1aa2/src/CoinbaseSmartWallet.sol
+///
+/// @author Coinbase (https://github.com/coinbase/smart-wallet)
+/// @author Solady (https://github.com/vectorized/solady/blob/main/src/accounts/ERC4337.sol)
+interface ICoinbaseSmartWallet is IERC1271, IAccount, IMultiOwnable, IUUPSUpgradeable {
+    /// @notice A wrapper struct used for signature validation so that callers
+    ///         can identify the owner that signed.
+    struct SignatureWrapper {
+        /// @dev The index of the owner that signed, see `MultiOwnable.ownerAtIndex`
+        uint256 ownerIndex;
+        /// @dev If `MultiOwnable.ownerAtIndex` is an Ethereum address, this should be `abi.encodePacked(r, s, v)`
+        ///      If `MultiOwnable.ownerAtIndex` is a external key, this should be `abi.encode(WebAuthnAuth)`.
+        bytes signatureData;
+    }
+
+    /// @notice Represents a call to make.
+    struct Call {
+        /// @dev The address to call.
+        address target;
+        /// @dev The value to send when making the call.
+        uint256 value;
+        /// @dev The data of the call.
+        bytes data;
+    }
+
+    /// @notice Thrown when `initialize` is called but the account already has had at least one owner.
+    error Initialized();
+
+    /// @notice Thrown when a call is passed to `executeWithoutChainIdValidation` that is not allowed by
+    ///         `canSkipChainIdValidation`
+    ///
+    /// @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.
+    ///
+    /// @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.
+    error InvalidNonceKey(uint256 key);
+
+    /// @notice Initializes the account with the `owners`.
+    ///
+    /// @dev Reverts if the account has had at least one owner, i.e. has been initialized.
+    ///
+    /// @param owners Array of initial owners for this account. Each item should be
+    ///               an ABI encoded Ethereum address, i.e. 32 bytes with 12 leading 0 bytes,
+    ///               or a 64 byte external key.
+    function initialize(bytes[] calldata owners) external payable;
+
+    /// @notice Executes `calls` on this account (i.e. self call).
+    ///
+    /// @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
+    ///      to be replayed for all accounts sharing the same address across chains. E.g. This may be
+    ///      useful for syncing owner changes.
+    ///
+    /// @param calls An array of calldata to use for separate self calls.
+    function executeWithoutChainIdValidation(bytes[] calldata calls) external payable;
+
+    /// @notice Executes the given call from this account.
+    ///
+    /// @dev Can only be called by the Entrypoint or an owner of this account (including itself).
+    ///
+    /// @param target The address to call.
+    /// @param value  The value to send with the call.
+    /// @param data   The data of the call.
+    function execute(address target, uint256 value, bytes calldata data) external;
+
+    /// @notice Executes batch of `Call`s.
+    ///
+    /// @dev Can only be called by the Entrypoint or an owner of this account (including itself).
+    ///
+    /// @param calls The list of `Call`s to execute.
+    function executeBatch(Call[] calldata calls) external;
+
+    /// @notice Returns the address of the EntryPoint v0.6.
+    ///
+    /// @return The address of the EntryPoint v0.6
+    function entryPoint() external view returns (address);
+
+    /// @notice Computes the hash of the `UserOperation` in the same way as EntryPoint v0.6, 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.
+    ///
+    /// @return The `UserOperation` hash, which does not depend on chain ID.
+    function getUserOpHashWithoutChainId(UserOperation calldata userOp) external view returns (bytes32);
+
+    /// @notice Returns the implementation of the ERC1967 proxy.
+    ///
+    /// @return $ The address of implementation contract.
+    function implementation() external view returns (address $);
+
+    /// @notice Returns whether `functionSelector` can be called in `executeWithoutChainIdValidation`.
+    ///
+    /// @param functionSelector The function selector to check.
+    ////
+    /// @return `true` is the function selector is allowed to skip the chain ID validation, else `false`.
+    function canSkipChainIdValidation(bytes4 functionSelector) external pure returns (bool);
+}

packages/smart-wallet/src/interfaces/ISmartWalletFactory.sol renamed to packages/smart-wallet/src/interfaces/ICoinbaseSmartWalletFactory.sol

@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-interface ISmartWalletFactory {
-    function createAccount(bytes[] calldata owners, uint256 nonce) external;
+import {ICoinbaseSmartWallet} from "./ICoinbaseSmartWallet.sol";
+
+interface ICoinbaseSmartWalletFactory {
+    function createAccount(bytes[] calldata owners, uint256 nonce) external returns (ICoinbaseSmartWallet account);
+
     function getAddress(bytes[] calldata owners, uint256 nonce) external view returns (address);
 
     function initCodeHash() external view returns (bytes32);
+
     function implementation() external view returns (address);
 }

packages/smart-wallet/src/interfaces/IERC1271.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+// interface extracted from https://github.com/coinbase/smart-wallet/blob/main/src/ERC1271.sol
+
+/// @title ERC-1271
+///
+/// @notice Abstract ERC-1271 implementation (based on Solady's) with guards to handle the same
+///         signer being used on multiple accounts.
+///
+/// @dev To prevent the same signature from being validated on different accounts owned by the samer signer,
+///      we introduce an anti cross-account-replay layer: the original hash is input into a new EIP-712 compliant
+///      hash. The domain separator of this outer hash contains the chain id and address of this contract, so that
+///      it cannot be used on two accounts (see `replaySafeHash()` for the implementation details).
+///
+/// @author Coinbase (https://github.com/coinbase/smart-wallet)
+/// @author Solady (https://github.com/vectorized/solady/blob/main/src/accounts/ERC1271.sol)
+interface IERC1271 {
+    /// @notice Returns information about the `EIP712Domain` used to create EIP-712 compliant hashes.
+    ///
+    /// @dev Follows ERC-5267 (see https://eips.ethereum.org/EIPS/eip-5267).
+    ///
+    /// @return fields The bitmap of used fields.
+    /// @return name The value of the `EIP712Domain.name` field.
+    /// @return version The value of the `EIP712Domain.version` field.
+    /// @return chainId The value of the `EIP712Domain.chainId` field.
+    /// @return verifyingContract The value of the `EIP712Domain.verifyingContract` field.
+    /// @return salt The value of the `EIP712Domain.salt` field.
+    /// @return extensions The list of EIP numbers, that extends EIP-712 with new domain fields.
+    function eip712Domain()
+        external
+        view
+        returns (
+            bytes1 fields,
+            string memory name,
+            string memory version,
+            uint256 chainId,
+            address verifyingContract,
+            bytes32 salt,
+            uint256[] memory extensions
+        );
+
+    /// @notice Validates the `signature` against the given `hash`.
+    ///
+    /// @dev This implementation follows ERC-1271. See https://eips.ethereum.org/EIPS/eip-1271.
+    /// @dev IMPORTANT: Signature verification is performed on the hash produced AFTER applying the anti
+    ///      cross-account-replay layer on the given `hash` (i.e., verification is run on the replay-safe
+    ///      hash version).
+    ///
+    /// @param hash      The original hash.
+    /// @param signature The signature of the replay-safe hash to validate.
+    ///
+    /// @return result `0x1626ba7e` if validation succeeded, else `0xffffffff`.
+    function isValidSignature(bytes32 hash, bytes calldata signature) external view returns (bytes4 result);
+
+    /// @notice Wrapper around `_eip712Hash()` to produce a replay-safe hash fron the given `hash`.
+    ///
+    /// @dev The returned EIP-712 compliant replay-safe hash is the result of:
+    ///      keccak256(
+    ///         \x19\x01 ||
+    ///         this.domainSeparator ||
+    ///         hashStruct(CoinbaseSmartWalletMessage({ hash: `hash`}))
+    ///      )
+    ///
+    /// @param hash The original hash.
+    ///
+    /// @return The corresponding replay-safe hash.
+    function replaySafeHash(bytes32 hash) external view returns (bytes32);
+
+    /// @notice Returns the `domainSeparator` used to create EIP-712 compliant hashes.
+    ///
+    /// @dev Implements domainSeparator = hashStruct(eip712Domain).
+    ///      See https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator.
+    ///
+    /// @return The 32 bytes domain separator result.
+    function domainSeparator() external view returns (bytes32);
+}