@rarible/external-contracts 3.11.4

package/contracts/prebuilts/account/interfaces/IEntryPoint.sol

@@ -0,0 +1,204 @@
+/**
+ ** Account-Abstraction (EIP-4337) singleton EntryPoint implementation.
+ ** Only one instance required on each chain.
+ **/
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+/* solhint-disable avoid-low-level-calls */
+/* solhint-disable no-inline-assembly */
+/* solhint-disable reason-string */
+
+import "./PackedUserOperation.sol";
+import "./IStakeManager.sol";
+import "./IAggregator.sol";
+import "./INonceManager.sol";
+
+interface IEntryPoint is IStakeManager, INonceManager {
+    /***
+     * An event emitted after each successful request.
+     * @param userOpHash    - Unique identifier for the request (hash its entire content, except signature).
+     * @param sender        - The account that generates this request.
+     * @param paymaster     - If non-null, the paymaster that pays for this request.
+     * @param nonce         - The nonce value from the request.
+     * @param success       - True if the sender transaction succeeded, false if reverted.
+     * @param actualGasCost - Actual amount paid (by account or paymaster) for this UserOperation.
+     * @param actualGasUsed - Total gas used by this UserOperation (including preVerification, creation,
+     *                        validation and execution).
+     */
+    event UserOperationEvent(
+        bytes32 indexed userOpHash,
+        address indexed sender,
+        address indexed paymaster,
+        uint256 nonce,
+        bool success,
+        uint256 actualGasCost,
+        uint256 actualGasUsed
+    );
+
+    /**
+     * Account "sender" was deployed.
+     * @param userOpHash - The userOp that deployed this account. UserOperationEvent will follow.
+     * @param sender     - The account that is deployed
+     * @param factory    - The factory used to deploy this account (in the initCode)
+     * @param paymaster  - The paymaster used by this UserOp
+     */
+    event AccountDeployed(bytes32 indexed userOpHash, address indexed sender, address factory, address paymaster);
+
+    /**
+     * An event emitted if the UserOperation "callData" reverted with non-zero length.
+     * @param userOpHash   - The request unique identifier.
+     * @param sender       - The sender of this request.
+     * @param nonce        - The nonce used in the request.
+     * @param revertReason - The return bytes from the (reverted) call to "callData".
+     */
+    event UserOperationRevertReason(
+        bytes32 indexed userOpHash,
+        address indexed sender,
+        uint256 nonce,
+        bytes revertReason
+    );
+
+    /**
+     * An event emitted if the UserOperation Paymaster's "postOp" call reverted with non-zero length.
+     * @param userOpHash   - The request unique identifier.
+     * @param sender       - The sender of this request.
+     * @param nonce        - The nonce used in the request.
+     * @param revertReason - The return bytes from the (reverted) call to "callData".
+     */
+    event PostOpRevertReason(bytes32 indexed userOpHash, address indexed sender, uint256 nonce, bytes revertReason);
+
+    /**
+     * UserOp consumed more than prefund. The UserOperation is reverted, and no refund is made.
+     * @param userOpHash   - The request unique identifier.
+     * @param sender       - The sender of this request.
+     * @param nonce        - The nonce used in the request.
+     */
+    event UserOperationPrefundTooLow(bytes32 indexed userOpHash, address indexed sender, uint256 nonce);
+
+    /**
+     * An event emitted by handleOps(), before starting the execution loop.
+     * Any event emitted before this event, is part of the validation.
+     */
+    event BeforeExecution();
+
+    /**
+     * Signature aggregator used by the following UserOperationEvents within this bundle.
+     * @param aggregator - The aggregator used for the following UserOperationEvents.
+     */
+    event SignatureAggregatorChanged(address indexed aggregator);
+
+    /**
+     * A custom revert error of handleOps, to identify the offending op.
+     * Should be caught in off-chain handleOps simulation and not happen on-chain.
+     * Useful for mitigating DoS attempts against batchers or for troubleshooting of factory/account/paymaster reverts.
+     * NOTE: If simulateValidation passes successfully, there should be no reason for handleOps to fail on it.
+     * @param opIndex - Index into the array of ops to the failed one (in simulateValidation, this is always zero).
+     * @param reason  - Revert reason. The string starts with a unique code "AAmn",
+     *                  where "m" is "1" for factory, "2" for account and "3" for paymaster issues,
+     *                  so a failure can be attributed to the correct entity.
+     */
+    error FailedOp(uint256 opIndex, string reason);
+
+    /**
+     * A custom revert error of handleOps, to report a revert by account or paymaster.
+     * @param opIndex - Index into the array of ops to the failed one (in simulateValidation, this is always zero).
+     * @param reason  - Revert reason. see FailedOp(uint256,string), above
+     * @param inner   - data from inner cought revert reason
+     * @dev note that inner is truncated to 2048 bytes
+     */
+    error FailedOpWithRevert(uint256 opIndex, string reason, bytes inner);
+
+    error PostOpReverted(bytes returnData);
+
+    /**
+     * Error case when a signature aggregator fails to verify the aggregated signature it had created.
+     * @param aggregator The aggregator that failed to verify the signature
+     */
+    error SignatureValidationFailed(address aggregator);
+
+    // Return value of getSenderAddress.
+    error SenderAddressResult(address sender);
+
+    // UserOps handled, per aggregator.
+    struct UserOpsPerAggregator {
+        PackedUserOperation[] userOps;
+        // Aggregator address
+        IAggregator aggregator;
+        // Aggregated signature
+        bytes signature;
+    }
+
+    /**
+     * Execute a batch of UserOperations.
+     * No signature aggregator is used.
+     * If any account requires an aggregator (that is, it returned an aggregator when
+     * performing simulateValidation), then handleAggregatedOps() must be used instead.
+     * @param ops         - The operations to execute.
+     * @param beneficiary - The address to receive the fees.
+     */
+    function handleOps(PackedUserOperation[] calldata ops, address payable beneficiary) external;
+
+    /**
+     * Execute a batch of UserOperation with Aggregators
+     * @param opsPerAggregator - The operations to execute, grouped by aggregator (or address(0) for no-aggregator accounts).
+     * @param beneficiary      - The address to receive the fees.
+     */
+    function handleAggregatedOps(
+        UserOpsPerAggregator[] calldata opsPerAggregator,
+        address payable beneficiary
+    ) external;
+
+    /**
+     * Generate a request Id - unique identifier for this request.
+     * The request ID is a hash over the content of the userOp (except the signature), the entrypoint and the chainid.
+     * @param userOp - The user operation to generate the request ID for.
+     * @return hash the hash of this UserOperation
+     */
+    function getUserOpHash(PackedUserOperation calldata userOp) external view returns (bytes32);
+
+    /**
+     * Gas and return values during simulation.
+     * @param preOpGas         - The gas used for validation (including preValidationGas)
+     * @param prefund          - The required prefund for this operation
+     * @param accountValidationData   - returned validationData from account.
+     * @param paymasterValidationData - return validationData from paymaster.
+     * @param paymasterContext - Returned by validatePaymasterUserOp (to be passed into postOp)
+     */
+    struct ReturnInfo {
+        uint256 preOpGas;
+        uint256 prefund;
+        uint256 accountValidationData;
+        uint256 paymasterValidationData;
+        bytes paymasterContext;
+    }
+
+    /**
+     * Returned aggregated signature info:
+     * The aggregator returned by the account, and its current stake.
+     */
+    struct AggregatorStakeInfo {
+        address aggregator;
+        StakeInfo stakeInfo;
+    }
+
+    /**
+     * Get counterfactual sender address.
+     * Calculate the sender contract address that will be generated by the initCode and salt in the UserOperation.
+     * This method always revert, and returns the address in SenderAddressResult error
+     * @param initCode - The constructor code to be passed into the UserOperation.
+     */
+    function getSenderAddress(bytes memory initCode) external;
+
+    error DelegateAndRevert(bool success, bytes ret);
+
+    /**
+     * Helper method for dry-run testing.
+     * @dev calling this method, the EntryPoint will make a delegatecall to the given data, and report (via revert) the result.
+     *  The method always revert, so is only useful off-chain for dry run calls, in cases where state-override to replace
+     *  actual EntryPoint code is less convenient.
+     * @param target a target contract to make a delegatecall from entrypoint
+     * @param data data to pass to target in a delegatecall
+     */
+    function delegateAndRevert(address target, bytes calldata data) external;
+}

