Source Code
Overview
ETH Balance
0 ETH
More Info
ContractCreator
Multichain Info
N/A
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
Latest 25 internal transactions (View All)
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
SingleOwnerMSCAFactory
Compiler Version
v0.8.24+commit.e11b9ed9
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {PluginManager} from "../../managers/PluginManager.sol";
import {SingleOwnerMSCA} from "../../account/semi/SingleOwnerMSCA.sol";
import "../../common/Errors.sol";
/**
* @dev Account factory that creates the semi-MSCA that enshrines single owner into the account storage.
* No plugin installation is required during account creation.
*/
contract SingleOwnerMSCAFactory {
// logic implementation
SingleOwnerMSCA public immutable accountImplementation;
IEntryPoint public immutable entryPoint;
event FactoryDeployed(address indexed factory, address accountImplementation, address entryPoint);
event AccountCreated(address indexed proxy, address sender, bytes32 salt);
/**
* @dev Salted deterministic deployment using create2 and a specific logic SingleOwnerMSCA implementation.
* Tx/userOp is either gated by userOpValidationFunction or runtimeValidationFunction, and SingleOwnerMSCA
* is a minimum account with a pre built-in owner validation, so we do not require the user to install any plugins
* during the deployment. No hooks can be injected during the account deployment, so for a future installation
* of more complicated plugins, please call installPlugin via a separate tx/userOp after account deployment.
*/
constructor(address _entryPointAddr, address _pluginManagerAddr) {
entryPoint = IEntryPoint(_entryPointAddr);
PluginManager _pluginManager = PluginManager(_pluginManagerAddr);
accountImplementation = new SingleOwnerMSCA(entryPoint, _pluginManager);
emit FactoryDeployed(address(this), address(accountImplementation), _entryPointAddr);
}
/**
* @dev Salted deterministic deployment using create2 and a specific logic SingleOwnerMSCA implementation.
* Tx/userOp is either gated by userOpValidationFunction or runtimeValidationFunction, and SingleOwnerMSCA
* is a minimum account with a pre built-in owner validation, so we do not require the user to install any plugins
* during the deployment. No hooks can be injected during the account deployment, so for a future installation
* of more complicated plugins, please call installPlugin via a separate tx/userOp after account deployment.
* @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner information during account creation,
* please use something unique, consistent and private to yourself. In the context of single owner semi-MSCA, this field is mostly
* for consistency because we also use owner to mix the salt.
* @param _salt salt that allows for deterministic deployment
* @param _initializingData abi.encode(address), address should not be zero
*/
function createAccount(
address _sender,
bytes32 _salt,
bytes memory _initializingData)
public returns (SingleOwnerMSCA account) {
address owner = abi.decode(_initializingData, (address));
(address counterfactualAddr, bytes32 mixedSalt) = _getAddress(_sender, _salt, owner);
if (counterfactualAddr.code.length > 0) {
return SingleOwnerMSCA(payable(counterfactualAddr));
}
// only perform implementation upgrade by setting empty _data in ERC1967Proxy
// meanwhile we also initialize proxy storage, which calls PluginManager._installPlugin directly to bypass validateNativeFunction checks
account = SingleOwnerMSCA(payable(new ERC1967Proxy{salt : mixedSalt}(
address(accountImplementation),
abi.encodeCall(SingleOwnerMSCA.initializeSingleOwnerMSCA, (owner)))));
if (address(account) != counterfactualAddr) {
revert Create2FailedDeployment();
}
emit AccountCreated(counterfactualAddr, _sender, _salt);
}
/**
* @dev Pre-compute the counterfactual address prior to calling createAccount.
* After decoding, owner is used in salt, byteCodeHash and func init call to minimize the front-running risk.
* @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner information during account creation,
* please use something unique, consistent and private to yourself. In the context of single owner semi-MSCA, this field is mostly
* for consistency because we also use owner to mix the salt.
* @param _salt salt that allows for deterministic deployment
* @param _initializingData abi.encode(address), address should not be zero
*/
function getAddress(
address _sender,
bytes32 _salt,
bytes memory _initializingData) public view returns (address addr, bytes32 mixedSalt) {
address owner = abi.decode(_initializingData, (address));
return _getAddress(_sender, _salt, owner);
}
/**
* @dev Pre-compute the counterfactual address prior to calling createAccount.
* After decoding, owner is used in salt, byteCodeHash and func init call to minimize the front-running risk.
* @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner information during account creation,
* please use something unique, consistent and private to yourself. In the context of single owner semi-MSCA, this field is mostly
* for consistency because we also use owner to mix the salt.
* @param _salt salt that allows for deterministic deployment
* @param _owner owner of the semi MSCA
*/
function _getAddress(
address _sender,
bytes32 _salt,
address _owner) internal view returns (address addr, bytes32 mixedSalt) {
if (_owner == address(0)) {
revert InvalidInitializationInput();
}
mixedSalt = keccak256(abi.encodePacked(_sender, _owner, _salt));
bytes32 code = keccak256(abi.encodePacked(
type(ERC1967Proxy).creationCode,
abi.encode(address(accountImplementation), abi.encodeCall(SingleOwnerMSCA.initializeSingleOwnerMSCA, (_owner)))));
addr = Create2.computeAddress(mixedSalt, code, address(this));
return (addr, mixedSalt);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
pragma solidity ^0.8.0;
import "../Proxy.sol";
import "./ERC1967Upgrade.sol";
/**
* @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
* implementation address that can be changed. This address is stored in storage in the location specified by
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
* implementation behind the proxy.
*/
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
/**
* @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
*
* If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
* function call, and allows initializing the storage of the proxy like a Solidity constructor.
*/
constructor(address _logic, bytes memory _data) payable {
_upgradeToAndCall(_logic, _data, false);
}
/**
* @dev Returns the current implementation address.
*/
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Create2.sol)
pragma solidity ^0.8.0;
/**
* @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 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) {
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
/// @solidity memory-safe-assembly
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
}
/**
* @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)
}
}
}/**
** Account-Abstraction (EIP-4337) singleton EntryPoint implementation.
** Only one instance required on each chain.
**/
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */
import "./UserOperation.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 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.
*/
event SignatureAggregatorChanged(address indexed aggregator);
/**
* a custom revert error of handleOps, to identify the offending op.
* 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.
* 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.
*/
error FailedOp(uint256 opIndex, string reason);
/**
* error case when a signature aggregator fails to verify the aggregated signature it had created.
*/
error SignatureValidationFailed(address aggregator);
/**
* Successful result from simulateValidation.
* @param returnInfo gas and time-range returned values
* @param senderInfo stake information about the sender
* @param factoryInfo stake information about the factory (if any)
* @param paymasterInfo stake information about the paymaster (if any)
*/
error ValidationResult(ReturnInfo returnInfo,
StakeInfo senderInfo, StakeInfo factoryInfo, StakeInfo paymasterInfo);
/**
* Successful result from simulateValidation, if the account returns a signature aggregator
* @param returnInfo gas and time-range returned values
* @param senderInfo stake information about the sender
* @param factoryInfo stake information about the factory (if any)
* @param paymasterInfo stake information about the paymaster (if any)
* @param aggregatorInfo signature aggregation info (if the account requires signature aggregator)
* bundler MUST use it to verify the signature, or reject the UserOperation
*/
error ValidationResultWithAggregation(ReturnInfo returnInfo,
StakeInfo senderInfo, StakeInfo factoryInfo, StakeInfo paymasterInfo,
AggregatorStakeInfo aggregatorInfo);
/**
* return value of getSenderAddress
*/
error SenderAddressResult(address sender);
/**
* return value of simulateHandleOp
*/
error ExecutionResult(uint256 preOpGas, uint256 paid, uint48 validAfter, uint48 validUntil, bool targetSuccess, bytes targetResult);
//UserOps handled, per aggregator
struct UserOpsPerAggregator {
UserOperation[] userOps;
// aggregator address
IAggregator aggregator;
// aggregated signature
bytes signature;
}
/**
* Execute a batch of UserOperation.
* 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(UserOperation[] 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.
*/
function getUserOpHash(UserOperation calldata userOp) external view returns (bytes32);
/**
* Simulate a call to account.validateUserOp and paymaster.validatePaymasterUserOp.
* @dev this method always revert. Successful result is ValidationResult error. other errors are failures.
* @dev The node must also verify it doesn't use banned opcodes, and that it doesn't reference storage outside the account's data.
* @param userOp the user operation to validate.
*/
function simulateValidation(UserOperation calldata userOp) external;
/**
* gas and return values during simulation
* @param preOpGas the gas used for validation (including preValidationGas)
* @param prefund the required prefund for this operation
* @param sigFailed validateUserOp's (or paymaster's) signature check failed
* @param validAfter - first timestamp this UserOp is valid (merging account and paymaster time-range)
* @param validUntil - last timestamp this UserOp is valid (merging account and paymaster time-range)
* @param paymasterContext returned by validatePaymasterUserOp (to be passed into postOp)
*/
struct ReturnInfo {
uint256 preOpGas;
uint256 prefund;
bool sigFailed;
uint48 validAfter;
uint48 validUntil;
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;
/**
* simulate full execution of a UserOperation (including both validation and target execution)
* this method will always revert with "ExecutionResult".
* it performs full validation of the UserOperation, but ignores signature error.
* an optional target address is called after the userop succeeds, and its value is returned
* (before the entire call is reverted)
* Note that in order to collect the the success/failure of the target call, it must be executed
* with trace enabled to track the emitted events.
* @param op the UserOperation to simulate
* @param target if nonzero, a target address to call after userop simulation. If called, the targetSuccess and targetResult
* are set to the return from that call.
* @param targetCallData callData to pass to target address
*/
function simulateHandleOp(UserOperation calldata op, address target, bytes calldata targetCallData) external;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {AddressDLLLib} from "../libs/AddressDLLLib.sol";
import {RepeatableFunctionReferenceDLLLib} from "../libs/RepeatableFunctionReferenceDLLLib.sol";
import {FunctionReferenceDLLLib} from "../libs/FunctionReferenceDLLLib.sol";
import {FunctionReferenceLib} from "../libs/FunctionReferenceLib.sol";
import {SelectorRegistryLib} from "../libs/SelectorRegistryLib.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
import "../common/PluginManifest.sol";
import "../common/Constants.sol";
/**
* @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support installing and uninstalling plugins.
*/
contract PluginManager {
using AddressDLLLib for AddressDLL;
using FunctionReferenceDLLLib for Bytes21DLL;
using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
using FunctionReferenceLib for FunctionReference;
using FunctionReferenceLib for bytes21;
using SelectorRegistryLib for bytes4;
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
enum AssociatedFunctionType {
HOOK,
VALIDATION_FUNCTION
}
error PluginNotImplementInterface();
error InvalidPluginManifest();
error InvalidPluginManifestHash();
error InvalidPluginDependency(address plugin);
error PluginUsedByOthers(address plugin);
error ExecutionDetailAlreadySet(address plugin, bytes4 selector);
error ExecuteFromPluginExternalAlreadySet(address plugin, address externalAddress);
error ExecuteFromPluginExternalAlreadyUnset(address plugin, address externalAddress);
error ValidationFunctionAlreadySet(bytes4 selector);
error FailToCallOnInstall(address plugin, bytes revertReason);
error OnlyDelegated();
error HookDependencyNotPermitted();
error InvalidExecutionSelector(address plugin, bytes4 selector);
modifier onlyDelegated() {
if (address(this) == __self) {
revert OnlyDelegated();
}
_;
}
/// @dev Refer to IPluginManager
function install(
address plugin,
bytes32 manifestHash,
bytes memory pluginInstallData,
FunctionReference[] memory dependencies,
address msca
) external onlyDelegated {
// revert if the plugin does not implement ERC-165 or does not support the IPlugin interface
if (!ERC165Checker.supportsInterface(plugin, type(IPlugin).interfaceId)) {
revert PluginNotImplementInterface();
}
WalletStorageV1Lib.Layout storage storageLayout = WalletStorageV1Lib.getLayout();
// revert internally if the plugin has already been installed on the modular account
storageLayout.installedPlugins.append(plugin);
IPlugin pluginToInstall = IPlugin(plugin);
// revert if manifestHash does not match the computed Keccak-256 hash of the plugin’s returned manifest
PluginManifest memory pluginManifest = pluginToInstall.pluginManifest();
if (manifestHash != keccak256(abi.encode(pluginManifest))) {
revert InvalidPluginManifestHash();
}
// store the plugin manifest hash
storageLayout.pluginDetails[plugin].manifestHash = manifestHash;
uint256 length = pluginManifest.interfaceIds.length;
for (uint256 i = 0; i < length; ++i) {
storageLayout.supportedInterfaces[pluginManifest.interfaceIds[i]] += 1;
}
// revert if any address in dependencies does not support the interface at its matching index in the manifest’s dependencyInterfaceIds,
// or if the two array lengths do not match,
// or if any of the dependencies are not already installed on the modular account
length = dependencies.length;
if (length != pluginManifest.dependencyInterfaceIds.length) {
revert InvalidPluginDependency(plugin);
}
for (uint256 i = 0; i < length; ++i) {
address dependencyPluginAddr = dependencies[i].plugin;
// if dependencyPluginAddr is msca address, then we don't actually introduce any new plugin dependency
// other than native dependency, so we do not need to perform any plugin dependency related logic
if (dependencyPluginAddr == msca) {
continue;
}
if (!ERC165Checker.supportsInterface(dependencyPluginAddr, pluginManifest.dependencyInterfaceIds[i])) {
revert InvalidPluginDependency(dependencyPluginAddr);
}
// the dependency plugin needs to be installed first
if (!storageLayout.installedPlugins.contains(dependencyPluginAddr)) {
revert InvalidPluginDependency(dependencyPluginAddr);
}
// each dependency’s record MUST also be updated to reflect that it has a new dependent
// record the plugin dependency, will revert if it's already installed
storageLayout.pluginDetails[plugin].dependencies.append(dependencies[i]);
// increment the dependency's dependentCounter since the current plugin is dependent on dependencyPlugin
storageLayout.pluginDetails[dependencyPluginAddr].dependentCounter += 1;
}
// record if this plugin is allowed to spend native token
if (pluginManifest.canSpendNativeToken) {
storageLayout.pluginDetails[plugin].canSpendNativeToken = true;
}
// record execution details
//////////////////////////////////////////////
// install execution functions and hooks
//////////////////////////////////////////////
length = pluginManifest.executionFunctions.length;
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = pluginManifest.executionFunctions[i];
if (storageLayout.executionDetails[selector].plugin != address(0)) {
revert ExecutionDetailAlreadySet(plugin, selector);
}
if (selector._isNativeFunctionSelector() || selector._isErc4337FunctionSelector() || selector._isIPluginFunctionSelector()) {
revert InvalidExecutionSelector(plugin, selector);
}
storageLayout.executionDetails[selector].plugin = plugin;
}
// install pre and post execution hooks
length = pluginManifest.executionHooks.length;
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = pluginManifest.executionHooks[i].selector;
FunctionReference memory preExecHook = _resolveManifestFunction(
pluginManifest.executionHooks[i].preExecHook,
plugin,
dependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK);
FunctionReference memory postExecHook = _resolveManifestFunction(
pluginManifest.executionHooks[i].postExecHook,
plugin,
dependencies,
ManifestAssociatedFunctionType.NONE,
AssociatedFunctionType.HOOK);
_addHookGroup(storageLayout.executionDetails[selector].executionHooks, preExecHook, postExecHook);
}
//////////////////////////////////////////////
// install validation functions and hooks
//////////////////////////////////////////////
// install userOpValidationFunctions
length = pluginManifest.userOpValidationFunctions.length;
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = pluginManifest.userOpValidationFunctions[i].executionSelector;
if (storageLayout.executionDetails[selector].userOpValidationFunction.pack() != EMPTY_FUNCTION_REFERENCE) {
revert ValidationFunctionAlreadySet(selector);
}
storageLayout.executionDetails[selector].userOpValidationFunction = _resolveManifestFunction(
pluginManifest.userOpValidationFunctions[i].associatedFunction,
plugin,
dependencies,
ManifestAssociatedFunctionType.NONE,
AssociatedFunctionType.VALIDATION_FUNCTION);
}
// install runtimeValidationFunctions
length = pluginManifest.runtimeValidationFunctions.length;
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = pluginManifest.runtimeValidationFunctions[i].executionSelector;
if (storageLayout.executionDetails[selector].runtimeValidationFunction.pack() != EMPTY_FUNCTION_REFERENCE) {
revert ValidationFunctionAlreadySet(selector);
}
storageLayout.executionDetails[selector].runtimeValidationFunction = _resolveManifestFunction(
pluginManifest.runtimeValidationFunctions[i].associatedFunction,
plugin,
dependencies,
ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW, // risk burning gas from the account
AssociatedFunctionType.VALIDATION_FUNCTION);
}
// install preUserOpValidationHooks
length = pluginManifest.preUserOpValidationHooks.length;
// force override to be safe
FunctionReference[] memory emptyDependencies = new FunctionReference[](0);
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = pluginManifest.preUserOpValidationHooks[i].executionSelector;
// revert internally
storageLayout.executionDetails[selector].preUserOpValidationHooks.append(
_resolveManifestFunction(
pluginManifest.preUserOpValidationHooks[i].associatedFunction,
plugin,
emptyDependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK)
);
}
// install preRuntimeValidationHooks
length = pluginManifest.preRuntimeValidationHooks.length;
for (uint256 i = 0; i < length; ++i) {
// revert internally
storageLayout.executionDetails[pluginManifest.preRuntimeValidationHooks[i].executionSelector]
.preRuntimeValidationHooks.append(
_resolveManifestFunction(
pluginManifest.preRuntimeValidationHooks[i].associatedFunction,
plugin,
emptyDependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK)
);
}
// store the plugin’s permitted function selectors and external contract calls to be able to validate calls
// to executeFromPlugin and executeFromPluginExternal
//////////////////////////////////////////////
// permissions for executeFromPlugin
//////////////////////////////////////////////
// native functions or execution functions already installed on the MSCA that this plugin will be able to call
length = pluginManifest.permittedExecutionSelectors.length;
for (uint256 i = 0; i < length; ++i) {
// enable PermittedPluginCall
storageLayout.permittedPluginCalls[plugin][pluginManifest.permittedExecutionSelectors[i]] = true;
}
//////////////////////////////////////////////
// permissions for executeFromPluginExternal
//////////////////////////////////////////////
// is the plugin permitted to call any external contracts and selectors
if (pluginManifest.permitAnyExternalAddress) {
storageLayout.pluginDetails[plugin].anyExternalAddressPermitted = true;
} else {
// more limited access - record external contract calls that this plugin will be able to make
length = pluginManifest.permittedExternalCalls.length;
for (uint256 i = 0; i < length; ++i) {
ManifestExternalCallPermission memory externalCallPermission = pluginManifest.permittedExternalCalls[i];
PermittedExternalCall storage permittedExternalCall = storageLayout.permittedExternalCalls[plugin][externalCallPermission.externalAddress];
if (permittedExternalCall.addressPermitted) {
revert ExecuteFromPluginExternalAlreadySet(plugin, externalCallPermission.externalAddress);
}
permittedExternalCall.addressPermitted = true;
if (externalCallPermission.permitAnySelector) {
permittedExternalCall.anySelector = true;
} else {
uint256 permittedExternalCallSelectorsLength = externalCallPermission.selectors.length;
for (uint256 j = 0; j < permittedExternalCallSelectorsLength; ++j) {
permittedExternalCall.selectors[externalCallPermission.selectors[j]] = true;
}
}
}
}
// call onInstall to initialize plugin data for the modular account
// solhint-disable-next-line no-empty-blocks
try IPlugin(plugin).onInstall(pluginInstallData) {}
catch (bytes memory revertReason) {
revert FailToCallOnInstall(plugin, revertReason);
}
}
/// @dev Refer to IPluginManager
function uninstall(
address plugin,
bytes memory config,
bytes memory pluginUninstallData
) external onlyDelegated returns (bool) {
WalletStorageV1Lib.Layout storage storageLayout = WalletStorageV1Lib.getLayout();
// revert internally if plugin was not installed before
storageLayout.installedPlugins.remove(plugin);
PluginManifest memory pluginManifest;
if (config.length > 0) {
// the modular account MAY implement the capability for the manifest to be encoded in the config field as a parameter
pluginManifest = abi.decode(config, (PluginManifest));
} else {
pluginManifest = IPlugin(plugin).pluginManifest();
}
// revert if the hash of the manifest used at install time does not match the computed Keccak-256 hash of the plugin’s current manifest
if (storageLayout.pluginDetails[plugin].manifestHash != keccak256(abi.encode(pluginManifest))) {
revert InvalidPluginManifestHash();
}
// revert if there is at least 1 other installed plugin that depends on validation functions or hooks added by this plugin;
// plugins used as dependencies must not be uninstalled while dependent plugins exist
if (storageLayout.pluginDetails[plugin].dependentCounter != 0) {
revert PluginUsedByOthers(plugin);
}
// each dependency’s record SHOULD be updated to reflect that it has no longer has this plugin as a dependent
_removeDependencies(plugin, storageLayout);
// remove records for the plugin’s dependencies, injected permitted call hooks, permitted function selectors, and permitted external contract calls
// uninstall the components in reverse order (by component type) of their installation
//////////////////////////////////////////////
// permissions for executeFromPluginExternal
//////////////////////////////////////////////
if (pluginManifest.permitAnyExternalAddress) {
storageLayout.pluginDetails[plugin].anyExternalAddressPermitted = false;
}
uint256 length;
if (!pluginManifest.permitAnyExternalAddress) {
length = pluginManifest.permittedExternalCalls.length;
for (uint256 i = 0; i < length; ++i) {
ManifestExternalCallPermission memory externalCallPermission = pluginManifest.permittedExternalCalls[i];
PermittedExternalCall storage permittedExternalCall = storageLayout.permittedExternalCalls[plugin][externalCallPermission.externalAddress];
if (!permittedExternalCall.addressPermitted) {
revert ExecuteFromPluginExternalAlreadyUnset(plugin, externalCallPermission.externalAddress);
}
permittedExternalCall.addressPermitted = false;
if (externalCallPermission.permitAnySelector) {
permittedExternalCall.anySelector = false;
} else {
uint256 permittedExternalCallSelectorsLength = externalCallPermission.selectors.length;
for (uint256 j = 0; j < permittedExternalCallSelectorsLength; ++j) {
permittedExternalCall.selectors[externalCallPermission.selectors[j]] = false;
}
}
}
}
length = pluginManifest.permittedExecutionSelectors.length;
for (uint256 i = 0; i < length; ++i) {
// disable PermittedPluginCall
storageLayout.permittedPluginCalls[plugin][pluginManifest.permittedExecutionSelectors[i]] = false;
}
//////////////////////////////////////////////
// uninstall validation functions and hooks
//////////////////////////////////////////////
// uninstall preRuntimeValidationHooks
FunctionReference[] memory emptyDependencies = new FunctionReference[](0);
length = pluginManifest.preRuntimeValidationHooks.length;
for (uint256 i = 0; i < length; ++i) {
// revert internally
storageLayout.executionDetails[pluginManifest.preRuntimeValidationHooks[i].executionSelector]
.preRuntimeValidationHooks.remove(
_resolveManifestFunction(
pluginManifest.preRuntimeValidationHooks[i].associatedFunction,
plugin,
emptyDependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK)
);
}
// uninstall preUserOpValidationHooks
length = pluginManifest.preUserOpValidationHooks.length;
for (uint256 i = 0; i < length; ++i) {
// revert internally
storageLayout.executionDetails[pluginManifest.preUserOpValidationHooks[i].executionSelector]
.preUserOpValidationHooks.remove(
_resolveManifestFunction(
pluginManifest.preUserOpValidationHooks[i].associatedFunction,
plugin,
emptyDependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK)
);
}
// uninstall runtimeValidationFunctions
FunctionReference memory emptyFunctionReference = EMPTY_FUNCTION_REFERENCE.unpack();
length = pluginManifest.runtimeValidationFunctions.length;
for (uint256 i = 0; i < length; ++i) {
storageLayout.executionDetails[pluginManifest.runtimeValidationFunctions[i].executionSelector].runtimeValidationFunction = emptyFunctionReference;
}
// uninstall userOpValidationFunctions
length = pluginManifest.userOpValidationFunctions.length;
for (uint256 i = 0; i < length; ++i) {
storageLayout.executionDetails[pluginManifest.userOpValidationFunctions[i].executionSelector].userOpValidationFunction = emptyFunctionReference;
}
//////////////////////////////////////////////
// uninstall execution functions and hooks
//////////////////////////////////////////////
_removeExecutionHooks(plugin, pluginManifest.executionHooks, storageLayout);
length = pluginManifest.executionFunctions.length;
for (uint256 i = 0; i < length; ++i) {
storageLayout.executionDetails[pluginManifest.executionFunctions[i]].plugin = address(0);
}
length = pluginManifest.interfaceIds.length;
for (uint256 i = 0; i < length; ++i) {
storageLayout.supportedInterfaces[pluginManifest.interfaceIds[i]] -= 1;
}
// reset all members that are not mappings and also recurse into the members unless they're mappings
delete storageLayout.pluginDetails[plugin];
// call the plugin’s onUninstall callback with the data provided in the uninstallData parameter;
// This serves to clear the plugin state for the modular account;
// If onUninstall reverts, execution SHOULD continue to allow the uninstall to complete
bool onUninstallSucceeded = true;
// solhint-disable-next-line no-empty-blocks
try IPlugin(plugin).onUninstall(pluginUninstallData) {}
catch {
// leave it up to the caller if we want to revert if the plugin storage isn't cleaned up
onUninstallSucceeded = false;
}
return onUninstallSucceeded;
}
/**
* @dev Resolve manifest function.
* For functions of type `ManifestAssociatedFunctionType.DEPENDENCY`, the MSCA MUST find the plugin address
* of the function at `dependencies[dependencyIndex]` during the call to `installPlugin(config)`.
* A plugin can no longer use hooks from other plugins to be added on Execution and/or Validation function selectors
* in its own manifest. We'll revert if hook is provided as dependency from an external plugin.
* @param allowedMagicValue which magic value (if any) is permissible for the function type to resolve.
* @param associatedFunctionType the type of associated function, either a validation function or a hook, as opposed to execution functions
*/
function _resolveManifestFunction(
ManifestFunction memory manifestFunction,
address plugin,
FunctionReference[] memory dependencies,
ManifestAssociatedFunctionType allowedMagicValue,
AssociatedFunctionType associatedFunctionType)
internal pure returns (FunctionReference memory) {
// revert if it's hook and provided as dependency
if (associatedFunctionType == AssociatedFunctionType.HOOK
&& manifestFunction.functionType == ManifestAssociatedFunctionType.DEPENDENCY) {
revert HookDependencyNotPermitted();
}
if (manifestFunction.functionType == ManifestAssociatedFunctionType.SELF) {
return FunctionReference(plugin, manifestFunction.functionId);
} else if (manifestFunction.functionType == ManifestAssociatedFunctionType.DEPENDENCY) {
// out of boundary
if (manifestFunction.dependencyIndex >= dependencies.length) {
revert InvalidPluginManifest();
}
return dependencies[manifestFunction.dependencyIndex];
} else if (manifestFunction.functionType == ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW) {
if (allowedMagicValue == ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW) {
return RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE.unpack();
} else {
revert InvalidPluginManifest();
}
} else if (manifestFunction.functionType == ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY) {
if (allowedMagicValue == ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY) {
return PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE.unpack();
} else {
revert InvalidPluginManifest();
}
} else {
return EMPTY_FUNCTION_REFERENCE.unpack();
}
}
function _addHookGroup(HookGroup storage hookGroup, FunctionReference memory preExecHook, FunctionReference memory postExecHook)
internal {
bytes21 packedPreExecHook = preExecHook.pack();
if (packedPreExecHook == EMPTY_FUNCTION_REFERENCE) {
if (postExecHook.pack() == EMPTY_FUNCTION_REFERENCE) {
// pre and post hooks cannot be null at the same time
revert InvalidFunctionReference();
}
hookGroup.postOnlyHooks.append(postExecHook);
} else {
hookGroup.preHooks.append(preExecHook);
if (postExecHook.pack() != EMPTY_FUNCTION_REFERENCE) {
hookGroup.preToPostHooks[packedPreExecHook].append(postExecHook);
}
}
}
function _removeHookGroup(HookGroup storage hookGroup, FunctionReference memory preExecHook, FunctionReference memory postExecHook)
internal {
bytes21 packedPreExecHook = preExecHook.pack();
if (packedPreExecHook == EMPTY_FUNCTION_REFERENCE) {
if (postExecHook.pack() != EMPTY_FUNCTION_REFERENCE) {
// pre and post hooks cannot be null at the same time
hookGroup.postOnlyHooks.remove(postExecHook);
}
} else {
hookGroup.preHooks.remove(preExecHook);
if (postExecHook.pack() != EMPTY_FUNCTION_REFERENCE) {
hookGroup.preToPostHooks[packedPreExecHook].remove(postExecHook);
}
}
}
function _removeDependencies(address plugin, WalletStorageV1Lib.Layout storage storageLayout) internal {
Bytes21DLL storage pluginDependencies = storageLayout.pluginDetails[plugin].dependencies;
uint256 length = pluginDependencies.size();
FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
FunctionReference[] memory dependencies;
for (uint256 i = 0; i < length; ++i) {
(dependencies, startFR) = pluginDependencies.getPaginated(startFR, 100);
for (uint j = 0; j < dependencies.length; ++j) {
storageLayout.pluginDetails[dependencies[j].plugin].dependentCounter -= 1;
storageLayout.pluginDetails[plugin].dependencies.remove(dependencies[j]);
}
if (startFR.pack() == EMPTY_FUNCTION_REFERENCE) {
break;
}
}
}
function _removeExecutionHooks(address plugin, ManifestExecutionHook[] memory executionHooks, WalletStorageV1Lib.Layout storage storageLayout) internal {
uint256 length = executionHooks.length;
FunctionReference[] memory dependencies = new FunctionReference[](0);
for (uint256 i = 0; i < length; ++i) {
bytes4 selector = executionHooks[i].selector;
FunctionReference memory preExecHook = _resolveManifestFunction(
executionHooks[i].preExecHook,
plugin,
dependencies,
ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
AssociatedFunctionType.HOOK);
FunctionReference memory postExecHookToRemove = _resolveManifestFunction(
executionHooks[i].postExecHook,
plugin,
dependencies,
ManifestAssociatedFunctionType.NONE,
AssociatedFunctionType.HOOK);
_removeHookGroup(storageLayout.executionDetails[selector].executionHooks, preExecHook, postExecHookToRemove);
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {IERC1271} from "@openzeppelin/contracts/interfaces/IERC1271.sol";
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
import {IPlugin} from "../../interfaces/IPlugin.sol";
import {BaseMSCA} from "../BaseMSCA.sol";
import {PluginManager} from "../../managers/PluginManager.sol";
import {DefaultCallbackHandler} from "../../../../../callback/DefaultCallbackHandler.sol";
import {ExecutionUtils} from "../../../../../utils/ExecutionUtils.sol";
import {RepeatableFunctionReferenceDLLLib} from "../../libs/RepeatableFunctionReferenceDLLLib.sol";
import {FunctionReferenceLib} from "../../libs/FunctionReferenceLib.sol";
import {WalletStorageV1Lib} from "../../libs/WalletStorageV1Lib.sol";
import {ValidationDataLib} from "../../libs/ValidationDataLib.sol";
import "../../common/Errors.sol";
import "../../common/Structs.sol";
import "../../common/Constants.sol";
/**
* @dev Semi-MSCA that enshrines single owner into the account storage.
*/
contract SingleOwnerMSCA is BaseMSCA, DefaultCallbackHandler, UUPSUpgradeable, IERC1271 {
using ExecutionUtils for address;
using ECDSA for bytes32;
using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
using FunctionReferenceLib for bytes21;
using FunctionReferenceLib for FunctionReference;
using ValidationDataLib for ValidationData;
enum FunctionId {
NATIVE_RUNTIME_VALIDATION_OWNER_OR_SELF,
NATIVE_USER_OP_VALIDATION_OWNER
}
event SingleOwnerMSCAInitialized(address indexed account, address indexed entryPointAddress, address owner);
event OwnershipTransferred(address indexed account, address indexed previousOwner, address indexed newOwner);
error InvalidOwnerForMSCA(address account, address owner);
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyFromEntryPointOrOwnerOrSelf() {
_checkFromEPOrOwnerOrSelf();
_;
}
constructor(IEntryPoint _newEntryPoint, PluginManager _newPluginManager) BaseMSCA(_newEntryPoint, _newPluginManager) {
// lock the implementation contract so it can only be called from proxies
_disableWalletStorageInitializers();
}
/// @notice Initializes the account with a set of plugins
/// @dev No dependencies or hooks can be injected with this installation. For a full installation, please use installPlugin.
/// @param owner The initial owner
function initializeSingleOwnerMSCA(address owner) external walletStorageInitializer {
if (owner == address(0)) {
revert InvalidOwnerForMSCA(address(this), owner);
}
_transferNativeOwnership(owner);
emit SingleOwnerMSCAInitialized(address(this), address(entryPoint), owner);
}
/// @inheritdoc IERC1271
function isValidSignature(bytes32 hash, bytes memory signature) external override view returns (bytes4) {
address owner = WalletStorageV1Lib.getLayout().owner;
if (owner == address(0)) {
// isValidSignature is installed via plugin, so it should fallback to the plugin
(bool success, bytes memory returnData) = WalletStorageV1Lib.getLayout().executionDetails[IERC1271.isValidSignature.selector].plugin.staticcall(
abi.encodeCall(IERC1271.isValidSignature, (hash, signature)));
if (!success) {
return EIP1271_INVALID_SIGNATURE;
}
return abi.decode(returnData, (bytes4));
}
if (_verifySignature(owner, hash, signature)) {
return EIP1271_VALID_SIGNATURE;
}
return EIP1271_INVALID_SIGNATURE;
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current msg.sender.
*/
function transferNativeOwnership(address newOwner) public
onlyFromEntryPointOrOwnerOrSelf
validateNativeFunction {
if (newOwner == address(0)) {
revert InvalidOwnerForMSCA(address(this), newOwner);
}
_transferNativeOwnership(newOwner);
}
/**
* @dev Leaves the contract without owner. Can only be initiated by the current owner.
*
* NOTE: Irreversible. Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner. Please
* make sure you've already have other backup validations before calling this method.
* If the user wants to switch to the validations provided by plugins, please call this
* function after you install the plugin, so owner will be disabled.
*/
function renounceNativeOwnership() public
onlyFromEntryPointOrOwnerOrSelf
validateNativeFunction {
_transferNativeOwnership(address(0));
}
/**
* @dev Returns the current owner.
*/
function getNativeOwner() public view returns (address) {
return WalletStorageV1Lib.getLayout().owner;
}
function supportsInterface(bytes4 interfaceId) public view override(BaseMSCA, DefaultCallbackHandler) returns (bool) {
// BaseMSCA has already implemented ERC165
return BaseMSCA.supportsInterface(interfaceId)
|| interfaceId == type(IERC721Receiver).interfaceId
|| interfaceId == type(IERC1155Receiver).interfaceId
|| interfaceId == type(IERC1271).interfaceId;
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferNativeOwnership(address newOwner) internal {
address oldOwner = WalletStorageV1Lib.getLayout().owner;
WalletStorageV1Lib.getLayout().owner = newOwner;
emit OwnershipTransferred(address(this), oldOwner, newOwner);
}
/**
* @dev We run the native validation function if it's enabled, otherwise we fallback to the plugin validation functions.
* In either case, we run the hooks from plugins if there's any.
*/
function _authenticateAndAuthorizeUserOp(UserOperation calldata userOp, bytes32 userOpHash)
internal override returns (uint256 validationData) {
// onlyFromEntryPoint is applied in the caller
// if there is no function defined for the selector, or if userOp.callData.length < 4, then execution MUST revert
if (userOp.callData.length < 4) {
revert NotFoundSelector();
}
bytes4 selector = bytes4(userOp.callData[0 : 4]);
if (selector == bytes4(0)) {
revert NotFoundSelector();
}
ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
// pre hook
ValidationData memory unpackedValidationData = _processPreUserOpValidationHooks(executionDetail, userOp, userOpHash);
uint256 currentValidationData;
// userOp validation
address owner = WalletStorageV1Lib.getLayout().owner;
// no native validation function
if (owner == address(0)) {
FunctionReference memory validationFunction = executionDetail.userOpValidationFunction;
bytes21 packedValidationFunction = validationFunction.pack();
if (packedValidationFunction == EMPTY_FUNCTION_REFERENCE
|| packedValidationFunction == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(validationFunction.functionId);
}
IPlugin userOpValidatorPlugin = IPlugin(validationFunction.plugin);
// execute the validation function with the user operation and its hash as parameters using the call opcode
currentValidationData = userOpValidatorPlugin.userOpValidationFunction(executionDetail.userOpValidationFunction.functionId, userOp, userOpHash);
} else {
if (_verifySignature(owner, userOpHash, userOp.signature)) {
currentValidationData = SIG_VALIDATION_SUCCEEDED;
} else {
currentValidationData = SIG_VALIDATION_FAILED;
}
}
// intercept with last result
unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
// only revert on unexpected values
revert InvalidAuthorizer();
}
validationData = unpackedValidationData._packValidationData();
}
function _processPreRuntimeHooksAndValidation(bytes4 selector)
internal override {
if (msg.sender == address(entryPoint)) {
// entryPoint should go through validateUserOp flow which calls userOpValidationFunction
return;
}
ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
FunctionReference memory validationFunction = executionDetail.runtimeValidationFunction;
RepeatableBytes21DLL storage preRuntimeValidationHooksDLL = executionDetail.preRuntimeValidationHooks;
uint256 totalUniqueHookCount = preRuntimeValidationHooksDLL.getUniqueItems();
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
FunctionReference[] memory preRuntimeValidationHooks;
FunctionReference memory nextHook;
for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
(preRuntimeValidationHooks, nextHook) = preRuntimeValidationHooksDLL.getPaginated(startHook, 10);
for (uint256 j = 0; j < preRuntimeValidationHooks.length; ++j) {
// revert on EMPTY_FUNCTION_REFERENCE, RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE, PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
// if any revert, the outer call MUST revert
bytes21 packedPreRuntimeValidationHook = preRuntimeValidationHooks[j].pack();
if (packedPreRuntimeValidationHook == EMPTY_FUNCTION_REFERENCE
|| packedPreRuntimeValidationHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedPreRuntimeValidationHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(preRuntimeValidationHooks[j].functionId);
}
IPlugin preRuntimeValidationHookPlugin = IPlugin(preRuntimeValidationHooks[j].plugin);
try preRuntimeValidationHookPlugin.preRuntimeValidationHook(preRuntimeValidationHooks[j].functionId, msg.sender, msg.value, msg.data) {}
catch (bytes memory revertReason) {
revert PreRuntimeValidationHookFailed(preRuntimeValidationHooks[j].plugin, preRuntimeValidationHooks[j].functionId, revertReason);
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
address owner = WalletStorageV1Lib.getLayout().owner;
// no native validation function
if (owner == address(0)) {
// call runtimeValidationFunction if it's not always allowed
if (validationFunction.pack() != RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE) {
try IPlugin(validationFunction.plugin).runtimeValidationFunction(validationFunction.functionId, msg.sender, msg.value, msg.data) {}
catch (bytes memory revertReason) {
revert RuntimeValidationFailed(validationFunction.plugin, validationFunction.functionId, revertReason);
}
}
return;
} else {
// the msg.sender should be the owner of the account or itself
if (msg.sender == owner || msg.sender == address(this)) {
return;
} else {
revert UnauthorizedCaller();
}
}
}
/// @inheritdoc UUPSUpgradeable
function upgradeTo(address newImplementation)
public
override
onlyProxy
validateNativeFunction {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
/// @inheritdoc UUPSUpgradeable
function upgradeToAndCall(address newImplementation, bytes memory data)
public
payable
override
onlyProxy
validateNativeFunction {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
/**
* @dev The function is overridden here so more granular ACLs to the upgrade mechanism should be enforced by plugins.
*/
function _authorizeUpgrade(address newImplementation) internal override {}
function _processPreUserOpValidationHooks(
ExecutionDetail storage executionDetail,
UserOperation calldata userOp,
bytes32 userOpHash) internal override returns (ValidationData memory unpackedValidationData) {
unpackedValidationData = ValidationData(0, 0xFFFFFFFFFFFF, address(0));
// if the function selector has associated pre user operation validation hooks, then those hooks MUST be run sequentially
uint256 totalUniqueHookCount = executionDetail.preUserOpValidationHooks.getUniqueItems();
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
FunctionReference[] memory preUserOpValidatorHooks;
FunctionReference memory nextHook;
uint256 currentValidationData;
for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
(preUserOpValidatorHooks, nextHook) = executionDetail.preUserOpValidationHooks.getPaginated(startHook, 10);
for (uint256 j = 0; j < preUserOpValidatorHooks.length; ++j) {
bytes21 packedUserOpValidatorHook = preUserOpValidatorHooks[j].pack();
// if any revert, the outer call MUST revert
if (packedUserOpValidatorHook == EMPTY_FUNCTION_REFERENCE
|| packedUserOpValidatorHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedUserOpValidatorHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidHookFunctionId(preUserOpValidatorHooks[j].functionId);
}
IPlugin preUserOpValidationHookPlugin = IPlugin(preUserOpValidatorHooks[j].plugin);
currentValidationData = preUserOpValidationHookPlugin.preUserOpValidationHook(preUserOpValidatorHooks[j].functionId, userOp, userOpHash);
unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
// if any return an authorizer value other than 0 or 1, execution MUST revert
if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
revert InvalidAuthorizer();
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
return unpackedValidationData;
}
function _checkFromEPOrOwnerOrSelf() internal view {
// all need to go through validation first, which means being initiated by the owner or account
if (msg.sender != address(entryPoint) && msg.sender != WalletStorageV1Lib.getLayout().owner && msg.sender != address(this)) {
revert UnauthorizedCaller();
}
}
/**
* @dev For EOA owner, run ecrecover. For smart contract owner, run 1271 staticcall.
*/
function _verifySignature(address owner, bytes32 hash, bytes memory signature) internal view returns (bool) {
// EOA owner (ECDSA)
// if the signature (personal sign) is signed over userOpHash.toEthSignedMessageHash (prepended with 'x\x19Ethereum Signed Message:\n32'), then we recover using userOpHash.toEthSignedMessageHash;
// or if the signature (typed data sign) is signed over userOpHash directly, then we recover userOpHash directly
(address recovered, ECDSA.RecoverError error) = hash.toEthSignedMessageHash().tryRecover(signature);
if (error == ECDSA.RecoverError.NoError && recovered == owner) {
return true;
}
(recovered, error) = hash.tryRecover(signature);
if (error == ECDSA.RecoverError.NoError && recovered == owner) {
return true;
}
if (SignatureChecker.isValidERC1271SignatureNow(owner, hash, signature)) {
// smart contract owner.isValidSignature should be smart enough to sign over the non-modified hash or over
// the hash that is modified in the way owner would expect
return true;
}
return false;
}
}// SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.24; /** * @notice Throws when the caller is unexpected. */ error UnauthorizedCaller(); /** * @notice Throws when the selector is not found. */ error NotFoundSelector(); /** * @notice Throws when authorizer is invalid. */ error InvalidAuthorizer(); error InvalidValidationFunctionId(uint8 functionId); error InvalidFunctionReference(); error ItemAlreadyExists(); error ItemDoesNotExist(); error InvalidLimit(); error InvalidExecutionFunction(bytes4 selector); error InvalidInitializationInput(); error Create2FailedDeployment(); error InvalidLength(); error Unsupported();
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
pragma solidity ^0.8.0;
/**
* @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
* instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
* be specified by overriding the virtual {_implementation} function.
*
* Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
* different contract through the {_delegate} function.
*
* The success and return data of the delegated call will be returned back to the caller of the proxy.
*/
abstract contract Proxy {
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
/**
* @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
* and {_fallback} should delegate.
*/
function _implementation() internal view virtual returns (address);
/**
* @dev Delegates the current call to the address returned by `_implementation()`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
* function in the contract matches the call data.
*/
fallback() external payable virtual {
_fallback();
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
* is empty.
*/
receive() external payable virtual {
_fallback();
}
/**
* @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
* call, or as part of the Solidity `fallback` or `receive` functions.
*
* If overridden should call `super._beforeFallback()`.
*/
function _beforeFallback() internal virtual {}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*/
abstract contract ERC1967Upgrade is IERC1967 {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation address.
*/
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Perform implementation upgrade
*
* Emits an {Upgraded} event.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Perform implementation upgrade with additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
/**
* @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Returns the current admin.
*/
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {AdminChanged} event.
*/
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
*/
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Returns the current beacon.
*/
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
/**
* @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
* not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
*
* Emits a {BeaconUpgraded} event.
*/
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
/* solhint-disable no-inline-assembly */
import {calldataKeccak} from "../core/Helpers.sol";
/**
* 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 callGasLimit the gas limit passed to the callData method call.
* @param verificationGasLimit gas used for validateUserOp and validatePaymasterUserOp.
* @param preVerificationGas gas not calculated by the handleOps method, but added to the gas paid. Covers batch overhead.
* @param maxFeePerGas same as EIP-1559 gas parameter.
* @param maxPriorityFeePerGas same as EIP-1559 gas parameter.
* @param paymasterAndData if set, this field holds the paymaster address and paymaster-specific 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 UserOperation {
address sender;
uint256 nonce;
bytes initCode;
bytes callData;
uint256 callGasLimit;
uint256 verificationGasLimit;
uint256 preVerificationGas;
uint256 maxFeePerGas;
uint256 maxPriorityFeePerGas;
bytes paymasterAndData;
bytes signature;
}
/**
* Utility functions helpful when working with UserOperation structs.
*/
library UserOperationLib {
function getSender(UserOperation calldata userOp) internal pure returns (address) {
address data;
//read sender from userOp, which is first userOp member (saves 800 gas...)
assembly {data := calldataload(userOp)}
return address(uint160(data));
}
//relayer/block builder might submit the TX with higher priorityFee, but the user should not
// pay above what he signed for.
function gasPrice(UserOperation calldata userOp) internal view returns (uint256) {
unchecked {
uint256 maxFeePerGas = userOp.maxFeePerGas;
uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
if (maxFeePerGas == maxPriorityFeePerGas) {
//legacy mode (for networks that don't support basefee opcode)
return maxFeePerGas;
}
return min(maxFeePerGas, maxPriorityFeePerGas + block.basefee);
}
}
function pack(UserOperation calldata userOp) internal pure returns (bytes memory ret) {
address sender = getSender(userOp);
uint256 nonce = userOp.nonce;
bytes32 hashInitCode = calldataKeccak(userOp.initCode);
bytes32 hashCallData = calldataKeccak(userOp.callData);
uint256 callGasLimit = userOp.callGasLimit;
uint256 verificationGasLimit = userOp.verificationGasLimit;
uint256 preVerificationGas = userOp.preVerificationGas;
uint256 maxFeePerGas = userOp.maxFeePerGas;
uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
bytes32 hashPaymasterAndData = calldataKeccak(userOp.paymasterAndData);
return abi.encode(
sender, nonce,
hashInitCode, hashCallData,
callGasLimit, verificationGasLimit, preVerificationGas,
maxFeePerGas, maxPriorityFeePerGas,
hashPaymasterAndData
);
}
function hash(UserOperation calldata userOp) internal pure returns (bytes32) {
return keccak256(pack(userOp));
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.12;
/**
* 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,staked, stake) fit into one cell (used during handleOps)
* and the rest fit into a 2nd cell.
* 112 bit allows for 10^15 eth
* 48 bit for full timestamp
* 32 bit allows 150 years for unstake delay
*/
struct DepositInfo {
uint112 deposit;
bool staked;
uint112 stake;
uint32 unstakeDelaySec;
uint48 withdrawTime;
}
//API struct used by getStakeInfo and simulateValidation
struct StakeInfo {
uint256 stake;
uint256 unstakeDelaySec;
}
/// @return info - full deposit information of given account
function getDepositInfo(address account) external view returns (DepositInfo memory info);
/// @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
*/
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;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
import "./UserOperation.sol";
/**
* Aggregated Signatures validator.
*/
interface IAggregator {
/**
* validate aggregated signature.
* revert if the aggregated signature does not match the given list of operations.
*/
function validateSignatures(UserOperation[] calldata userOps, bytes calldata signature) external view;
/**
* validate signature of a single userOp
* This method is should be called by bundler after EntryPoint.simulateValidation() returns (reverts) with ValidationResultWithAggregation
* First it validates the signature over the userOp. Then it returns data to be used when creating the handleOps.
* @param userOp the userOperation received from the user.
* @return sigForUserOp the value to put into the signature field of the userOp when calling handleOps.
* (usually empty, unless account and aggregator support some kind of "multisig"
*/
function validateUserOpSignature(UserOperation calldata userOp)
external view returns (bytes memory sigForUserOp);
/**
* aggregate multiple signatures into a single value.
* This method is called off-chain to calculate the signature to pass with handleOps()
* bundler MAY use optimized custom code perform this aggregation
* @param userOps array of UserOperations to collect the signatures from.
* @return aggregatedSignature the aggregated signature
*/
function aggregateSignatures(UserOperation[] calldata userOps) external view returns (bytes memory aggregatedSignature);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
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;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/introspection/ERC165Checker.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Library used to query support of an interface declared via {IERC165}.
*
* Note that these functions return the actual result of the query: they do not
* `revert` if an interface is not supported. It is up to the caller to decide
* what to do in these cases.
*/
library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
/**
* @dev Returns true if `account` supports the {IERC165} interface.
*/
function supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return
supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
/**
* @dev Returns true if `account` supports the interface defined by
* `interfaceId`. Support for {IERC165} itself is queried automatically.
*
* See {IERC165-supportsInterface}.
*/
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
/**
* @dev Returns a boolean array where each value corresponds to the
* interfaces passed in and whether they're supported or not. This allows
* you to batch check interfaces for a contract where your expectation
* is that some interfaces may not be supported.
*
* See {IERC165-supportsInterface}.
*
* _Available since v3.4._
*/
function getSupportedInterfaces(
address account,
bytes4[] memory interfaceIds
) internal view returns (bool[] memory) {
// an array of booleans corresponding to interfaceIds and whether they're supported or not
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
// query support of ERC165 itself
if (supportsERC165(account)) {
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
/**
* @dev Returns true if `account` supports all the interfaces defined in
* `interfaceIds`. Support for {IERC165} itself is queried automatically.
*
* Batch-querying can lead to gas savings by skipping repeated checks for
* {IERC165} support.
*
* See {IERC165-supportsInterface}.
*/
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!supportsERC165(account)) {
return false;
}
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
/**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interface with
* identifier interfaceId, false otherwise
* @dev Assumes that account contains a contract that supports ERC165, otherwise
* the behavior of this method is undefined. This precondition can be checked
* with {supportsERC165}.
*
* Some precompiled contracts will falsely indicate support for a given interface, so caution
* should be exercised when using this function.
*
* Interface identification is specified in ERC-165.
*/
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
// prepare call
bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);
// perform static call
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 0;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";
import "../common/Structs.sol";
import "../common/PluginManifest.sol";
/**
* @dev Implements https://eips.ethereum.org/EIPS/eip-6900. Plugins must implement this interface to support plugin management and interactions with MSCAs.
*/
interface IPlugin {
/// @notice Initialize plugin data for the modular account.
/// @dev Called by the modular account during `installPlugin`.
/// @param data Optional bytes array to be decoded and used by the plugin to setup initial plugin data for the modular account.
function onInstall(bytes calldata data) external;
/// @notice Clear plugin data for the modular account.
/// @dev Called by the modular account during `uninstallPlugin`.
/// @param data Optional bytes array to be decoded and used by the plugin to clear plugin data for the modular account.
function onUninstall(bytes calldata data) external;
/// @notice Run the pre user operation validation hook specified by the `functionId`.
/// @dev Pre user operation validation hooks MUST NOT return an authorizer value other than 0 or 1.
/// @param functionId An identifier that routes the call to different internal implementations, should there be more than one.
/// @param userOp The user operation.
/// @param userOpHash The user operation hash.
/// @return Packed validation data for validAfter (6 bytes), validUntil (6 bytes), and authorizer (20 bytes).
function preUserOpValidationHook(uint8 functionId, UserOperation calldata userOp, bytes32 userOpHash) external returns (uint256);
/// @notice Run the user operation validationFunction specified by the `functionId`.
/// @param functionId An identifier that routes the call to different internal implementations, should there be
/// more than one.
/// @param userOp The user operation.
/// @param userOpHash The user operation hash.
/// @return Packed validation data for validAfter (6 bytes), validUntil (6 bytes), and authorizer (20 bytes).
function userOpValidationFunction(uint8 functionId, UserOperation calldata userOp, bytes32 userOpHash)
external
returns (uint256);
/// @notice Run the pre runtime validation hook specified by the `functionId`.
/// @dev To indicate the entire call should revert, the function MUST revert.
/// @param functionId An identifier that routes the call to different internal implementations, should there be more than one.
/// @param sender The caller address.
/// @param value The call value.
/// @param data The calldata sent.
function preRuntimeValidationHook(uint8 functionId, address sender, uint256 value, bytes calldata data) external;
/// @notice Run the runtime validationFunction specified by the `functionId`.
/// @dev To indicate the entire call should revert, the function MUST revert.
/// @param functionId An identifier that routes the call to different internal implementations, should there be
/// more than one.
/// @param sender The caller address.
/// @param value The call value.
/// @param data The calldata sent.
function runtimeValidationFunction(uint8 functionId, address sender, uint256 value, bytes calldata data)
external;
/// @notice Run the pre execution hook specified by the `functionId`.
/// @dev To indicate the entire call should revert, the function MUST revert.
/// @param functionId An identifier that routes the call to different internal implementations, should there be more than one.
/// @param sender The caller address.
/// @param value The call value.
/// @param data The calldata sent.
/// @return context Context to pass to a post execution hook, if present. An empty bytes array MAY be returned.
function preExecutionHook(uint8 functionId, address sender, uint256 value, bytes calldata data) external returns (bytes memory context);
/// @notice Run the post execution hook specified by the `functionId`.
/// @dev To indicate the entire call should revert, the function MUST revert.
/// @param functionId An identifier that routes the call to different internal implementations, should there be more than one.
/// @param preExecHookData The context returned by its associated pre execution hook.
function postExecutionHook(uint8 functionId, bytes calldata preExecHookData) external;
/// @notice Describe the contents and intended configuration of the plugin.
/// @dev This manifest MUST stay constant over time.
/// @return A manifest describing the contents and intended configuration of the plugin.
function pluginManifest() external pure returns (PluginManifest memory);
/// @notice Describe the metadata of the plugin.
/// @dev This metadata MUST stay constant over time.
/// @return A metadata struct describing the plugin.
function pluginMetadata() external pure returns (PluginMetadata memory);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Structs.sol";
/// @dev The same storage will be used for v1.x.y of MSCAs.
library WalletStorageV1Lib {
// keccak256 hash of "circle.msca.v1.storage" subtracted by 1
bytes32 constant WALLET_STORAGE_SLOT = 0xc6a0cc20c824c4eecc4b0fbb7fb297d07492a7bd12c83d4fa4d27b4249f9bfc8;
struct Layout {
// installed plugin addresses for quick query
AddressDLL installedPlugins;
// installed plugin details such as manifest, dependencies
mapping(address => PluginDetail) pluginDetails;
// permissions for executeFromPlugin into another plugin
// callingPluginAddress => callingExecutionSelector => permittedOrNot
mapping(address => mapping(bytes4 => bool)) permittedPluginCalls;
// permissions for executeFromPluginExternal into external contract
// callingPluginAddress => targetContractAddress => permission
mapping(address => mapping(address => PermittedExternalCall)) permittedExternalCalls;
// list of ERC-165 interfaceIds to add to account to support introspection checks
// interfaceId => counter
mapping(bytes4 => uint256) supportedInterfaces;
// find plugin or native function execution detail by selector
mapping(bytes4 => ExecutionDetail) executionDetails;
/// indicates that the contract has been initialized
uint8 initialized;
/// indicates that the contract is in the process of being initialized
bool initializing;
// optional fields
address owner;
}
/**
* @dev Function to read structured wallet storage.
*/
function getLayout() internal pure returns (Layout storage walletStorage) {
assembly ("memory-safe") {
walletStorage.slot := WALLET_STORAGE_SLOT
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Errors.sol";
import "../common/Structs.sol";
/**
* @dev Enumerable & ordered doubly linked list built using mapping(address => address).
* Item is expected to be unique.
*/
library AddressDLLLib {
address constant SENTINEL_ADDRESS = address(0x0);
uint160 constant SENTINEL_ADDRESS_UINT = 0;
event AddressAdded(address indexed addr);
event AddressRemoved(address indexed addr);
error InvalidAddress();
modifier validAddress(address addr) {
if (uint160(addr) <= SENTINEL_ADDRESS_UINT) {
revert InvalidAddress();
}
_;
}
/**
* @dev Check if an item exists or not. O(1).
*/
function contains(AddressDLL storage dll, address item) internal view returns (bool) {
return getHead(dll) == item || dll.next[item] != address(0) || dll.prev[item] != address(0);
}
/**
* @dev Get the count of dll. O(1).
*/
function size(AddressDLL storage dll) internal view returns (uint256) {
return dll.count;
}
/**
* @dev Add an new item which did not exist before. Otherwise the function reverts. O(1).
*/
function append(AddressDLL storage dll, address item) internal validAddress(item) returns (bool) {
if (contains(dll, item)) {
revert ItemAlreadyExists();
}
address prev = getTail(dll);
address next = SENTINEL_ADDRESS;
// prev.next = item
dll.next[prev] = item;
// item.next = next
dll.next[item] = next;
// next.prev = item
dll.prev[next] = item;
// item.prev = prev
dll.prev[item] = prev;
dll.count++;
emit AddressAdded(item);
return true;
}
/**
* @dev Remove an already existing item. Otherwise the function reverts. O(1).
*/
function remove(AddressDLL storage dll, address item) internal validAddress(item) returns (bool) {
if (!contains(dll, item)) {
revert ItemDoesNotExist();
}
// item.prev.next = item.next
dll.next[dll.prev[item]] = dll.next[item];
// item.next.prev = item.prev
dll.prev[dll.next[item]] = dll.prev[item];
delete dll.next[item];
delete dll.prev[item];
dll.count--;
emit AddressRemoved(item);
return true;
}
/**
* @dev Return paginated addresses and next pointer address. O(n).
* @param start Starting address, inclusive, if start == address(0x0), this method searches from the head.
*/
function getPaginated(AddressDLL storage dll, address start, uint256 limit) internal view returns(address[] memory, address) {
if (limit == 0) {
revert InvalidLimit();
}
address[] memory results = new address[](limit);
address current = start;
if (start == address(0)) {
current = getHead(dll);
}
uint256 count = 0;
for (; count < limit && uint160(current) > SENTINEL_ADDRESS_UINT; ++count) {
results[count] = current;
current = dll.next[current];
}
assembly ("memory-safe") {
mstore(results, count)
}
return (results, current);
}
/**
* @dev Return all the data. O(n).
*/
function getAll(AddressDLL storage dll) internal view returns(address[] memory results) {
uint256 totalCount = size(dll);
results = new address[](totalCount);
uint256 accumulatedCount = 0;
address startAddr = address(0x0);
for (uint256 i = 0; i < totalCount; ++i) {
(address[] memory currentResults, address nextAddr) = getPaginated(dll, startAddr, 10);
for (uint256 j = 0; j < currentResults.length; ++j) {
results[accumulatedCount++] = currentResults[j];
}
if (nextAddr == SENTINEL_ADDRESS) {
break;
}
startAddr = nextAddr;
}
return results;
}
function getHead(AddressDLL storage dll) internal view returns (address) {
return dll.next[SENTINEL_ADDRESS];
}
function getTail(AddressDLL storage dll) internal view returns (address) {
return dll.prev[SENTINEL_ADDRESS];
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
import "../common/Constants.sol";
/**
* @dev Enumerable & ordered doubly linked list built using RepeatableBytes21DLL.
* Item is expected to be have a counter that tracks repeated number.
*/
library RepeatableFunctionReferenceDLLLib {
using FunctionReferenceLib for FunctionReference;
using FunctionReferenceLib for bytes21;
modifier validFunctionReference(FunctionReference memory fr) {
if (fr.pack() <= SENTINEL_BYTES21) {
revert InvalidFunctionReference();
}
_;
}
/**
* @dev Check the counter of an item. O(1).
* @return the counter
*/
function getRepeatedCount(RepeatableBytes21DLL storage dll, FunctionReference memory fr) internal view returns (uint256) {
bytes21 item = fr.pack();
if (item == SENTINEL_BYTES21) {
return 1;
}
return dll.counter[item];
}
/**
* @dev Get the total items of dll. O(1).
*/
function getTotalItems(RepeatableBytes21DLL storage dll) internal view returns (uint256) {
return dll.totalItems;
}
/**
* @dev Get the unique items of dll. O(1).
*/
function getUniqueItems(RepeatableBytes21DLL storage dll) internal view returns (uint256) {
return dll.uniqueItems;
}
/**
* @dev Add an new item. O(1).
*/
function append(RepeatableBytes21DLL storage dll, FunctionReference memory fr) internal validFunctionReference(fr) returns (uint256) {
bytes21 item = fr.pack();
uint256 currentCount = getRepeatedCount(dll, fr);
if (currentCount == 0) {
bytes21 prev = getTailWithoutUnpack(dll);
bytes21 next = SENTINEL_BYTES21;
// prev.next = item
dll.next[prev] = item;
// item.next = next
dll.next[item] = next;
// next.prev = item
dll.prev[next] = item;
// item.prev = prev
dll.prev[item] = prev;
dll.uniqueItems++;
}
dll.counter[item]++;
dll.totalItems++;
return dll.counter[item];
}
/**
* @dev Remove or decrease the counter of already existing item. Otherwise the function reverts. O(1).
*/
function remove(RepeatableBytes21DLL storage dll, FunctionReference memory fr) internal validFunctionReference(fr) returns (uint256) {
uint256 currentCount = getRepeatedCount(dll, fr);
if (currentCount == 0) {
revert ItemDoesNotExist();
}
bytes21 item = fr.pack();
if (currentCount == 1) {
// delete the item
// item.prev.next = item.next
dll.next[dll.prev[item]] = dll.next[item];
// item.next.prev = item.prev
dll.prev[dll.next[item]] = dll.prev[item];
delete dll.next[item];
delete dll.prev[item];
delete dll.counter[item];
dll.uniqueItems--;
} else {
dll.counter[item]--;
}
dll.totalItems--;
return dll.counter[item];
}
/**
* @dev Remove all copies of already existing items. O(1).
*/
function removeAllRepeated(RepeatableBytes21DLL storage dll, FunctionReference memory fr) internal validFunctionReference(fr) returns (bool) {
uint256 currentCount = getRepeatedCount(dll, fr);
if (currentCount == 0) {
revert ItemDoesNotExist();
}
bytes21 item = fr.pack();
// item.prev.next = item.next
dll.next[dll.prev[item]] = dll.next[item];
// item.next.prev = item.prev
dll.prev[dll.next[item]] = dll.prev[item];
delete dll.next[item];
delete dll.prev[item];
delete dll.counter[item];
dll.uniqueItems--;
dll.totalItems -= currentCount;
return true;
}
/**
* @dev Return paginated results and next pointer without counter information. O(n).
* In order to get counter information (which our current use case does not need), please call getRepeatedCount.
* @param startFR Starting item, inclusive, if start == bytes21(0), this method searches from the head.
*/
function getPaginated(RepeatableBytes21DLL storage dll, FunctionReference memory startFR, uint256 limit) internal view returns(FunctionReference[] memory, FunctionReference memory) {
if (limit == 0) {
revert InvalidLimit();
}
bytes21 start = startFR.pack();
FunctionReference[] memory results = new FunctionReference[](limit);
bytes21 current = start;
if (start == SENTINEL_BYTES21) {
current = getHeadWithoutUnpack(dll);
}
uint256 count = 0;
for (; count < limit && current > SENTINEL_BYTES21; ++count) {
results[count] = current.unpack();
current = dll.next[current];
}
assembly ("memory-safe") {
mstore(results, count)
}
return (results, current.unpack());
}
/**
* @dev Return all the unique items without counter information. O(n).
* In order to get counter information (which our current use case does not need), please call getRepeatedCount.
*/
function getAll(RepeatableBytes21DLL storage dll) internal view returns(FunctionReference[] memory results) {
uint256 totalUniqueCount = getUniqueItems(dll);
results = new FunctionReference[](totalUniqueCount);
uint256 accumulatedCount = 0;
FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
for (uint256 i = 0; i < totalUniqueCount; ++i) {
(FunctionReference[] memory currentResults, FunctionReference memory nextFR) = getPaginated(dll, startFR, 10);
for (uint256 j = 0; j < currentResults.length; ++j) {
results[accumulatedCount++] = currentResults[j];
}
if (nextFR.pack() == SENTINEL_BYTES21) {
break;
}
startFR = nextFR;
}
return results;
}
function getHead(RepeatableBytes21DLL storage dll) internal view returns (FunctionReference memory) {
return dll.next[SENTINEL_BYTES21].unpack();
}
function getTail(RepeatableBytes21DLL storage dll) internal view returns (FunctionReference memory) {
return dll.prev[SENTINEL_BYTES21].unpack();
}
function getHeadWithoutUnpack(RepeatableBytes21DLL storage dll) private view returns (bytes21) {
return dll.next[SENTINEL_BYTES21];
}
function getTailWithoutUnpack(RepeatableBytes21DLL storage dll) private view returns (bytes21) {
return dll.prev[SENTINEL_BYTES21];
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
import "../common/Constants.sol";
/**
* @dev Enumerable & ordered doubly linked list built using mapping(bytes21 => bytes21) for function reference.
* Item is expected to be unique.
*/
library FunctionReferenceDLLLib {
using FunctionReferenceLib for FunctionReference;
using FunctionReferenceLib for bytes21;
modifier validFunctionReference(FunctionReference memory fr) {
if (fr.pack() <= SENTINEL_BYTES21) {
revert InvalidFunctionReference();
}
_;
}
/**
* @dev Check if an item exists or not. O(1).
*/
function contains(Bytes21DLL storage dll, FunctionReference memory fr) internal view returns (bool) {
return contains(dll, fr.pack());
}
function contains(Bytes21DLL storage dll, bytes21 item) internal view returns (bool) {
return getHeadWithoutUnpack(dll) == item || dll.next[item] != SENTINEL_BYTES21 || dll.prev[item] != SENTINEL_BYTES21;
}
/**
* @dev Get the count of dll. O(1).
*/
function size(Bytes21DLL storage dll) internal view returns (uint256) {
return dll.count;
}
/**
* @dev Add an new item which did not exist before. Otherwise the function reverts. O(1).
*/
function append(Bytes21DLL storage dll, FunctionReference memory fr) internal validFunctionReference(fr) returns (bool) {
bytes21 item = fr.pack();
if (contains(dll, item)) {
revert ItemAlreadyExists();
}
bytes21 prev = getTailWithoutUnpack(dll);
bytes21 next = SENTINEL_BYTES21;
// prev.next = item
dll.next[prev] = item;
// item.next = next
dll.next[item] = next;
// next.prev = item
dll.prev[next] = item;
// item.prev = prev
dll.prev[item] = prev;
dll.count++;
return true;
}
/**
* @dev Remove an already existing item. Otherwise the function reverts. O(1).
*/
function remove(Bytes21DLL storage dll, FunctionReference memory fr) internal validFunctionReference(fr) returns (bool) {
bytes21 item = fr.pack();
if (!contains(dll, item)) {
revert ItemDoesNotExist();
}
// item.prev.next = item.next
dll.next[dll.prev[item]] = dll.next[item];
// item.next.prev = item.prev
dll.prev[dll.next[item]] = dll.prev[item];
delete dll.next[item];
delete dll.prev[item];
dll.count--;
return true;
}
/**
* @dev Return paginated bytes21s and next pointer bytes21. O(n).
* @param startFR Starting bytes21, inclusive, if start == bytes21(0), this method searches from the head.
*/
function getPaginated(Bytes21DLL storage dll, FunctionReference memory startFR, uint256 limit) internal view returns(FunctionReference[] memory, FunctionReference memory) {
if (limit == 0) {
revert InvalidLimit();
}
bytes21 start = startFR.pack();
FunctionReference[] memory results = new FunctionReference[](limit);
bytes21 current = start;
if (start == SENTINEL_BYTES21) {
current = getHeadWithoutUnpack(dll);
}
uint256 count = 0;
for (; count < limit && current > SENTINEL_BYTES21; ++count) {
results[count] = current.unpack();
current = dll.next[current];
}
assembly ("memory-safe") {
mstore(results, count)
}
return (results, current.unpack());
}
/**
* @dev Return all the data. O(n).
*/
function getAll(Bytes21DLL storage dll) internal view returns(FunctionReference[] memory results) {
uint256 totalCount = size(dll);
results = new FunctionReference[](totalCount);
uint256 accumulatedCount = 0;
FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
for (uint256 i = 0; i < totalCount; ++i) {
(FunctionReference[] memory currentResults, FunctionReference memory nextFR) = getPaginated(dll, startFR, 10);
for (uint256 j = 0; j < currentResults.length; ++j) {
results[accumulatedCount++] = currentResults[j];
}
if (nextFR.pack() == SENTINEL_BYTES21) {
break;
}
startFR = nextFR;
}
return results;
}
function getHead(Bytes21DLL storage dll) internal view returns (FunctionReference memory) {
return dll.next[SENTINEL_BYTES21].unpack();
}
function getTail(Bytes21DLL storage dll) internal view returns (FunctionReference memory) {
return dll.prev[SENTINEL_BYTES21].unpack();
}
function getHeadWithoutUnpack(Bytes21DLL storage dll) private view returns (bytes21) {
return dll.next[SENTINEL_BYTES21];
}
function getTailWithoutUnpack(Bytes21DLL storage dll) private view returns (bytes21) {
return dll.prev[SENTINEL_BYTES21];
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Structs.sol";
library FunctionReferenceLib {
function unpack(bytes21 frBytes) internal pure returns (FunctionReference memory) {
return FunctionReference(address(bytes20(frBytes)), uint8(bytes1(frBytes << 160)));
}
function pack(FunctionReference memory functionReference) internal pure returns (bytes21) {
return (bytes21(bytes20(functionReference.plugin)) | bytes21(uint168(functionReference.functionId)));
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {IPaymaster} from "@account-abstraction/contracts/interfaces/IPaymaster.sol";
import {IAggregator} from "@account-abstraction/contracts/interfaces/IAggregator.sol";
import {IAccountLoupe} from "../interfaces/IAccountLoupe.sol";
import {IPluginManager} from "../interfaces/IPluginManager.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {IStandardExecutor} from "../interfaces/IStandardExecutor.sol";
library SelectorRegistryLib {
bytes4 constant INITIALIZE_UPGRADABLE_MSCA = bytes4(keccak256("initializeUpgradableMSCA(address[],bytes32[],bytes[])"));
bytes4 constant INITIALIZE_SINGLE_OWNER_MSCA = bytes4(keccak256("initializeSingleOwnerMSCA(address)"));
bytes4 constant TRANSFER_NATIVE_OWNERSHIP = bytes4(keccak256("transferNativeOwnership(address)"));
bytes4 constant RENOUNCE_NATIVE_OWNERSHIP = bytes4(keccak256("renounceNativeOwnership()"));
bytes4 constant GET_NATIVE_OWNER = bytes4(keccak256("getNativeOwner()"));
bytes4 constant VALIDATE_USER_OP = bytes4(keccak256("validateUserOp(UserOperation,bytes32,uint256)"));
bytes4 constant GET_ENTRYPOINT = bytes4(keccak256("getEntryPoint()"));
bytes4 constant GET_NONCE = bytes4(keccak256("getNonce()"));
/**
* @dev Check if the selector is for native function.
* @param selector the function selector.
*/
function _isNativeFunctionSelector(bytes4 selector)
internal pure returns (bool) {
return
selector == IStandardExecutor.execute.selector || selector == IStandardExecutor.executeBatch.selector
|| selector == IPluginManager.installPlugin.selector || selector == IPluginManager.uninstallPlugin.selector
|| selector == UUPSUpgradeable.upgradeTo.selector || selector == UUPSUpgradeable.upgradeToAndCall.selector || selector == UUPSUpgradeable.proxiableUUID.selector
// check against IERC165 methods
|| selector == IERC165.supportsInterface.selector
// check against IPluginExecutor methods
|| selector == IPluginExecutor.executeFromPlugin.selector
|| selector == IPluginExecutor.executeFromPluginExternal.selector
// check against IAccountLoupe methods
|| selector == IAccountLoupe.getExecutionFunctionConfig.selector
|| selector == IAccountLoupe.getExecutionHooks.selector
|| selector == IAccountLoupe.getPreValidationHooks.selector
|| selector == IAccountLoupe.getInstalledPlugins.selector
|| selector == VALIDATE_USER_OP || selector == GET_ENTRYPOINT || selector == GET_NONCE
|| selector == INITIALIZE_UPGRADABLE_MSCA
|| selector == INITIALIZE_SINGLE_OWNER_MSCA
|| selector == TRANSFER_NATIVE_OWNERSHIP || selector == RENOUNCE_NATIVE_OWNERSHIP || selector == GET_NATIVE_OWNER;
}
function _isErc4337FunctionSelector(bytes4 selector) internal pure returns (bool) {
return selector == IAggregator.validateSignatures.selector
|| selector == IAggregator.validateUserOpSignature.selector
|| selector == IAggregator.aggregateSignatures.selector
|| selector == IPaymaster.validatePaymasterUserOp.selector || selector == IPaymaster.postOp.selector;
}
function _isIPluginFunctionSelector(bytes4 selector) internal pure returns (bool) {
return selector == IPlugin.onInstall.selector || selector == IPlugin.onUninstall.selector
|| selector == IPlugin.preUserOpValidationHook.selector
|| selector == IPlugin.userOpValidationFunction.selector
|| selector == IPlugin.preRuntimeValidationHook.selector
|| selector == IPlugin.runtimeValidationFunction.selector || selector == IPlugin.preExecutionHook.selector
|| selector == IPlugin.postExecutionHook.selector || selector == IPlugin.pluginManifest.selector
|| selector == IPlugin.pluginMetadata.selector;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
/**
* @dev Returned data from validateUserOp.
* validateUserOp returns a uint256, with is created by `_packedValidationData` and parsed by `_parseValidationData`
* @param validAfter - this UserOp is valid only after this timestamp.
* @param validaUntil - this UserOp is valid only up to this timestamp.
* @param authorizer - address(0) - the account validated the signature by itself.
* address(1) - the account failed to validate the signature.
* otherwise - this is an address of a signature aggregator that must be used to validate the signature.
*/
struct ValidationData {
uint48 validAfter;
uint48 validUntil;
address authorizer;
}
// Standard executor
struct Call {
// The target address for the account to call.
address target;
// The value to send with the call.
uint256 value;
// The calldata for the call.
bytes data;
}
struct FunctionReference {
address plugin;
uint8 functionId;
}
// Account loupe
// @notice Config for an execution function, given a selector
struct ExecutionFunctionConfig {
address plugin;
FunctionReference userOpValidationFunction;
FunctionReference runtimeValidationFunction;
}
/// @notice Pre and post hooks for a given selector
/// @dev It's possible for one of either `preExecHook` or `postExecHook` to be empty
struct ExecutionHooks {
FunctionReference preExecHook;
FunctionReference postExecHook;
}
// internal data structure
struct Bytes21DLL {
mapping (bytes21 => bytes21) next;
mapping (bytes21 => bytes21) prev;
uint256 count;
}
struct RepeatableBytes21DLL {
mapping (bytes21 => bytes21) next;
mapping (bytes21 => bytes21) prev;
mapping (bytes21 => uint256) counter;
// unique items
uint256 uniqueItems;
// total items with repeatable ones
uint256 totalItems;
}
struct AddressDLL {
mapping (address => address) next;
mapping (address => address) prev;
uint256 count;
}
// Represents a set of pre and post hooks. Used to store execution hooks.
struct HookGroup {
RepeatableBytes21DLL preHooks;
// key = preExecHook.pack()
mapping(bytes21 => RepeatableBytes21DLL) preToPostHooks;
RepeatableBytes21DLL postOnlyHooks;
}
// plugin's permission to call external (to the account and its plugins) contracts and addresses
// through `executeFromPluginExternal`
struct PermittedExternalCall {
bool addressPermitted;
// either anySelector or selectors permitted
bool anySelector;
mapping(bytes4 => bool) selectors;
}
struct PostExecHookToRun {
bytes preExecHookReturnData;
FunctionReference postExecHook;
}
// plugin detail stored in wallet storage
struct PluginDetail {
// permitted to call any external contracts and selectors
bool anyExternalAddressPermitted;
// boolean to indicate if the plugin can spend native tokens, if any of the execution function can spend
// native tokens, a plugin is considered to be able to spend native tokens of the accounts
bool canSpendNativeToken;
// tracks the count this plugin has been used as a dependency function
uint256 dependentCounter;
bytes32 manifestHash;
Bytes21DLL dependencies;
}
// execution detail associated with selector
struct ExecutionDetail {
address plugin; // plugin address that implements the execution function, for native functions, the value should be address(0)
FunctionReference userOpValidationFunction;
RepeatableBytes21DLL preUserOpValidationHooks;
FunctionReference runtimeValidationFunction;
RepeatableBytes21DLL preRuntimeValidationHooks;
HookGroup executionHooks;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
// Plugin Manifest
enum ManifestAssociatedFunctionType {
// Function is not defined.
NONE,
// Function belongs to this plugin.
SELF,
// Function belongs to an external plugin provided as a dependency during plugin installation.
DEPENDENCY,
// Resolves to a magic value to always bypass runtime validation for a given function.
// This is only assignable on runtime validation functions. If it were to be used on a user op validation function,
// it would risk burning gas from the account. When used as a hook in any hook location, it is equivalent to not
// setting a hook and is therefore disallowed.
RUNTIME_VALIDATION_ALWAYS_ALLOW,
// Resolves to a magic value to always fail in a hook for a given function.
// This is only assignable to pre hooks (pre validation and pre execution). It should not be used on
// validation functions themselves, because this is equivalent to leaving the validation functions unset.
// It should not be used in post-exec hooks, because if it is known to always revert, that should happen
// as early as possible to save gas.
PRE_HOOK_ALWAYS_DENY
}
/// @dev For functions of type `ManifestAssociatedFunctionType.DEPENDENCY`, the MSCA MUST find the plugin address
/// of the function at `dependencies[dependencyIndex]` during the call to `installPlugin(config)`.
struct ManifestFunction {
ManifestAssociatedFunctionType functionType;
uint8 functionId;
uint256 dependencyIndex;
}
struct ManifestAssociatedFunction {
bytes4 executionSelector;
ManifestFunction associatedFunction;
}
struct ManifestExecutionHook {
bytes4 selector;
ManifestFunction preExecHook;
ManifestFunction postExecHook;
}
struct ManifestExternalCallPermission {
address externalAddress;
bool permitAnySelector;
bytes4[] selectors;
}
struct SelectorPermission {
bytes4 functionSelector;
string permissionDescription;
}
/// @dev A struct holding fields to describe the plugin in a purely view context. Intended for front end clients.
struct PluginMetadata {
// A human-readable name of the plugin.
string name;
// The version of the plugin, following the semantic versioning scheme.
string version;
// The author field SHOULD be a username representing the identity of the user or organization
// that created this plugin.
string author;
// String descriptions of the relative sensitivity of specific functions. The selectors MUST be selectors for
// functions implemented by this plugin.
SelectorPermission[] permissionDescriptors;
}
/// @dev A struct describing how the plugin should be installed on a modular account.
struct PluginManifest {
// List of ERC-165 interface IDs to add to account to support introspection checks. This MUST NOT include
// IPlugin's interface ID.
bytes4[] interfaceIds;
// If this plugin depends on other plugins' validation functions, the interface IDs of those plugins MUST be
// provided here, with its position in the array matching the `dependencyIndex` members of `ManifestFunction`
bytes4[] dependencyInterfaceIds;
// Execution functions defined in this plugin to be installed on the MSCA.
bytes4[] executionFunctions;
// Plugin execution functions already installed on the MSCA that this plugin will be able to call.
bytes4[] permittedExecutionSelectors;
// Boolean to indicate whether the plugin can call any external address.
bool permitAnyExternalAddress;
// Boolean to indicate whether the plugin needs access to spend native tokens of the account. If false, the
// plugin MUST still be able to spend up to the balance that it sends to the account in the same call.
bool canSpendNativeToken;
// More granular control
ManifestExternalCallPermission[] permittedExternalCalls;
ManifestAssociatedFunction[] userOpValidationFunctions;
ManifestAssociatedFunction[] runtimeValidationFunctions;
ManifestAssociatedFunction[] preUserOpValidationHooks;
ManifestAssociatedFunction[] preRuntimeValidationHooks;
// for executionFunctions
ManifestExecutionHook[] executionHooks;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
// ERC4337 constants
// return value in case of signature failure, with no time-range.
// equivalent to _packValidationData(true,0,0);
uint256 constant SIG_VALIDATION_FAILED = 1;
uint256 constant SIG_VALIDATION_SUCCEEDED = 0;
// sentinel values
// any values less than or equal to this will not be allowed in storage
bytes21 constant SENTINEL_BYTES21 = bytes21(0);
// empty or unset function reference
// we don't store the empty function reference
bytes21 constant EMPTY_FUNCTION_REFERENCE = bytes21(0);
// magic value for runtime validation functions that always allow access
bytes21 constant RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE = bytes21(uint168(1));
// magic value for hooks that should always revert
bytes21 constant PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE = bytes21(uint168(2));
// wallet constants
string constant WALLET_AUTHOR = "Circle Internet Financial";
string constant WALLET_VERSION_1 = "1.0.0";
// plugin constants
string constant PLUGIN_AUTHOR = "Circle Internet Financial";
string constant PLUGIN_VERSION_1 = "1.0.0";
// bytes4(keccak256("isValidSignature(bytes32,bytes)")
bytes4 constant EIP1271_VALID_SIGNATURE = 0x1626ba7e;
bytes4 constant EIP1271_INVALID_SIGNATURE = 0xffffffff;
// reference: https://github.com/ethereum/EIPs/blob/30fec793f3cb6769cb44d2d0daa5238451f67c48/EIPS/eip-712.md#specification
bytes2 constant EIP712_PREFIX = "\x19\x01";
// keccak256('')
bytes32 constant EMPTY_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.0;
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.sol";
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*
* _Available since v4.1._
*/
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
/**
* @dev Check that the execution is not being performed through a delegate call. This allows a function to be
* callable on the implementing contract but not through proxies.
*/
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
/**
* @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
* implementation. It is used to validate the implementation's compatibility when performing an upgrade.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
*/
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeTo(address newImplementation) public virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeTo} and {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal override onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC1271 standard signature validation method for
* contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
*
* _Available since v4.1._
*/
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 v4.9.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
import "../Strings.sol";
/**
* @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,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode 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 {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]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
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);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode 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 {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
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]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
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.
*
* _Available since v4.2._
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
// 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);
}
// 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);
}
return (signer, RecoverError.NoError);
}
/**
* @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) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
/**
* @dev Returns an Ethereum Signed Data with intended validator, created from a
* `validator` and `data` according to the version 0 of EIP-191.
*
* See {recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @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
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155Receiver is IERC165 {
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/SignatureChecker.sol)
pragma solidity ^0.8.0;
import "./ECDSA.sol";
import "../../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 Gnosis Safe.
*
* _Available since v4.1._
*/
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.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
);
return (success &&
result.length >= 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {IAccountLoupe} from "../interfaces/IAccountLoupe.sol";
import {IPluginManager} from "../interfaces/IPluginManager.sol";
import {IStandardExecutor} from "../interfaces/IStandardExecutor.sol";
import {PluginManager} from "../managers/PluginManager.sol";
import {StandardExecutor} from "../managers/StandardExecutor.sol";
import {PluginExecutor} from "../managers/PluginExecutor.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {ExecutionHookLib} from "../libs/ExecutionHookLib.sol";
import {WalletStorageInitializable} from "./WalletStorageInitializable.sol";
import {RepeatableFunctionReferenceDLLLib} from "../libs/RepeatableFunctionReferenceDLLLib.sol";
import {FunctionReferenceLib} from "../libs/FunctionReferenceLib.sol";
import {AddressDLLLib} from "../libs/AddressDLLLib.sol";
import {ValidationDataLib} from "../libs/ValidationDataLib.sol";
import {SelectorRegistryLib} from "../libs/SelectorRegistryLib.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
import "../common/Constants.sol";
/**
* @dev Base MSCA implementation with **authentication**.
* This contract provides the basic logic for implementing the MSCA interfaces;
* specific account implementation should inherit this contract.
*/
abstract contract BaseMSCA is WalletStorageInitializable, IPluginManager, IAccountLoupe, IStandardExecutor, IPluginExecutor, IERC165 {
using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
using FunctionReferenceLib for bytes21;
using FunctionReferenceLib for FunctionReference;
using ExecutionHookLib for HookGroup;
using ExecutionHookLib for PostExecHookToRun[];
using ExecutionUtils for address;
using PluginExecutor for bytes;
using StandardExecutor for address;
using StandardExecutor for Call[];
using AddressDLLLib for AddressDLL;
using ValidationDataLib for ValidationData;
using SelectorRegistryLib for bytes4;
string public constant author = WALLET_AUTHOR;
string public constant version = WALLET_VERSION_1;
// 4337 related immutable storage
IEntryPoint public immutable entryPoint;
PluginManager public immutable pluginManager;
error NotNativeFunctionSelector(bytes4 selector);
error InvalidHookFunctionId(uint8 functionId);
error PreRuntimeValidationHookFailed(address plugin, uint8 functionId, bytes revertReason);
error RuntimeValidationFailed(address plugin, uint8 functionId, bytes revertReason);
/**
* @dev Wraps execution of a native function (as opposed to a function added by plugins) with runtime validations (not from EP)
* and hooks. Used by execute, executeBatch, installPlugin, uninstallPlugin, upgradeTo and upgradeToAndCall.
* If the call is from entry point, then validateUserOp will run.
* https://eips.ethereum.org/assets/eip-6900/Modular_Account_Call_Flow.svg
*/
modifier validateNativeFunction() {
PostExecHookToRun[] memory postExecHooks = _processPreExecHooks();
_;
postExecHooks._processPostExecHooks();
}
/**
* @dev This function allows entry point or SA itself to execute certain actions.
* If the caller is not authorized, the function will revert with an error message.
*/
modifier onlyFromEntryPointOrSelf() {
_checkAccessRuleFromEPOrAcctItself();
_;
}
constructor(IEntryPoint _newEntryPoint, PluginManager _newPluginManager) {
entryPoint = _newEntryPoint;
pluginManager = _newPluginManager;
// lock the implementation contract so it can only be called from proxies
_disableWalletStorageInitializers();
}
receive() external payable {}
/// @notice Manage fallback calls made to the plugins.
/// @dev Route calls to execution functions based on incoming msg.sig
/// If there's no plugin associated with this function selector, revert
fallback(bytes calldata) external payable returns (bytes memory result) {
// run runtime validation before we load the executionDetail because validation may update account state
if (msg.sender != address(entryPoint)) {
// entryPoint should go through validateUserOp flow which calls userOpValidationFunction
_processPreRuntimeHooksAndValidation(msg.sig);
}
// load the executionDetail before we run the preExecHooks because they may modify the plugins
ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[msg.sig];
address executionFunctionPlugin = executionDetail.plugin;
// valid plugin address should not be 0
if (executionFunctionPlugin == address(0)) {
revert InvalidExecutionFunction(msg.sig);
}
PostExecHookToRun[] memory postExecHooks = executionDetail.executionHooks._processPreExecHooks(msg.data);
result = ExecutionUtils.callWithReturnDataOrRevert(executionFunctionPlugin, msg.value, msg.data);
postExecHooks._processPostExecHooks();
return result;
}
/**
* @dev Return the entryPoint used by this account.
* subclass should return the current entryPoint used by this account.
*/
function getEntryPoint() external view returns (IEntryPoint) {
return entryPoint;
}
/**
* @dev Validate user's signature and nonce.
* subclass doesn't need to override this method. Instead, it should override the specific internal validation methods.
*/
function validateUserOp(UserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds)
external
virtual
returns (uint256 validationData) {
if (msg.sender != address(entryPoint)) {
revert UnauthorizedCaller();
}
validationData = _authenticateAndAuthorizeUserOp(userOp, userOpHash);
if (missingAccountFunds != 0) {
(bool success,) = payable(msg.sender).call{value : missingAccountFunds, gas : type(uint256).max}("");
(success);
// ignore failure (its EntryPoint's job to verify, not account.)
}
}
/// @notice ERC165 introspection https://eips.ethereum.org/EIPS/eip-165
/// @dev returns true for `IERC165.interfaceId` and false for `0xFFFFFFFF`
/// @param interfaceId interface id to check against
/// @return bool support for specific interface
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
if (interfaceId == 0xffffffff) {
return false;
}
if (interfaceId == type(IERC165).interfaceId) {
return true;
}
return WalletStorageV1Lib.getLayout().supportedInterfaces[interfaceId] > 0;
}
/**
* @dev Return the account nonce.
* This method returns the next sequential nonce.
* For a nonce of a specific key, use `entrypoint.getNonce(account, key)`
*/
function getNonce() public view virtual returns (uint256) {
return entryPoint.getNonce(address(this), 0);
}
function installPlugin(
address plugin,
bytes32 manifestHash,
bytes memory pluginInstallData,
FunctionReference[] memory dependencies)
external
override
validateNativeFunction {
bytes memory data = abi.encodeCall(PluginManager.install, (plugin, manifestHash, pluginInstallData, dependencies, address(this)));
address(pluginManager).delegateCall(data);
emit PluginInstalled(plugin, manifestHash, dependencies);
}
function uninstallPlugin(
address plugin,
bytes memory config,
bytes memory pluginUninstallData)
external
override
validateNativeFunction {
bytes memory data = abi.encodeCall(PluginManager.uninstall, (plugin, config, pluginUninstallData));
address(pluginManager).delegateCall(data);
emit PluginUninstalled(plugin, true);
}
function execute(address target, uint256 value, bytes calldata data)
external
payable
override
validateNativeFunction
returns (bytes memory returnData) {
return target.execute(value, data);
}
function executeBatch(Call[] calldata calls)
external
payable
override
validateNativeFunction
returns (bytes[] memory returnData) {
return calls.executeBatch();
}
function executeFromPlugin(bytes calldata data) external override payable returns (bytes memory) {
return data.executeFromPlugin();
}
function executeFromPluginExternal(address target, uint256 value, bytes calldata data) external override payable returns (bytes memory) {
return data.executeFromPluginToExternal(target, value);
}
/// @notice Gets the validation functions and plugin address for a selector
/// @dev If the selector is a native function, the plugin address will be the address of the account
/// @param selector The selector to get the configuration for
/// @return executionFunctionConfig The configuration for this selector
function getExecutionFunctionConfig(bytes4 selector) external view returns (ExecutionFunctionConfig memory executionFunctionConfig) {
WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
if (selector._isNativeFunctionSelector()) {
executionFunctionConfig.plugin = address(this);
} else {
executionFunctionConfig.plugin = walletStorage.executionDetails[selector].plugin;
}
executionFunctionConfig.userOpValidationFunction = walletStorage.executionDetails[selector].userOpValidationFunction;
executionFunctionConfig.runtimeValidationFunction = walletStorage.executionDetails[selector].runtimeValidationFunction;
return executionFunctionConfig;
}
/// @notice Gets the pre and post execution hooks for a selector
/// @param selector The selector to get the hooks for
/// @return executionHooks The pre and post execution hooks for this selector
function getExecutionHooks(bytes4 selector) external view returns (ExecutionHooks[] memory executionHooks) {
return WalletStorageV1Lib.getLayout().executionDetails[selector].executionHooks._getExecutionHooks();
}
/// @notice Gets the pre user op and runtime validation hooks associated with a selector
/// @param selector The selector to get the hooks for
/// @return preUserOpValidationHooks The pre user op validation hooks for this selector
/// @return preRuntimeValidationHooks The pre runtime validation hooks for this selector
function getPreValidationHooks(bytes4 selector) external view returns (FunctionReference[] memory preUserOpValidationHooks, FunctionReference[] memory preRuntimeValidationHooks) {
preUserOpValidationHooks = WalletStorageV1Lib.getLayout().executionDetails[selector].preUserOpValidationHooks.getAll();
preRuntimeValidationHooks = WalletStorageV1Lib.getLayout().executionDetails[selector].preRuntimeValidationHooks.getAll();
return (preUserOpValidationHooks, preRuntimeValidationHooks);
}
/// @notice Gets an array of all installed plugins
/// @return pluginAddresses The addresses of all installed plugins
function getInstalledPlugins() external view returns (address[] memory pluginAddresses) {
return WalletStorageV1Lib.getLayout().installedPlugins.getAll();
}
/**
* Check current account deposit in the entryPoint.
*/
function getDeposit() public view returns (uint256) {
return entryPoint.balanceOf(address(this));
}
/**
* Deposit more funds for this account in the entryPoint.
*/
function addDeposit() public payable {
entryPoint.depositTo{value : msg.value}(address(this));
}
/**
* Withdraw value from the account's deposit.
* @param withdrawAddress target to send to
* @param amount to withdraw
*/
function withdrawDepositTo(address payable withdrawAddress, uint256 amount) public onlyFromEntryPointOrSelf {
entryPoint.withdrawTo(withdrawAddress, amount);
}
/**
* @dev Authenticate and authorize this userOp. OnlyFromEntryPoint is applied in the caller.
* @param userOp validate the userOp.signature field
* @param userOpHash convenient field: the hash of the request, to check the signature against
* (also hashes the entrypoint and chain id)
* @return validationData signature and time-range of this operation
* <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 the 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 due to the storage rule.
*/
function _authenticateAndAuthorizeUserOp(UserOperation calldata userOp, bytes32 userOpHash)
internal virtual returns (uint256 validationData) {
// onlyFromEntryPoint is applied in the caller
// if there is no function defined for the selector, or if userOp.callData.length < 4, then execution MUST revert
if (userOp.callData.length < 4) {
revert NotFoundSelector();
}
bytes4 selector = bytes4(userOp.callData[0 : 4]);
if (selector == bytes4(0)) {
revert NotFoundSelector();
}
ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
FunctionReference memory validationFunction = executionDetail.userOpValidationFunction;
bytes21 packedValidationFunction = validationFunction.pack();
if (packedValidationFunction == EMPTY_FUNCTION_REFERENCE
|| packedValidationFunction == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(validationFunction.functionId);
}
// pre hook
ValidationData memory unpackedValidationData = _processPreUserOpValidationHooks(executionDetail, userOp, userOpHash);
IPlugin userOpValidatorPlugin = IPlugin(validationFunction.plugin);
// execute the validation function with the user operation and its hash as parameters using the call opcode
uint256 currentValidationData = userOpValidatorPlugin.userOpValidationFunction(executionDetail.userOpValidationFunction.functionId, userOp, userOpHash);
// intercept with validation function call
unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
// only revert on unexpected values
revert InvalidAuthorizer();
}
validationData = unpackedValidationData._packValidationData();
}
/**
* @dev Default validation logic is from installed plugins. However, you can override this validation logic in MSCA
* implementations. For instance, semi MSCA such as single owner semi MSCA may want to honor the validation
* from native owner.
*/
function _processPreRuntimeHooksAndValidation(bytes4 selector)
internal virtual {
FunctionReference memory validationFunction = WalletStorageV1Lib.getLayout().executionDetails[selector].runtimeValidationFunction;
bytes21 packedValidationFunction = validationFunction.pack();
if (packedValidationFunction == EMPTY_FUNCTION_REFERENCE
|| packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(validationFunction.functionId);
}
RepeatableBytes21DLL storage preRuntimeValidationHooksDLL = WalletStorageV1Lib.getLayout().executionDetails[selector].preRuntimeValidationHooks;
uint256 totalUniqueHookCount = preRuntimeValidationHooksDLL.getUniqueItems();
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
FunctionReference[] memory preRuntimeValidationHooks;
FunctionReference memory nextHook;
for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
(preRuntimeValidationHooks, nextHook) = preRuntimeValidationHooksDLL.getPaginated(startHook, 10);
for (uint256 j = 0; j < preRuntimeValidationHooks.length; ++j) {
// revert on EMPTY_FUNCTION_REFERENCE, RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE, PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
// if any revert, the outer call MUST revert
bytes21 packedPreRuntimeValidationHook = preRuntimeValidationHooks[j].pack();
if (packedPreRuntimeValidationHook == EMPTY_FUNCTION_REFERENCE
|| packedPreRuntimeValidationHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedPreRuntimeValidationHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(preRuntimeValidationHooks[j].functionId);
}
IPlugin preRuntimeValidationHookPlugin = IPlugin(preRuntimeValidationHooks[j].plugin);
try preRuntimeValidationHookPlugin.preRuntimeValidationHook(preRuntimeValidationHooks[j].functionId, msg.sender, msg.value, msg.data) {}
catch (bytes memory revertReason) {
revert PreRuntimeValidationHookFailed(preRuntimeValidationHooks[j].plugin, preRuntimeValidationHooks[j].functionId, revertReason);
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
// call runtimeValidationFunction if it's not always allowed
if (packedValidationFunction != RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE) {
try IPlugin(validationFunction.plugin).runtimeValidationFunction(validationFunction.functionId, msg.sender, msg.value, msg.data) {}
catch (bytes memory revertReason) {
revert RuntimeValidationFailed(validationFunction.plugin, validationFunction.functionId, revertReason);
}
}
}
/// @dev Also runs runtime hooks and validation if msg.sender is not from entry point.
function _processPreExecHooks() internal returns (PostExecHookToRun[] memory) {
if (!msg.sig._isNativeFunctionSelector()) {
revert NotNativeFunctionSelector(msg.sig);
}
if (msg.sender != address(entryPoint)) {
// entryPoint should go through validateUserOp flow which calls userOpValidationFunction
_processPreRuntimeHooksAndValidation(msg.sig);
}
return WalletStorageV1Lib.getLayout().executionDetails[msg.sig].executionHooks._processPreExecHooks(msg.data);
}
function _processPreUserOpValidationHooks(
ExecutionDetail storage executionDetail,
UserOperation calldata userOp,
bytes32 userOpHash) internal virtual returns (ValidationData memory unpackedValidationData) {
unpackedValidationData = ValidationData(0, 0xFFFFFFFFFFFF, address(0));
// if the function selector has associated pre user operation validation hooks, then those hooks MUST be run sequentially
uint256 totalUniqueHookCount = executionDetail.preUserOpValidationHooks.getUniqueItems();
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
FunctionReference[] memory preUserOpValidatorHooks;
FunctionReference memory nextHook;
uint256 currentValidationData;
for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
(preUserOpValidatorHooks, nextHook) = executionDetail.preUserOpValidationHooks.getPaginated(startHook, 10);
for (uint256 j = 0; j < preUserOpValidatorHooks.length; ++j) {
bytes21 packedUserOpValidatorHook = preUserOpValidatorHooks[j].pack();
// if any revert, the outer call MUST revert
if (packedUserOpValidatorHook == EMPTY_FUNCTION_REFERENCE
|| packedUserOpValidatorHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedUserOpValidatorHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidHookFunctionId(preUserOpValidatorHooks[j].functionId);
}
IPlugin preUserOpValidationHookPlugin = IPlugin(preUserOpValidatorHooks[j].plugin);
currentValidationData = preUserOpValidationHookPlugin.preUserOpValidationHook(preUserOpValidatorHooks[j].functionId, userOp, userOpHash);
unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
// if any return an authorizer value other than 0 or 1, execution MUST revert
if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
revert InvalidAuthorizer();
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
return unpackedValidationData;
}
function _checkAccessRuleFromEPOrAcctItself() internal view {
if (msg.sender != address(entryPoint) && msg.sender != address(this)) {
revert UnauthorizedCaller();
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {IERC777Recipient} from "@openzeppelin/contracts/interfaces/IERC777Recipient.sol";
/**
* @dev Token callback handler. Allowing account receiving these tokens.
* @notice The user will have to register itself in the ERC1820 global registry
* in order to fully support ERC777 token operations upon the installation of this plugin.
*/
contract DefaultCallbackHandler is IERC721Receiver, IERC1155Receiver, IERC777Recipient {
function supportsInterface(bytes4 interfaceId) external view virtual override returns (bool) {
return interfaceId == type(IERC721Receiver).interfaceId ||
interfaceId == type(IERC1155Receiver).interfaceId ||
interfaceId == type(IERC165).interfaceId;
}
function onERC1155Received(
address,
address,
uint256,
uint256,
bytes calldata
) external pure override returns (bytes4) {
return IERC1155Receiver.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address,
uint256[] calldata,
uint256[] calldata,
bytes calldata
) external pure override returns (bytes4) {
return IERC1155Receiver.onERC1155BatchReceived.selector;
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure override returns (bytes4) {
return IERC721Receiver.onERC721Received.selector;
}
// ERC777
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external pure override {}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
// solhint-disable no-inline-assembly
/**
* Utility functions helpful when making different kinds of contract calls in Solidity.
* For inline assembly, please refer to https://docs.soliditylang.org/en/latest/assembly.html
* For opcodes, please refer to https://ethereum.org/en/developers/docs/evm/opcodes/ and https://www.evm.codes/
*/
library ExecutionUtils {
function call(address to,
uint256 value,
bytes memory data
) internal returns (bool success, bytes memory returnData) {
assembly {
success := call(gas(), to, value, add(data, 0x20), mload(data), 0, 0)
let len := returndatasize()
let ptr := mload(0x40)
mstore(0x40, add(ptr, add(len, 0x20)))
mstore(ptr, len)
returndatacopy(add(ptr, 0x20), 0, len)
returnData := ptr
}
}
function revertWithData(bytes memory returnData) internal pure {
assembly {
revert(add(returnData, 32), mload(returnData))
}
}
function callAndRevert(address to,
uint256 value,
bytes memory data) internal {
(bool success, bytes memory returnData) = call(to, value, data);
if (!success) {
revertWithData(returnData);
}
}
function callWithReturnDataOrRevert(address to,
uint256 value,
bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returnData) = call(to, value, data);
if (!success) {
// bubble up revert reason
revertWithData(returnData);
}
return returnData;
}
/// @dev Return data or revert.
function delegateCall(
address to,
bytes memory data
) internal returns (bytes memory) {
(bool success, bytes memory returnData) = to.delegatecall(data);
if (!success) {
// bubble up revert reason
revertWithData(returnData);
}
return returnData;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {ValidationData} from "../common/Structs.sol";
library ValidationDataLib {
error WrongTimeBounds();
/**
* @dev Intercept the time bounds [validAfter, validUntil], as well as signature validation result (favoring the failure).
*/
function _intersectValidationData(ValidationData memory a, uint256 uintb)
internal pure returns (ValidationData memory validationData) {
ValidationData memory b = _unpackValidationData(uintb);
if (a.validAfter > a.validUntil) {
revert WrongTimeBounds();
}
if (b.validAfter > b.validUntil) {
revert WrongTimeBounds();
}
// 0 is successful validation
if (a.authorizer == address(0)) {
validationData.authorizer = b.authorizer;
} else {
validationData.authorizer = a.authorizer;
}
if (a.validAfter > b.validAfter) {
validationData.validAfter = a.validAfter;
} else {
validationData.validAfter = b.validAfter;
}
if (a.validUntil < b.validUntil) {
validationData.validUntil = a.validUntil;
} else {
validationData.validUntil = b.validUntil;
}
// make sure the caller (e.g. entryPoint) reverts
if (validationData.validAfter > validationData.validUntil) {
validationData.authorizer = address(1);
}
return validationData;
}
/**
* @dev Unpack into the deserialized packed format from validAfter | validUntil | authorizer.
*/
function _unpackValidationData(uint256 validationDataInt) internal pure returns (ValidationData memory validationData) {
address authorizer = address(uint160(validationDataInt));
uint48 validUntil = uint48(validationDataInt >> 160);
if (validUntil == 0) {
validUntil = type(uint48).max;
}
uint48 validAfter = uint48(validationDataInt >> (48 + 160));
return ValidationData(validAfter, validUntil, authorizer);
}
function _packValidationData(ValidationData memory data) internal pure returns (uint256) {
return uint160(data.authorizer) | (uint256(data.validUntil) << 160) | (uint256(data.validAfter) << (160 + 48));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeacon {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
*
* _Available since v4.8.3._
*/
interface IERC1967 {
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822Proxiable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
* _Available since v4.9 for `string`, `bytes`._
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
/* solhint-disable no-inline-assembly */
/**
* returned data from validateUserOp.
* validateUserOp returns a uint256, with is created by `_packedValidationData` and parsed by `_parseValidationData`
* @param aggregator - address(0) - the account validated the signature by itself.
* address(1) - the account failed to validate the signature.
* otherwise - this is an address of a signature aggregator that must be used to validate the signature.
* @param validAfter - this UserOp is valid only after this timestamp.
* @param validaUntil - this UserOp is valid only up to this timestamp.
*/
struct ValidationData {
address aggregator;
uint48 validAfter;
uint48 validUntil;
}
//extract sigFailed, validAfter, validUntil.
// also convert zero validUntil to type(uint48).max
function _parseValidationData(uint validationData) pure returns (ValidationData memory data) {
address aggregator = address(uint160(validationData));
uint48 validUntil = uint48(validationData >> 160);
if (validUntil == 0) {
validUntil = type(uint48).max;
}
uint48 validAfter = uint48(validationData >> (48 + 160));
return ValidationData(aggregator, validAfter, validUntil);
}
// intersect account and paymaster ranges.
function _intersectTimeRange(uint256 validationData, uint256 paymasterValidationData) pure returns (ValidationData memory) {
ValidationData memory accountValidationData = _parseValidationData(validationData);
ValidationData memory pmValidationData = _parseValidationData(paymasterValidationData);
address aggregator = accountValidationData.aggregator;
if (aggregator == address(0)) {
aggregator = pmValidationData.aggregator;
}
uint48 validAfter = accountValidationData.validAfter;
uint48 validUntil = accountValidationData.validUntil;
uint48 pmValidAfter = pmValidationData.validAfter;
uint48 pmValidUntil = pmValidationData.validUntil;
if (validAfter < pmValidAfter) validAfter = pmValidAfter;
if (validUntil > pmValidUntil) validUntil = pmValidUntil;
return ValidationData(aggregator, validAfter, validUntil);
}
/**
* helper to pack the return value for validateUserOp
* @param data - the ValidationData to pack
*/
function _packValidationData(ValidationData memory data) pure returns (uint256) {
return uint160(data.aggregator) | (uint256(data.validUntil) << 160) | (uint256(data.validAfter) << (160 + 48));
}
/**
* helper to pack the return value for validateUserOp, when not using an aggregator
* @param sigFailed - true for signature failure, false for success
* @param validUntil last timestamp this UserOperation is valid (or zero for infinite)
* @param validAfter first timestamp this UserOperation is valid
*/
function _packValidationData(bool sigFailed, uint48 validUntil, uint48 validAfter) pure returns (uint256) {
return (sigFailed ? 1 : 0) | (uint256(validUntil) << 160) | (uint256(validAfter) << (160 + 48));
}
/**
* keccak function over calldata.
* @dev copy calldata into memory, do keccak and drop allocated memory. Strangely, this is more efficient than letting solidity do it.
*/
function calldataKeccak(bytes calldata data) pure returns (bytes32 ret) {
assembly {
let mem := mload(0x40)
let len := data.length
calldatacopy(mem, data.offset, len)
ret := keccak256(mem, len)
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;
import "./UserOperation.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 {
opSucceeded, // user op succeeded
opReverted, // user op reverted. still has to pay for gas.
postOpReverted //user op succeeded, but caused postOp to revert. Now it's a 2nd call, after user's op was deliberately reverted.
}
/**
* 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,
* 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
* Note that the validation code cannot use block.timestamp (or block.number) directly.
*/
function validatePaymasterUserOp(UserOperation 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. still has to pay for gas.
* postOpReverted - user op succeeded, but caused postOp (in mode=opSucceeded) to revert.
* Now this is the 2nd call, after user's op was deliberately reverted.
* @param context - the context value returned by validatePaymasterUserOp
* @param actualGasCost - actual gas used so far (without this postOp call).
*/
function postOp(PostOpMode mode, bytes calldata context, uint256 actualGasCost) external;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Structs.sol";
/**
* @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs may implement this interface to support visibility in plugin configurations on-chain.
*/
interface IAccountLoupe {
/// @notice Get the validation functions and plugin address for a selector.
/// @dev If the selector is a native function, the plugin address will be the address of the account.
/// @param selector The selector to get the configuration for.
/// @return The configuration for this selector.
function getExecutionFunctionConfig(bytes4 selector) external view returns (ExecutionFunctionConfig memory);
/// @notice Get the pre and post execution hooks for a selector.
/// @param selector The selector to get the hooks for.
/// @return The pre and post execution hooks for this selector.
function getExecutionHooks(bytes4 selector) external view returns (ExecutionHooks[] memory);
/// @notice Get the pre user op and runtime validation hooks associated with a selector.
/// @param selector The selector to get the hooks for.
/// @return preUserOpValidationHooks The pre user op validation hooks for this selector.
/// @return preRuntimeValidationHooks The pre runtime validation hooks for this selector.
function getPreValidationHooks(bytes4 selector) external view returns (FunctionReference[] memory, FunctionReference[] memory);
/// @notice Get an array of all installed plugins.
/// @return pluginAddresses The addresses of all installed plugins.
function getInstalledPlugins() external view returns (address[] memory);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Structs.sol";
/**
* @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support installing and uninstalling plugins.
*/
interface IPluginManager {
event PluginInstalled(address indexed plugin, bytes32 manifestHash, FunctionReference[] dependencies);
event PluginUninstalled(address indexed plugin, bool indexed onUninstallSucceeded);
/// @notice Install a plugin to the modular account.
/// @param plugin The plugin to install.
/// @param manifestHash The hash of the plugin manifest.
/// @param pluginInstallData Optional data to be decoded and used by the plugin to setup initial plugin data
/// for the modular account.
/// @param dependencies The dependencies of the plugin, as described in the manifest. Each FunctionReference
/// MUST be composed of an installed plugin's address and a function ID of its validation function.
function installPlugin(
address plugin,
bytes32 manifestHash,
bytes calldata pluginInstallData,
FunctionReference[] calldata dependencies
) external;
/// @notice Uninstall a plugin from the modular account.
/// @param plugin The plugin to uninstall.
/// @param config An optional, implementation-specific field that accounts may use to ensure consistency
/// guarantees.
/// @param pluginUninstallData Optional data to be decoded and used by the plugin to clear plugin data for the
/// modular account.
function uninstallPlugin(
address plugin,
bytes calldata config,
bytes calldata pluginUninstallData
) external;
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
/**
* @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support execution from plugins.
*/
interface IPluginExecutor {
/// @notice Execute a call from a plugin through the account.
/// @dev Permissions must be granted to the calling plugin for the call to go through.
/// @param data The calldata to send to the account.
function executeFromPlugin(bytes calldata data) external payable returns (bytes memory);
/// @notice Execute a call from a plugin to a non-plugin address.
/// @dev If the target is a plugin, the call SHOULD revert. Permissions must be granted to the calling plugin
/// for the call to go through.
/// @param target The address to be called.
/// @param value The value to send with the call.
/// @param data The calldata to send to the target.
/// @return The return data from the call.
function executeFromPluginExternal(address target, uint256 value, bytes calldata data) external payable returns (bytes memory);
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import "../common/Structs.sol";
/**
* @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support open-ended execution.
*/
interface IStandardExecutor {
/// @notice Standard execute method.
/// @dev If the target is a plugin, the call SHOULD revert.
/// @param target The target address for the account to call.
/// @param value The value to send with the call.
/// @param data The calldata for the call.
/// @return The return data from the call.
function execute(address target, uint256 value, bytes calldata data) external payable returns (bytes memory);
/// @notice Standard executeBatch method.
/// @dev If the target is a plugin, the call SHOULD revert. If any of the calls revert, the entire batch MUST
/// revert.
/// @param calls The array of calls.
/// @return An array containing the return data from the calls.
function executeBatch(Call[] calldata calls) external payable returns (bytes[] memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822ProxiableUpgradeable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
pragma solidity ^0.8.2;
import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/IERC1967Upgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*/
abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
function __ERC1967Upgrade_init() internal onlyInitializing {
}
function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
}
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Returns the current implementation address.
*/
function _getImplementation() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Perform implementation upgrade
*
* Emits an {Upgraded} event.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Perform implementation upgrade with additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
AddressUpgradeable.functionDelegateCall(newImplementation, data);
}
}
/**
* @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Returns the current admin.
*/
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {AdminChanged} event.
*/
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
*/
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Returns the current beacon.
*/
function _getBeacon() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
/**
* @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
* not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
*
* Emits a {BeaconUpgraded} event.
*/
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import "../common/Structs.sol";
/**
* @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support open-ended execution.
*/
library StandardExecutor {
using ExecutionUtils for address;
error TargetIsPlugin(address plugin);
/// @dev Refer to IStandardExecutor
function execute(address target, uint256 value, bytes calldata data) internal returns (bytes memory returnData) {
// reverts if the target is a plugin because modular account should be calling plugin via execution functions
// defined in IPluginExecutor
if (ERC165Checker.supportsInterface(target, type(IPlugin).interfaceId)) {
revert TargetIsPlugin(target);
}
return target.callWithReturnDataOrRevert(value, data);
}
/// @dev Refer to IStandardExecutor
function executeBatch(Call[] calldata calls) internal returns (bytes[] memory returnData) {
returnData = new bytes[](calls.length);
for (uint256 i = 0; i < calls.length; ++i) {
if (ERC165Checker.supportsInterface(calls[i].target, type(IPlugin).interfaceId)) {
revert TargetIsPlugin(calls[i].target);
}
returnData[i] = calls[i].target.callWithReturnDataOrRevert(calls[i].value, calls[i].data);
}
return returnData;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {ExecutionHookLib} from "../libs/ExecutionHookLib.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
/**
* @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support execution from plugins.
* https://eips.ethereum.org/assets/eip-6900/Plugin_Execution_Flow.svg
*/
library PluginExecutor {
using ExecutionHookLib for HookGroup;
using ExecutionHookLib for PostExecHookToRun[];
using ExecutionUtils for address;
error ExecuteFromPluginToExternalNotPermitted();
error ExecFromPluginToSelectorNotPermitted(address plugin, bytes4 selector);
error NativeTokenSpendingNotPermitted(address plugin);
/// @dev Refer to IPluginExecutor
function executeFromPlugin(bytes calldata data) internal returns (bytes memory) {
if (data.length < 4) {
revert NotFoundSelector();
}
bytes4 selector = bytes4(data[0 : 4]);
if (selector == bytes4(0)) {
revert NotFoundSelector();
}
address callingPlugin = msg.sender;
WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
// permission check
if (!walletStorage.permittedPluginCalls[callingPlugin][selector]) {
revert ExecFromPluginToSelectorNotPermitted(callingPlugin, selector);
}
// this function call emulates a call to the fallback that routes calls into another plugin;
// we use inner data here instead of the entire msg.data that includes the complete calldata of executeFromPlugin
ExecutionDetail storage executionDetail = walletStorage.executionDetails[selector];
if (executionDetail.plugin == address(0)) {
revert InvalidExecutionFunction(selector);
}
// pre execution hooks
PostExecHookToRun[] memory postExecHooks = executionDetail.executionHooks._processPreExecHooks(data);
// permitted to call the other plugin
bytes memory returnData = executionDetail.plugin.callWithReturnDataOrRevert(0, data);
// post execution hooks
postExecHooks._processPostExecHooks();
return returnData;
}
/// @dev Refer to IPluginExecutor
function executeFromPluginToExternal(bytes calldata data, address target, uint256 value) internal returns (bytes memory) {
if (target == address(this) || ERC165Checker.supportsInterface(target, type(IPlugin).interfaceId)) {
revert ExecuteFromPluginToExternalNotPermitted();
}
WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
address callingPlugin = msg.sender;
// revert if the plugin can't cover the value and is not permitted to spend MSCA's native token
if (value > 0 && value > msg.value && !walletStorage.pluginDetails[callingPlugin].canSpendNativeToken) {
revert NativeTokenSpendingNotPermitted(callingPlugin);
}
PermittedExternalCall storage permittedExternalCall = walletStorage.permittedExternalCalls[callingPlugin][target];
// permission check
// addressPermitted can only be true if anyExternalAddressPermitted is false
bool targetContractCallPermitted;
// external call might not have function selector
bytes4 selector = bytes4(data);
if (permittedExternalCall.addressPermitted) {
targetContractCallPermitted = permittedExternalCall.anySelector || permittedExternalCall.selectors[selector] || data.length == 0;
} else {
// also need to check the default permission in plugin detail
targetContractCallPermitted = walletStorage.pluginDetails[callingPlugin].anyExternalAddressPermitted;
}
if (!targetContractCallPermitted) {
revert ExecFromPluginToSelectorNotPermitted(callingPlugin, selector);
}
// we use msg.data here so the complete calldata of current function call executeFromPluginToExternalContract can be passed
// pre executeFromPluginToExternalContract hooks
// process any pre exec hooks for IPluginExecutor.executeFromPluginExternal.selector during runtime
PostExecHookToRun[] memory postExecHooks = walletStorage.executionDetails[IPluginExecutor.executeFromPluginExternal.selector]
.executionHooks._processPreExecHooks(msg.data);
// call externally
bytes memory returnData = target.callWithReturnDataOrRevert(value, data);
// post executeFromPluginToExternalContract hooks
postExecHooks._processPostExecHooks();
return returnData;
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {IPlugin} from "../interfaces/IPlugin.sol";
import {RepeatableFunctionReferenceDLLLib} from "./RepeatableFunctionReferenceDLLLib.sol";
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";
import "../common/Errors.sol";
import "../common/Structs.sol";
import "../common/Constants.sol";
/**
* @dev Process pre or post execution hooks.
*/
library ExecutionHookLib {
using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
using FunctionReferenceLib for FunctionReference;
using FunctionReferenceLib for bytes21;
error PreExecHookFailed(address plugin, uint8 functionId, bytes revertReason);
error PostExecHookFailed(address plugin, uint8 functionId, bytes revertReason);
// avoid stack too deep
struct SetPostExecHooksFromPreHooksParam {
uint256 totalPostExecHooksToRunCount;
PostExecHookToRun[] postExecHooksToRun;
}
function _processPreExecHooks(
HookGroup storage hookGroup,
bytes calldata data)
internal
returns(PostExecHookToRun[] memory postExecHooksToRun) {
uint256 postOnlyHooksCount = hookGroup.postOnlyHooks.getUniqueItems();
// hooks have three categories a. preOnlyHook b. preToPostHook c. postOnlyHook
// 1. add repeated preHook into postHook 2. add postOnlyHooks
uint256 maxPostHooksCount = postOnlyHooksCount + hookGroup.preHooks.getTotalItems();
uint256 totalPostExecHooksToRunCount = 0;
postExecHooksToRun = new PostExecHookToRun[](maxPostHooksCount);
// copy postOnlyHooks into result first
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
for (uint256 i = 0; i < postOnlyHooksCount; ++i) {
(FunctionReference[] memory resultPostOnlyHooks, FunctionReference memory nextHook) = hookGroup.postOnlyHooks.getPaginated(startHook, 10);
for (uint256 j = 0; j < resultPostOnlyHooks.length; ++j) {
postExecHooksToRun[totalPostExecHooksToRunCount++].postExecHook = resultPostOnlyHooks[j];
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
// then run the preHooks and copy associated postHooks
SetPostExecHooksFromPreHooksParam memory input;
input.totalPostExecHooksToRunCount = totalPostExecHooksToRunCount;
input.postExecHooksToRun = postExecHooksToRun;
(totalPostExecHooksToRunCount, postExecHooksToRun) = _setPostExecHooksFromPreHooks(hookGroup, data, input);
assembly ("memory-safe") {
mstore(postExecHooksToRun, totalPostExecHooksToRunCount)
}
}
function _processPreExecHook(FunctionReference memory preExecHook, bytes calldata data)
internal
returns (bytes memory preExecHookReturnData){
try IPlugin(preExecHook.plugin).preExecutionHook(preExecHook.functionId, msg.sender, msg.value, data) returns (
bytes memory returnData
) {
preExecHookReturnData = returnData;
} catch (bytes memory revertReason) {
revert PreExecHookFailed(preExecHook.plugin, preExecHook.functionId, revertReason);
}
return preExecHookReturnData;
}
function _processPostExecHooks(PostExecHookToRun[] memory postExecHooksToRun) internal {
uint256 length = postExecHooksToRun.length;
for (uint256 i = 0; i < length; ++i) {
FunctionReference memory postExecHook = postExecHooksToRun[i].postExecHook;
try IPlugin(postExecHook.plugin).postExecutionHook(postExecHook.functionId, postExecHooksToRun[i].preExecHookReturnData) {}
catch (bytes memory revertReason) {
revert PostExecHookFailed(postExecHook.plugin, postExecHook.functionId, revertReason);
}
}
}
function _getExecutionHooks(HookGroup storage hookGroup)
internal
view
returns(ExecutionHooks[] memory hooks) {
uint256 preHooksCount = hookGroup.preHooks.getUniqueItems();
uint256 postOnlyHooksCount = hookGroup.postOnlyHooks.getUniqueItems();
// hooks have three categories a. preOnlyHook b. preToPostHook c. postOnlyHook
// 1. add repeated preHook into postHook 2. add postOnlyHooks
uint256 maxExecHooksCount = postOnlyHooksCount + hookGroup.preHooks.getTotalItems();
uint256 totalExecHooksCount = 0;
hooks = new ExecutionHooks[](maxExecHooksCount);
// copy postOnlyHooks into result first
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
for (uint i = 0; i < postOnlyHooksCount; ++i) {
(FunctionReference[] memory resultPostOnlyHooks, FunctionReference memory nextHook) = hookGroup.postOnlyHooks.getPaginated(startHook, 10);
for (uint j = 0; j < resultPostOnlyHooks.length; ++j) {
hooks[totalExecHooksCount++].postExecHook = resultPostOnlyHooks[j];
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
// then copy preOnlyHooks or preToPostHooks
startHook = EMPTY_FUNCTION_REFERENCE.unpack();
for (uint256 i = 0; i < preHooksCount; ++i) {
(FunctionReference[] memory resultPreExecHooks, FunctionReference memory nextHook) = hookGroup.preHooks.getPaginated(startHook, 10);
for (uint256 j = 0; j < resultPreExecHooks.length; ++j) {
// if any revert, the outer call MUST revert
bytes21 packedPreExecHook = resultPreExecHooks[j].pack();
// getAll can handle 1000+ hooks
FunctionReference[] memory preToPostHooks = hookGroup.preToPostHooks[packedPreExecHook].getAll();
if (preToPostHooks.length > 0) {
for (uint256 k = 0; k < preToPostHooks.length; ++k) {
hooks[totalExecHooksCount].preExecHook = resultPreExecHooks[j];
hooks[totalExecHooksCount].postExecHook = preToPostHooks[k];
totalExecHooksCount++;
}
} else {
// no associated postHook
hooks[totalExecHooksCount++].preExecHook = resultPreExecHooks[j];
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
assembly ("memory-safe") {
mstore(hooks, totalExecHooksCount)
}
return hooks;
}
/// @dev The caller would expect both input.totalPostExecHooksToRunCount and input.postExecHooksToRun to be assigned back to original values.
function _setPostExecHooksFromPreHooks(HookGroup storage hookGroup, bytes calldata data, SetPostExecHooksFromPreHooksParam memory input) internal returns (uint256, PostExecHookToRun[] memory) {
FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
uint256 preHooksCount = hookGroup.preHooks.getUniqueItems();
for (uint256 i = 0; i < preHooksCount; ++i) {
(FunctionReference[] memory resultPreExecHooks, FunctionReference memory nextHook) = hookGroup.preHooks.getPaginated(startHook, 10);
for (uint256 j = 0; j < resultPreExecHooks.length; ++j) {
// if any revert, the outer call MUST revert
bytes21 packedPreExecHook = resultPreExecHooks[j].pack();
if (packedPreExecHook == EMPTY_FUNCTION_REFERENCE
|| packedPreExecHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
|| packedPreExecHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE) {
revert InvalidValidationFunctionId(resultPreExecHooks[j].functionId);
}
// getAll can handle 1000+ hooks
// run duplicated (if any) preHooks only once
bytes memory preExecHookReturnData = _processPreExecHook(resultPreExecHooks[j], data);
FunctionReference[] memory preToPostHooks = hookGroup.preToPostHooks[packedPreExecHook].getAll();
if (preToPostHooks.length > 0) {
for (uint256 k = 0; k < preToPostHooks.length; ++k) {
input.postExecHooksToRun[input.totalPostExecHooksToRunCount].postExecHook = preToPostHooks[k];
input.postExecHooksToRun[input.totalPostExecHooksToRunCount].preExecHookReturnData = preExecHookReturnData;
input.totalPostExecHooksToRunCount++;
}
}
}
if (nextHook.pack() == SENTINEL_BYTES21) {
break;
}
startHook = nextHook;
}
return (input.totalPostExecHooksToRunCount, input.postExecHooksToRun);
}
}// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.24;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
/// @notice Forked from OpenZeppelin (proxy/utils/Initializable.sol) with wallet storage access.
/// Reinitialization is removed.
/// For V1 MSCA.
abstract contract WalletStorageInitializable {
/**
* @dev Triggered when the contract has been initialized.
*/
event WalletStorageInitialized();
error WalletStorageIsInitializing();
error WalletStorageIsNotInitializing();
error WalletStorageIsInitialized();
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyWalletStorageInitializing` functions can be used to initialize parent contracts.
*
* Functions marked with `walletStorageInitializer` can be nested in the context of a
* constructor.
*
* Emits an {WalletStorageInitialized} event.
*/
modifier walletStorageInitializer() {
bool isTopLevelCall = _setWalletStorageInitializing();
_;
if (isTopLevelCall) {
WalletStorageV1Lib.getLayout().initializing = false;
emit WalletStorageInitialized();
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {walletStorageInitializer} modifier, directly or indirectly.
*/
modifier onlyWalletStorageInitializing() {
if (!WalletStorageV1Lib.getLayout().initializing) {
revert WalletStorageIsNotInitializing();
}
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {WalletStorageInitialized} event the first time it is successfully executed.
*/
function _disableWalletStorageInitializers() internal virtual {
if (WalletStorageV1Lib.getLayout().initializing) {
revert WalletStorageIsInitializing();
}
if (WalletStorageV1Lib.getLayout().initialized != type(uint8).max) {
WalletStorageV1Lib.getLayout().initialized = type(uint8).max;
emit WalletStorageInitialized();
}
}
function _setWalletStorageInitializing() internal returns (bool) {
bool isTopLevelCall = !WalletStorageV1Lib.getLayout().initializing;
uint8 initialized = WalletStorageV1Lib.getLayout().initialized;
if (!(isTopLevelCall && initialized < 1) || (!Address.isContract(address(this)) && initialized == 1)) {
revert WalletStorageIsInitialized();
}
WalletStorageV1Lib.getLayout().initialized = 1;
if (isTopLevelCall) {
WalletStorageV1Lib.getLayout().initializing = true;
}
return isTopLevelCall;
}
}// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC777Recipient.sol) pragma solidity ^0.8.0; import "../token/ERC777/IERC777Recipient.sol";
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeaconUpgradeable {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
*
* _Available since v4.8.3._
*/
interface IERC1967Upgradeable {
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Emitted when the beacon is changed.
*/
event BeaconUpgraded(address indexed beacon);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
* _Available since v4.9 for `string`, `bytes`._
*/
library StorageSlotUpgradeable {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777Recipient.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
*
* Accounts can be notified of {IERC777} tokens being sent to them by having a
* contract implement this interface (contract holders can be their own
* implementer) and registering it on the
* https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
*
* See {IERC1820Registry} and {ERC1820Implementer}.
*/
interface IERC777Recipient {
/**
* @dev Called by an {IERC777} token contract whenever tokens are being
* moved or created into a registered account (`to`). The type of operation
* is conveyed by `from` being the zero address or not.
*
* This call occurs _after_ the token contract's state is updated, so
* {IERC777-balanceOf}, etc., can be used to query the post-operation state.
*
* This function may revert to prevent the operation from being executed.
*/
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external;
}{
"remappings": [
"@account-abstraction/=lib/account-abstraction/",
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"ds-test/=lib/forge-std/lib/ds-test/src/",
"eth-gas-reporter/=node_modules/eth-gas-reporter/",
"forge-std/=lib/forge-std/",
"hardhat/=node_modules/hardhat/",
"@modular-account/=lib/modular-account/src/",
"@alchemy/light-account/=lib/modular-account/lib/light-account/",
"@eth-infinitism/account-abstraction/=lib/modular-account/lib/account-abstraction/contracts/",
"account-abstraction/=lib/account-abstraction/contracts/",
"centre-tokens/=lib/centre-tokens/",
"erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
"hardhat-deploy/=node_modules/hardhat-deploy/",
"light-account/=lib/modular-account/lib/light-account/",
"modular-account/=lib/modular-account/",
"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/",
"openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/"
],
"optimizer": {
"enabled": true,
"runs": 200
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"abi"
]
}
},
"evmVersion": "paris",
"viaIR": true,
"libraries": {}
}[{"inputs":[{"internalType":"address","name":"_entryPointAddr","type":"address"},{"internalType":"address","name":"_pluginManagerAddr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Create2FailedDeployment","type":"error"},{"inputs":[],"name":"InvalidInitializationInput","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"AccountCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"factory","type":"address"},{"indexed":false,"internalType":"address","name":"accountImplementation","type":"address"},{"indexed":false,"internalType":"address","name":"entryPoint","type":"address"}],"name":"FactoryDeployed","type":"event"},{"inputs":[],"name":"accountImplementation","outputs":[{"internalType":"contract SingleOwnerMSCA","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"bytes","name":"_initializingData","type":"bytes"}],"name":"createAccount","outputs":[{"internalType":"contract SingleOwnerMSCA","name":"account","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"entryPoint","outputs":[{"internalType":"contract IEntryPoint","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"bytes","name":"_initializingData","type":"bytes"}],"name":"getAddress","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes32","name":"mixedSalt","type":"bytes32"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d2789000000000000000000000000c751a2bfa2a4a5b27e94ad735534c16a0999d871
-----Decoded View---------------
Arg [0] : _entryPointAddr (address): 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789
Arg [1] : _pluginManagerAddr (address): 0xc751A2bFA2A4a5b27E94ad735534c16a0999d871
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d2789
Arg [1] : 000000000000000000000000c751a2bfa2a4a5b27e94ad735534c16a0999d871
Deployed Bytecode Sourcemap
649:5955:44:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;776:39;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;;5185:34;649:5955;;;:::i;:::-;;;-1:-1:-1;;;;;649:5955:44;5128:40;;;;;;;;;;;:::i;:::-;649:5955;5185:34;;:::i;:::-;649:5955;;;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;;;;;;;;716:54;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;649:5955:44;;;;;;;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;649:5955:44;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;649:5955:44;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;649:5955:44;;;;;;;;;;;;-1:-1:-1;;;;;649:5955:44;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;649:5955:44;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;649:5955:44;;;;:::o;3120:1068::-;649:5955;;-1:-1:-1;;;;;649:5955:44;;;;3303:40;;;;;;;;;;;:::i;:::-;649:5955;3403:34;;;;;;:::i;:::-;3451:30;;;;3447:116;;649:5955;;3937:66;;;;3303:40;3937:66;;;;;;649:5955;3937:66;;;;;;:::i;:::-;649:5955;;3837:167;;;;;;;;;;;;;;;;;;;;;;3897:21;;649:5955;3837:167;;:::i;:::-;;;-1:-1:-1;3837:167:44;;;;;649:5955;;;;4020:38;;;;4016:101;;649:5955;;;-1:-1:-1;;;;;649:5955:44;;;;;;;;;;;;;4131:50;;;3120:1068::o;4016:101::-;649:5955;;-1:-1:-1;;;4081:25:44;;3937:66;;4081:25;3837:167;649:5955;;;-1:-1:-1;649:5955:44;;;;;3447:116;649:5955;;;;;;;;3501:51;:::o;5941:661::-;;;;-1:-1:-1;;;;;649:5955:44;;;;6105:20;;6101:86;;649:5955;;;;6218:40;;;;;;649:5955;;;;;;;;;;;;;;;;;;;;;;6218:40;;649:5955;;;;;;;;;;;;;;6294:195;649:5955;;2345:1598:27;649:5955:44;6377:111;2345:1598:27;649:5955:44;6377:111;649:5955;;;;;6208:51;;6328:31;;;;;;649:5955;6328:31;;;649:5955;;:::i;:::-;6328:31;;;;;;;;649:5955;;3937:66;;;;6420:67;;;;;;;649:5955;6420:67;;;;;;:::i;:::-;649:5955;;6377:111;;;;;;6396:21;;649:5955;6377:111;;:::i;:::-;;649:5955;;6377:111;;;;;;:::i;:::-;649:5955;;6294:195;;;649:5955;6294:195;;;649:5955;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;6294:195;;;;;;;:::i;:::-;649:5955;6284:206;;2345:1598:27;;;;;;;;;6555:4:44;2345:1598:27;;;;;;;6571:24:44;5941:661;:::o;6101:86::-;649:5955;;-1:-1:-1;;;6148:28:44;;;;
Swarm Source
ipfs://aed1cb5c2656e0786d7e99ec6daa5f6be3f1ab560098ab808fc5b3f58434316e
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.