Add IEntryPoint.sol

contracts/vendor/erc4337-entrypoint/interfaces/IEntryPoint.sol

@@ -0,0 +1,223 @@
+/**
+ ** Account-Abstraction (EIP-4337) singleton EntryPoint implementation.
+ ** Only one instance required on each chain.
+ **/
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.7.5;
+
+/* 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;
+}