package/contracts/prebuilts/account/interfaces/INonceManager.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+interface INonceManager {
+    /**
+     * Return the next nonce for this sender.
+     * Within a given key, the nonce values are sequenced (starting with zero, and incremented by one on each userop)
+     * But UserOp with different keys can come with arbitrary order.
+     *
+     * @param sender the account address
+     * @param key the high 192 bit of the nonce
+     * @return nonce a full nonce to pass for next UserOp with this sender.
+     */
+    function getNonce(address sender, uint192 key) external view returns (uint256 nonce);
+
+    /**
+     * Manually increment the nonce of the sender.
+     * This method is exposed just for completeness..
+     * Account does NOT need to call it, neither during validation, nor elsewhere,
+     * as the EntryPoint will update the nonce regardless.
+     * Possible use-case is call it with various keys to "initialize" their nonces to one, so that future
+     * UserOperations will not pay extra for the first transaction with a given key.
+     */
+    function incrementNonce(uint192 key) external;
+}

package/contracts/prebuilts/account/interfaces/IOracle.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IOracle {
+    function decimals() external view returns (uint8);
+    function latestRoundData()
+        external
+        view
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
+}

package/contracts/prebuilts/account/interfaces/IPaymaster.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+import "./PackedUserOperation.sol";
+
+/**
+ * The interface exposed by a paymaster contract, who agrees to pay the gas for user's operations.
+ * A paymaster must hold a stake to cover the required entrypoint stake and also the gas for the transaction.
+ */
+interface IPaymaster {
+    enum PostOpMode {
+        // User op succeeded.
+        opSucceeded,
+        // User op reverted. Still has to pay for gas.
+        opReverted,
+        // Only used internally in the EntryPoint (cleanup after postOp reverts). Never calling paymaster with this value
+        postOpReverted
+    }
+
+    /**
+     * Payment validation: check if paymaster agrees to pay.
+     * Must verify sender is the entryPoint.
+     * Revert to reject this request.
+     * Note that bundlers will reject this method if it changes the state, unless the paymaster is trusted (whitelisted).
+     * The paymaster pre-pays using its deposit, and receive back a refund after the postOp method returns.
+     * @param userOp          - The user operation.
+     * @param userOpHash      - Hash of the user's request data.
+     * @param maxCost         - The maximum cost of this transaction (based on maximum gas and gas price from userOp).
+     * @return context        - Value to send to a postOp. Zero length to signify postOp is not required.
+     * @return validationData - Signature and time-range of this operation, encoded the same as the return
+     *                          value of validateUserOperation.
+     *                          <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
+     *                                                    other values are invalid for paymaster.
+     *                          <6-byte> validUntil - last timestamp this operation is valid. 0 for "indefinite"
+     *                          <6-byte> validAfter - first timestamp this operation is valid
+     *                          Note that the validation code cannot use block.timestamp (or block.number) directly.
+     */
+    function validatePaymasterUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash,
+        uint256 maxCost
+    ) external returns (bytes memory context, uint256 validationData);
+
+    /**
+     * Post-operation handler.
+     * Must verify sender is the entryPoint.
+     * @param mode          - Enum with the following options:
+     *                        opSucceeded - User operation succeeded.
+     *                        opReverted  - User op reverted. The paymaster still has to pay for gas.
+     *                        postOpReverted - never passed in a call to postOp().
+     * @param context       - The context value returned by validatePaymasterUserOp
+     * @param actualGasCost - Actual gas used so far (without this postOp call).
+     * @param actualUserOpFeePerGas - the gas price this UserOp pays. This value is based on the UserOp's maxFeePerGas
+     *                        and maxPriorityFee (and basefee)
+     *                        It is not the same as tx.gasprice, which is what the bundler pays.
+     */
+    function postOp(
+        PostOpMode mode,
+        bytes calldata context,
+        uint256 actualGasCost,
+        uint256 actualUserOpFeePerGas
+    ) external;
+}

