Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

// From with some modifications
// https://github.com/erc6551/reference/blob/main/src/examples/simple/SimpleERC6551Account.sol

import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC1271.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

import "./lib/ERC6551Account.sol";
import "./interfaces/IERC6551Account.sol";
import "./interfaces/IERC6551Executable.sol";

contract PackAccount is IERC165, IERC1271, IERC6551Account, IERC6551Executable {
    uint256 public state;

    receive() external payable {}

    function execute(
        address to,
        uint256 value,
        bytes calldata data,
        uint256 operation
    ) public payable virtual returns (bytes memory result) {
        require(
            _isValidSigner(msg.sender),
            "PackAccount: Only PackMain can call"
        );
        require(
            operation == 0,
            "PackAccount: Only call operations are supported"
        );

        ++state;

        bool success;
        (success, result) = to.call{value: value}(data);

        if (!success) {
            assembly {
                revert(add(result, 32), mload(result))
            }
        }
    }

    function isValidSigner(
        address signer,
        bytes calldata
    ) public view virtual returns (bytes4) {
        if (_isValidSigner(signer)) {
            return IERC6551Account.isValidSigner.selector;
        }

        return bytes4(0);
    }

    function isValidSignature(
        bytes32 hash,
        bytes memory signature
    ) public view virtual returns (bytes4 magicValue) {
        bool isValid = SignatureChecker.isValidSignatureNow(
            owner(),
            hash,
            signature
        );

        if (isValid) {
            return IERC1271.isValidSignature.selector;
        }

        return "";
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public pure virtual returns (bool) {
        return (interfaceId == type(IERC165).interfaceId ||
            interfaceId == type(IERC6551Account).interfaceId ||
            interfaceId == type(IERC6551Executable).interfaceId);
    }

    function token() public view virtual returns (uint256, address, uint256) {
        bytes memory footer = new bytes(0x60);

        assembly {
            extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)
        }

        return abi.decode(footer, (uint256, address, uint256));
    }

    function owner() public view virtual returns (address) {
        (uint256 chainId, address tokenContract, uint256 tokenId) = token();
        if (chainId != block.chainid) return address(0);

        return IERC721(tokenContract).ownerOf(tokenId);
    }

    // Modified function to check if the signer is the token contract
    function _isValidSigner(
        address signer
    ) internal view virtual returns (bool) {
        (, address tokenContract, ) = token();
        return signer == tokenContract;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Create2.sol)

pragma solidity ^0.8.20;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Not enough balance for performing a CREATE2 deploy.
     */
    error Create2InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev There's no code to deploy.
     */
    error Create2EmptyBytecode();

    /**
     * @dev The deployment failed.
     */
    error Create2FailedDeployment();

    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        if (address(this).balance < amount) {
            revert Create2InsufficientBalance(address(this).balance, amount);
        }
        if (bytecode.length == 0) {
            revert Create2EmptyBytecode();
        }
        /// @solidity memory-safe-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        if (addr == address(0)) {
            revert Create2FailedDeployment();
        }
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.20;

import {ECDSA} from "./ECDSA.sol";
import {IERC1271} from "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Safe Wallet (previously Gnosis Safe).
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @dev the ERC-165 identifier for this interface is `0x6faff5f1`
interface IERC6551Account {
    /**
     * @dev Allows the account to receive Ether
     *
     * Accounts MUST implement a `receive` function
     *
     * Accounts MAY perform arbitrary logic to restrict conditions
     * under which Ether can be received
     */
    receive() external payable;

    /**
     * @dev Returns the identifier of the non-fungible token which owns the account
     *
     * The return value of this function MUST be constant - it MUST NOT change over time
     *
     * @return chainId       The EIP-155 ID of the chain the token exists on
     * @return tokenContract The contract address of the token
     * @return tokenId       The ID of the token
     */
    function token()
        external
        view
        returns (uint256 chainId, address tokenContract, uint256 tokenId);

    /**
     * @dev Returns a value that SHOULD be modified each time the account changes state
     *
     * @return The current account state
     */
    function state() external view returns (uint256);