package/contracts/prebuilts/account/interfaces/IStakeManager.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * Manage deposits and stakes.
+ * Deposit is just a balance used to pay for UserOperations (either by a paymaster or an account).
+ * Stake is value locked for at least "unstakeDelay" by the staked entity.
+ */
+interface IStakeManager {
+    event Deposited(address indexed account, uint256 totalDeposit);
+
+    event Withdrawn(address indexed account, address withdrawAddress, uint256 amount);
+
+    // Emitted when stake or unstake delay are modified.
+    event StakeLocked(address indexed account, uint256 totalStaked, uint256 unstakeDelaySec);
+
+    // Emitted once a stake is scheduled for withdrawal.
+    event StakeUnlocked(address indexed account, uint256 withdrawTime);
+
+    event StakeWithdrawn(address indexed account, address withdrawAddress, uint256 amount);
+
+    /**
+     * @param deposit         - The entity's deposit.
+     * @param staked          - True if this entity is staked.
+     * @param stake           - Actual amount of ether staked for this entity.
+     * @param unstakeDelaySec - Minimum delay to withdraw the stake.
+     * @param withdrawTime    - First block timestamp where 'withdrawStake' will be callable, or zero if already locked.
+     * @dev Sizes were chosen so that deposit fits into one cell (used during handleOp)
+     *      and the rest fit into a 2nd cell (used during stake/unstake)
+     *      - 112 bit allows for 10^15 eth
+     *      - 48 bit for full timestamp
+     *      - 32 bit allows 150 years for unstake delay
+     */
+    struct DepositInfo {
+        uint256 deposit;
+        bool staked;
+        uint112 stake;
+        uint32 unstakeDelaySec;
+        uint48 withdrawTime;
+    }
+
+    // API struct used by getStakeInfo and simulateValidation.
+    struct StakeInfo {
+        uint256 stake;
+        uint256 unstakeDelaySec;
+    }
+
+    /**
+     * Get deposit info.
+     * @param account - The account to query.
+     * @return info   - Full deposit information of given account.
+     */
+    function getDepositInfo(address account) external view returns (DepositInfo memory info);
+
+    /**
+     * Get account balance.
+     * @param account - The account to query.
+     * @return        - The deposit (for gas payment) of the account.
+     */
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * Add to the deposit of the given account.
+     * @param account - The account to add to.
+     */
+    function depositTo(address account) external payable;
+
+    /**
+     * Add to the account's stake - amount and delay
+     * any pending unstake is first cancelled.
+     * @param _unstakeDelaySec - The new lock duration before the deposit can be withdrawn.
+     */
+    function addStake(uint32 _unstakeDelaySec) external payable;
+
+    /**
+     * Attempt to unlock the stake.
+     * The value can be withdrawn (using withdrawStake) after the unstake delay.
+     */
+    function unlockStake() external;
+
+    /**
+     * Withdraw from the (unlocked) stake.
+     * Must first call unlockStake and wait for the unstakeDelay to pass.
+     * @param withdrawAddress - The address to send withdrawn value.
+     */
+    function withdrawStake(address payable withdrawAddress) external;
+
+    /**
+     * Withdraw from the deposit.
+     * @param withdrawAddress - The address to send withdrawn value.
+     * @param withdrawAmount  - The amount to withdraw.
+     */
+    function withdrawTo(address payable withdrawAddress, uint256 withdrawAmount) external;
+}