    /**
     * @dev Returns a magic value indicating whether a given signer is authorized to act on behalf
     * of the account
     *
     * MUST return the bytes4 magic value 0x523e3260 if the given signer is valid
     *
     * By default, the holder of the non-fungible token the account is bound to MUST be considered
     * a valid signer
     *
     * Accounts MAY implement additional authorization logic which invalidates the holder as a
     * signer or grants signing permissions to other non-holder accounts
     *
     * @param  signer     The address to check signing authorization for
     * @param  context    Additional data used to determine whether the signer is valid
     * @return magicValue Magic value indicating whether the signer is valid
     */
    function isValidSigner(
        address signer,
        bytes calldata context
    ) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @dev the ERC-165 identifier for this interface is `0x74420f4c`
interface IERC6551Executable {
    /**
     * @dev Executes a low-level operation if the caller is a valid signer on the account
     *
     * Reverts and bubbles up error if operation fails
     *
     * @param to        The target address of the operation
     * @param value     The Ether value to be sent to the target
     * @param data      The encoded operation calldata
     * @param operation A value indicating the type of operation to perform
     *
     * Accounts implementing this interface MUST accept the following operation parameter values:
     * - 0 = CALL
     * - 1 = DELEGATECALL
     * - 2 = CREATE
     * - 3 = CREATE2
     *
     * Accounts implementing this interface MAY support additional operations or restrict a signer's
     * ability to execute certain operations
     *
     * @return The result of the operation
     */
    function execute(
        address to,
        uint256 value,
        bytes calldata data,
        uint256 operation
    ) external payable returns (bytes memory);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// From:
// https://github.com/erc6551/reference/blob/main/src/lib/ERC6551AccountLib.sol

import "@openzeppelin/contracts/utils/Create2.sol";
import "./ERC6551Bytecode.sol";

library ERC6551AccountLib {
    function computeAddress(
        address registry,
        address implementation,
        uint256 chainId,
        address tokenContract,
        uint256 tokenId,
        uint256 _salt
    ) internal pure returns (address) {
        bytes32 bytecodeHash = keccak256(
            ERC6551BytecodeLib.getCreationCode(
                implementation,
                chainId,
                tokenContract,
                tokenId,
                _salt
            )
        );

        return Create2.computeAddress(bytes32(_salt), bytecodeHash, registry);
    }

    function token() internal view returns (uint256, address, uint256) {
        bytes memory footer = new bytes(0x60);

        assembly {
            // copy 0x60 bytes from end of footer
            extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)
        }

        return abi.decode(footer, (uint256, address, uint256));
    }

    function salt() internal view returns (uint256) {
        bytes memory footer = new bytes(0x20);

        assembly {
            // copy 0x20 bytes from beginning of footer
            extcodecopy(address(), add(footer, 0x20), 0x2d, 0x20)
        }

        return abi.decode(footer, (uint256));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// From:
// https://github.com/erc6551/reference/blob/main/src/lib/ERC6551BytecodeLib.sol

library ERC6551BytecodeLib {
    function getCreationCode(
        address implementation_,
        uint256 chainId_,
        address tokenContract_,
        uint256 tokenId_,
        uint256 salt_
    ) internal pure returns (bytes memory) {
        return
            abi.encodePacked(
                hex"3d60ad80600a3d3981f3363d3d373d3d3d363d73",
                implementation_,
                hex"5af43d82803e903d91602b57fd5bf3",
                abi.encode(salt_, chainId_, tokenContract_, tokenId_)
            );
    }
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"operation","type":"uint256"}],"name":"execute","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bytes4","name":"magicValue","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"isValidSigner","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"state","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106100745760003560e01c806374420f4c1161004e57806374420f4c146101375780638da5cb5b14610167578063c19d93fb14610192578063fc0c546a146101bd5761007b565b806301ffc9a7146100805780631626ba7e146100bd578063523e3260146100fa5761007b565b3661007b57005b600080fd5b34801561008c57600080fd5b506100a760048036038101906100a2919061099f565b6101ea565b6040516100b491906109e7565b60405180910390f35b3480156100c957600080fd5b506100e460048036038101906100df9190610b7e565b610324565b6040516100f19190610be9565b60405180910390f35b34801561010657600080fd5b50610121600480360381019061011c9190610cc2565b61035d565b60405161012e9190610be9565b60405180910390f35b610151600480360381019061014c9190610d58565b61038b565b60405161015e9190610e5f565b60405180910390f35b34801561017357600080fd5b5061017c6104b9565b6040516101899190610e90565b60405180910390f35b34801561019e57600080fd5b506101a7610563565b6040516101b49190610eba565b60405180910390f35b3480156101c957600080fd5b506101d2610569565b6040516101e193929190610ed5565b60405180910390f35b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614806102b557507f6faff5f1000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b8061031d57507f74420f4c000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b9050919050565b6000806103396103326104b9565b85856105e9565b9050801561035157631626ba7e60e01b915050610357565b60009150505b92915050565b600061036884610679565b1561037c5763523e326060e01b9050610384565b600060e01b90505b9392505050565b606061039633610679565b6103d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103cc90610f8f565b60405180910390fd5b60008214610418576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161040f90611021565b60405180910390fd5b600080815461042690611070565b9190508190555060008673ffffffffffffffffffffffffffffffffffffffff168686866040516104579291906110e8565b60006040518083038185875af1925050503d8060008114610494576040519150601f19603f3d011682016040523d82523d6000602084013e610499565b606091505b508093508192505050806104af57815160208301fd5b5095945050505050565b6000806000806104c7610569565b9250925092504683146104e05760009350505050610560565b8173ffffffffffffffffffffffffffffffffffffffff16636352211e826040518263ffffffff1660e01b81526004016105199190610eba565b602060405180830381865afa158015610536573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061055a9190611116565b93505050505b90565b60005481565b600080600080606067ffffffffffffffff81111561058a57610589610a53565b5b6040519080825280601f01601f1916602001820160405280156105bc5781602001600182028036833780820191505090505b5090506060604d60208301303c808060200190518101906105dd9190611196565b93509350935050909192565b60008060006105f885856106bf565b509150915060006003811115610611576106106111e9565b5b816003811115610624576106236111e9565b5b14801561065c57508573ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16145b8061066e575061066d86868661071b565b5b925050509392505050565b600080610684610569565b509150508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614915050919050565b600080600060418451036107045760008060006020870151925060408701519150606087015160001a90506106f68882858561083f565b955095509550505050610714565b60006002855160001b9250925092505b9250925092565b60008060008573ffffffffffffffffffffffffffffffffffffffff16858560405160240161074a929190611227565b604051602081830303815290604052631626ba7e60e01b6020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505060405161079c9190611288565b600060405180830381855afa9150503d80600081146107d7576040519150601f19603f3d011682016040523d82523d6000602084013e6107dc565b606091505b50915091508180156107f057506020815110155b80156108345750631626ba7e60e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168180602001905181019061083291906112b4565b145b925050509392505050565b60008060007f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08460001c111561087f576000600385925092509250610929565b6000600188888888604051600081526020016040526040516108a494939291906112fd565b6020604051602081039080840390855afa1580156108c6573d6000803e3d6000fd5b505050602060405103519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361091a57600060016000801b93509350935050610929565b8060008060001b935093509350505b9450945094915050565b6000604051905090565b600080fd5b600080fd5b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b61097c81610947565b811461098757600080fd5b50565b60008135905061099981610973565b92915050565b6000602082840312156109b5576109b461093d565b5b60006109c38482850161098a565b91505092915050565b60008115159050919050565b6109e1816109cc565b82525050565b60006020820190506109fc60008301846109d8565b92915050565b6000819050919050565b610a1581610a02565b8114610a2057600080fd5b50565b600081359050610a3281610a0c565b92915050565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b610a8b82610a42565b810181811067ffffffffffffffff82111715610aaa57610aa9610a53565b5b80604052505050565b6000610abd610933565b9050610ac98282610a82565b919050565b600067ffffffffffffffff821115610ae957610ae8610a53565b5b610af282610a42565b9050602081019050919050565b82818337600083830152505050565b6000610b21610b1c84610ace565b610ab3565b905082815260208101848484011115610b3d57610b3c610a3d565b5b610b48848285610aff565b509392505050565b600082601f830112610b6557610b64610a38565b5b8135610b75848260208601610b0e565b91505092915050565b60008060408385031215610b9557610b9461093d565b5b6000610ba385828601610a23565b925050602083013567ffffffffffffffff811115610bc457610bc3610942565b5b610bd085828601610b50565b9150509250929050565b610be381610947565b82525050565b6000602082019050610bfe6000830184610bda565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610c2f82610c04565b9050919050565b610c3f81610c24565b8114610c4a57600080fd5b50565b600081359050610c5c81610c36565b92915050565b600080fd5b600080fd5b60008083601f840112610c8257610c81610a38565b5b8235905067ffffffffffffffff811115610c9f57610c9e610c62565b5b602083019150836001820283011115610cbb57610cba610c67565b5b9250929050565b600080600060408486031215610cdb57610cda61093d565b5b6000610ce986828701610c4d565b935050602084013567ffffffffffffffff811115610d0a57610d09610942565b5b610d1686828701610c6c565b92509250509250925092565b6000819050919050565b610d3581610d22565b8114610d4057600080fd5b50565b600081359050610d5281610d2c565b92915050565b600080600080600060808688031215610d7457610d7361093d565b5b6000610d8288828901610c4d565b9550506020610d9388828901610d43565b945050604086013567ffffffffffffffff811115610db457610db3610942565b5b610dc088828901610c6c565b93509350506060610dd388828901610d43565b9150509295509295909350565b600081519050919050565b600082825260208201905092915050565b60005b83811015610e1a578082015181840152602081019050610dff565b60008484015250505050565b6000610e3182610de0565b610e3b8185610deb565b9350610e4b818560208601610dfc565b610e5481610a42565b840191505092915050565b60006020820190508181036000830152610e798184610e26565b905092915050565b610e8a81610c24565b82525050565b6000602082019050610ea56000830184610e81565b92915050565b610eb481610d22565b82525050565b6000602082019050610ecf6000830184610eab565b92915050565b6000606082019050610eea6000830186610eab565b610ef76020830185610e81565b610f046040830184610eab565b949350505050565b600082825260208201905092915050565b7f5061636b4163636f756e743a204f6e6c79205061636b4d61696e2063616e206360008201527f616c6c0000000000000000000000000000000000000000000000000000000000602082015250565b6000610f79602383610f0c565b9150610f8482610f1d565b604082019050919050565b60006020820190508181036000830152610fa881610f6c565b9050919050565b7f5061636b4163636f756e743a204f6e6c792063616c6c206f7065726174696f6e60008201527f732061726520737570706f727465640000000000000000000000000000000000602082015250565b600061100b602f83610f0c565b915061101682610faf565b604082019050919050565b6000602082019050818103600083015261103a81610ffe565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061107b82610d22565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036110ad576110ac611041565b5b600182019050919050565b600081905092915050565b60006110cf83856110b8565b93506110dc838584610aff565b82840190509392505050565b60006110f58284866110c3565b91508190509392505050565b60008151905061111081610c36565b92915050565b60006020828403121561112c5761112b61093d565b5b600061113a84828501611101565b91505092915050565b60008151905061115281610d2c565b92915050565b600061116382610c04565b9050919050565b61117381611158565b811461117e57600080fd5b50565b6000815190506111908161116a565b92915050565b6000806000606084860312156111af576111ae61093d565b5b60006111bd86828701611143565b93505060206111ce86828701611181565b92505060406111df86828701611143565b9150509250925092565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b61122181610a02565b82525050565b600060408201905061123c6000830185611218565b818103602083015261124e8184610e26565b90509392505050565b600061126282610de0565b61126c81856110b8565b935061127c818560208601610dfc565b80840191505092915050565b60006112948284611257565b915081905092915050565b6000815190506112ae81610a0c565b92915050565b6000602082840312156112ca576112c961093d565b5b60006112d88482850161129f565b91505092915050565b600060ff82169050919050565b6112f7816112e1565b82525050565b60006080820190506113126000830187611218565b61131f60208301866112ee565b61132c6040830185611218565b6113396060830184611218565b9594505050505056fea26469706673582212201a63742e86eeb5a2e0d046e913705ff5453e6269341760c57bf5d71a1d916ab964736f6c63430008140033