package/contracts/prebuilts/account/interfaces/PackedUserOperation.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+/**
+ * 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;
+}

package/contracts/prebuilts/account/managed/ManagedAccount.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/* solhint-disable avoid-low-level-calls */
+/* solhint-disable no-inline-assembly */
+/* solhint-disable reason-string */
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+import "../utils/AccountCore.sol";
+import "@thirdweb-dev/dynamic-contracts/src/core/Router.sol";
+import "@thirdweb-dev/dynamic-contracts/src/interface/IRouterState.sol";
+
+contract ManagedAccount is AccountCore, Router, IRouterState {
+    constructor(IEntryPoint _entrypoint, address _factory) AccountCore(_entrypoint, _factory) {}
+
+    /// @notice Returns the implementation contract address for a given function signature.
+    function getImplementationForFunction(bytes4 _functionSelector) public view virtual override returns (address) {
+        return Router(payable(factory)).getImplementationForFunction(_functionSelector);
+    }
+
+    /// @notice Returns all extensions of the Router.
+    function getAllExtensions() external view returns (Extension[] memory) {
+        return IRouterState(payable(factory)).getAllExtensions();
+    }
+}

package/contracts/prebuilts/account/managed/ManagedAccountFactory.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.12;
+
+// Utils
+import "@thirdweb-dev/dynamic-contracts/src/presets/BaseRouter.sol";
+import "../utils/BaseAccountFactory.sol";
+
+// Extensions
+import "../../../extension/upgradeable//PermissionsEnumerable.sol";
+import "../../../extension/upgradeable//ContractMetadata.sol";
+
+// Smart wallet implementation
+import { ManagedAccount, IEntryPoint } from "./ManagedAccount.sol";
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+contract ManagedAccountFactory is BaseAccountFactory, ContractMetadata, PermissionsEnumerable, BaseRouter {
+    /*///////////////////////////////////////////////////////////////
+                            Constructor
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(
+        address _defaultAdmin,
+        IEntryPoint _entrypoint,
+        Extension[] memory _defaultExtensions
+    )
+        BaseRouter(_defaultExtensions)
+        BaseAccountFactory(payable(address(new ManagedAccount(_entrypoint, address(this)))), address(_entrypoint))
+    {
+        __BaseRouter_init();
+        _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
+
+        bytes32 _extensionRole = keccak256("EXTENSION_ROLE");
+        _setupRole(_extensionRole, _defaultAdmin);
+        _setRoleAdmin(_extensionRole, _extensionRole);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Called in `createAccount`. Initializes the account contract created in `createAccount`.
+    function _initializeAccount(address _account, address _admin, bytes calldata _data) internal override {
+        ManagedAccount(payable(_account)).initialize(_admin, _data);
+    }
+
+    /// @dev Returns whether all relevant permission and other checks are met before any upgrade.
+    function _isAuthorizedCallToUpgrade() internal view virtual override returns (bool) {
+        return hasRole(keccak256("EXTENSION_ROLE"), msg.sender);
+    }
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual override returns (bool) {
+        return hasRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    /// @notice Returns the sender in the given execution context.
+    function _msgSender() internal view override(Multicall, Permissions) returns (address) {
+        return msg.sender;
+    }
+}