编译器
0.8.19+commit.7dd6d404
文件 1 的 19：AddressProvider.sol
pragma solidity 0.8.19;
import {IAddressProviderService} from "interfaces/IAddressProviderService.sol";
import {Constants} from "src/core/Constants.sol";
contract AddressProvider is Constants {
error RegistryAlreadyExists();
error AddressProviderUnsupported();
error NotGovernance(address);
error NotPendingGovernance(address);
error NullAddress();
event RegistryInitialised(address indexed registry, bytes32 indexed key);
event AuthorizedAddressInitialised(address indexed authorizedAddress, bytes32 indexed key);
event GovernanceTransferRequested(address indexed previousGovernance, address indexed newGovernance);
event GovernanceTransferred(address indexed previousGovernance, address indexed newGovernance);
address public governance;
address public pendingGovernance;
mapping(bytes32 => address) internal authorizedAddresses;
mapping(bytes32 => address) internal registries;
constructor(address _governance, address walletRegistry, address policyRegistry, address executorRegistry) {
_notNull(_governance);
governance = _governance;
_notNull(walletRegistry);
_notNull(policyRegistry);
_notNull(executorRegistry);
registries[_WALLET_REGISTRY_HASH] = walletRegistry;
registries[_POLICY_REGISTRY_HASH] = policyRegistry;
registries[_EXECUTOR_REGISTRY_HASH] = executorRegistry;
}
function setGovernance(address _newGovernance) external {
_notNull(_newGovernance);
_onlyGov();
emit GovernanceTransferRequested(governance, _newGovernance);
pendingGovernance = _newGovernance;
}
function acceptGovernance() external {
if (msg.sender != pendingGovernance) {
revert NotPendingGovernance(msg.sender);
}
emit GovernanceTransferred(governance, msg.sender);
governance = msg.sender;
delete pendingGovernance;
}
function setAuthorizedAddress(bytes32 _key, address _authorizedAddress, bool _overrideCheck) external {
_onlyGov();
_notNull(_authorizedAddress);
if (!_overrideCheck) {
if (_authorizedAddress.code.length != 0) _ensureAddressProvider(_authorizedAddress);
}
authorizedAddresses[_key] = _authorizedAddress;
emit AuthorizedAddressInitialised(_authorizedAddress, _key);
}
function setRegistry(bytes32 _key, address _registry) external {
_onlyGov();
_ensureAddressProvider(_registry);
if (registries[_key] != address(0)) revert RegistryAlreadyExists();
registries[_key] = _registry;
emit RegistryInitialised(_registry, _key);
}
function getAuthorizedAddress(bytes32 _key) external view returns (address) {
return authorizedAddresses[_key];
}
function getRegistry(bytes32 _key) external view returns (address) {
return registries[_key];
}
function _ensureAddressProvider(address _newAddress) internal view {
if (IAddressProviderService(_newAddress).addressProviderTarget() != address(this)) {
revert AddressProviderUnsupported();
}
}
function _onlyGov() internal view {
if (msg.sender != governance) revert NotGovernance(msg.sender);
}
function _notNull(address addr) internal pure {
if (addr == address(0)) revert NullAddress();
}
}
文件 2 的 19：AddressProviderService.sol
pragma solidity 0.8.19;
import {IAddressProviderService} from "../../interfaces/IAddressProviderService.sol";
import {AddressProvider} from "../core/AddressProvider.sol";
import {Constants} from "./Constants.sol";
abstract contract AddressProviderService is IAddressProviderService, Constants {
error InvalidAddressProvider();
error NotGovernance(address);
error InvalidAddress();
AddressProvider public immutable addressProvider;
address public immutable walletRegistry;
address public immutable policyRegistry;
address public immutable executorRegistry;
constructor(address _addressProvider) {
if (_addressProvider == address(0)) revert InvalidAddressProvider();
addressProvider = AddressProvider(_addressProvider);
walletRegistry = addressProvider.getRegistry(_WALLET_REGISTRY_HASH);
policyRegistry = addressProvider.getRegistry(_POLICY_REGISTRY_HASH);
executorRegistry = addressProvider.getRegistry(_EXECUTOR_REGISTRY_HASH);
_notNull(walletRegistry);
_notNull(policyRegistry);
_notNull(executorRegistry);
}
function addressProviderTarget() external view override returns (address) {
return address(addressProvider);
}
function _getAuthorizedAddress(bytes32 _key) internal view returns (address authorizedAddress) {
authorizedAddress = addressProvider.getAuthorizedAddress(_key);
_notNull(authorizedAddress);
}
function _notNull(address _addr) internal pure {
if (_addr == address(0)) revert InvalidAddress();
}
}
文件 3 的 19：Constants.sol
pragma solidity 0.8.19;
abstract contract Constants {
bytes32 internal constant _EXECUTOR_REGISTRY_HASH = bytes32(uint256(keccak256("console.core.ExecutorRegistry")) - 1);
bytes32 internal constant _WALLET_REGISTRY_HASH = bytes32(uint256(keccak256("console.core.WalletRegistry")) - 1);
bytes32 internal constant _POLICY_REGISTRY_HASH = bytes32(uint256(keccak256("console.core.PolicyRegistry")) - 1);
bytes32 internal constant _EXECUTOR_PLUGIN_HASH = bytes32(uint256(keccak256("console.core.ExecutorPlugin")) - 1);
bytes32 internal constant _CONSOLE_FALLBACK_HANDLER_HASH =
bytes32(uint256(keccak256("console.core.FallbackHandler")) - 1);
bytes32 internal constant _SAFE_FALLBACK_HANDLER_HASH = bytes32(uint256(keccak256("safe.FallbackHandler")) - 1);
bytes32 internal constant _SAFE_MULTI_SEND_HASH = bytes32(uint256(keccak256("safe.MultiSend")) - 1);
bytes32 internal constant _SAFE_PROXY_FACTORY_HASH = bytes32(uint256(keccak256("safe.ProxyFactory")) - 1);
bytes32 internal constant _SAFE_SINGLETON_HASH = bytes32(uint256(keccak256("safe.Singleton")) - 1);
bytes32 internal constant _POLICY_VALIDATOR_HASH = bytes32(uint256(keccak256("console.core.PolicyValidator")) - 1);
bytes32 internal constant _SAFE_DEPLOYER_HASH = bytes32(uint256(keccak256("console.core.SafeDeployer")) - 1);
bytes32 internal constant _SAFE_ENABLER_HASH = bytes32(uint256(keccak256("console.core.SafeEnabler")) - 1);
bytes32 internal constant _SAFE_MODERATOR_HASH = bytes32(uint256(keccak256("console.core.SafeModerator")) - 1);
bytes32 internal constant _SAFE_MODERATOR_OVERRIDABLE_HASH =
bytes32(uint256(keccak256("console.core.SafeModeratorOverridable")) - 1);
bytes32 internal constant _TRANSACTION_VALIDATOR_HASH =
bytes32(uint256(keccak256("console.core.TransactionValidator")) - 1);
bytes32 internal constant _CONSOLE_OP_BUILDER_HASH =
bytes32(uint256(keccak256("console.core.ConsoleOpBuilder")) - 1);
bytes32 internal constant _EXECUTION_BLOCKER_HASH = bytes32(uint256(keccak256("console.core.ExecutionBlocker")) - 1);
bytes32 internal constant _POLICY_AUTHENTICATOR_HASH =
bytes32(uint256(keccak256("console.roles.PolicyAuthenticator")) - 1);
}
文件 4 的 19：EIP712.sol
pragma solidity ^0.8.4;
abstract contract EIP712 {
bytes32 internal constant _DOMAIN_TYPEHASH =
0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
address private immutable _cachedThis;
uint256 private immutable _cachedChainId;
bytes32 private immutable _cachedNameHash;
bytes32 private immutable _cachedVersionHash;
bytes32 private immutable _cachedDomainSeparator;
constructor() {
_cachedThis = address(this);
_cachedChainId = block.chainid;
string memory name;
string memory version;
if (!_domainNameAndVersionMayChange()) (name, version) = _domainNameAndVersion();
bytes32 nameHash = _domainNameAndVersionMayChange() ? bytes32(0) : keccak256(bytes(name));
bytes32 versionHash =
_domainNameAndVersionMayChange() ? bytes32(0) : keccak256(bytes(version));
_cachedNameHash = nameHash;
_cachedVersionHash = versionHash;
bytes32 separator;
if (!_domainNameAndVersionMayChange()) {
assembly {
let m := mload(0x40)
mstore(m, _DOMAIN_TYPEHASH)
mstore(add(m, 0x20), nameHash)
mstore(add(m, 0x40), versionHash)
mstore(add(m, 0x60), chainid())
mstore(add(m, 0x80), address())
separator := keccak256(m, 0xa0)
}
}
_cachedDomainSeparator = separator;
}
function _domainNameAndVersion()
internal
view
virtual
returns (string memory name, string memory version);
function _domainNameAndVersionMayChange() internal pure virtual returns (bool result) {}
function _domainSeparator() internal view virtual returns (bytes32 separator) {
if (_domainNameAndVersionMayChange()) {
separator = _buildDomainSeparator();
} else {
separator = _cachedDomainSeparator;
if (_cachedDomainSeparatorInvalidated()) separator = _buildDomainSeparator();
}
}
function _hashTypedData(bytes32 structHash) internal view virtual returns (bytes32 digest) {
bytes32 separator;
if (_domainNameAndVersionMayChange()) {
separator = _buildDomainSeparator();
} else {
separator = _cachedDomainSeparator;
if (_cachedDomainSeparatorInvalidated()) separator = _buildDomainSeparator();
}
assembly {
mstore(0x00, 0x1901000000000000)
mstore(0x1a, separator)
mstore(0x3a, structHash)
digest := keccak256(0x18, 0x42)
mstore(0x3a, 0)
}
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
fields = hex"0f";
(name, version) = _domainNameAndVersion();
chainId = block.chainid;
verifyingContract = address(this);
salt = salt;
extensions = extensions;
}
function _buildDomainSeparator() private view returns (bytes32 separator) {
bytes32 nameHash;
bytes32 versionHash;
if (_domainNameAndVersionMayChange()) {
(string memory name, string memory version) = _domainNameAndVersion();
nameHash = keccak256(bytes(name));
versionHash = keccak256(bytes(version));
} else {
nameHash = _cachedNameHash;
versionHash = _cachedVersionHash;
}
assembly {
let m := mload(0x40)
mstore(m, _DOMAIN_TYPEHASH)
mstore(add(m, 0x20), nameHash)
mstore(add(m, 0x40), versionHash)
mstore(add(m, 0x60), chainid())
mstore(add(m, 0x80), address())
separator := keccak256(m, 0xa0)
}
}
function _cachedDomainSeparatorInvalidated() private view returns (bool result) {
uint256 cachedChainId = _cachedChainId;
address cachedThis = _cachedThis;
assembly {
result := iszero(and(eq(chainid(), cachedChainId), eq(address(), cachedThis)))
}
}
}
文件 5 的 19：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 6 的 19：ExecutorPlugin.sol
pragma solidity 0.8.19;
import {ReentrancyGuard} from "openzeppelin-contracts/security/ReentrancyGuard.sol";
import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
import {EIP712} from "solady/utils/EIP712.sol";
import {ISafeWallet} from "interfaces/external/ISafeWallet.sol";
import {AddressProviderService} from "src/core/AddressProviderService.sol";
import {TransactionValidator} from "src/core/TransactionValidator.sol";
import {ExecutorRegistry} from "src/core/registries/ExecutorRegistry.sol";
import {SafeHelper} from "src/libraries/SafeHelper.sol";
import {TypeHashHelper} from "src/libraries/TypeHashHelper.sol";
import {Types} from "interfaces/Types.sol";
contract ExecutorPlugin is AddressProviderService, ReentrancyGuard, EIP712 {
error InvalidExecutor();
error InvalidSignature();
error ModuleExecutionFailed();
struct ExecutionRequest {
Types.Executable exec;
address account;
address executor;
bytes executorSignature;
bytes validatorSignature;
}
string private constant _NAME = "ExecutorPlugin";
string private constant _VERSION = "1.0";
mapping(address account => mapping(address executor => uint256 nonce)) public executorNonce;
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function executeTransaction(ExecutionRequest calldata execRequest) external nonReentrant returns (bytes memory) {
address transactionValidator = AddressProviderService._getAuthorizedAddress(_TRANSACTION_VALIDATOR_HASH);
_validateExecutionRequest(execRequest, transactionValidator);
bytes memory txnResult = _executeTxnAsModule(execRequest.account, execRequest.exec);
TransactionValidator(transactionValidator).validatePostExecutorTransaction(msg.sender, execRequest.account);
return txnResult;
}
function _executeTxnAsModule(address _account, Types.Executable memory _executable)
internal
returns (bytes memory)
{
(bool success, bytes memory txnResult) = ISafeWallet(_account).execTransactionFromModuleReturnData(
_executable.target,
_executable.value,
_executable.data,
SafeHelper._parseOperationEnum(_executable.callType)
);
if (!success) revert ModuleExecutionFailed();
return txnResult;
}
function _validateExecutionRequest(ExecutionRequest calldata execRequest, address transactionValidator) internal {
if (!ExecutorRegistry(executorRegistry).isExecutor(execRequest.account, execRequest.executor)) {
revert InvalidExecutor();
}
if (execRequest.executor.code.length == 0 && execRequest.executorSignature.length == 0) {
revert InvalidSignature();
}
bytes32 _executionStructHash = TypeHashHelper._buildExecutionParamsHash(
TypeHashHelper.ExecutionParams({
to: execRequest.exec.target,
value: execRequest.exec.value,
data: execRequest.exec.data,
operation: uint8(SafeHelper._parseOperationEnum(execRequest.exec.callType)),
account: execRequest.account,
executor: execRequest.executor,
nonce: executorNonce[execRequest.account][execRequest.executor]++,
safeTxGas: 0,
baseGas: 0,
gasPrice: 0,
gasToken: address(0),
refundReceiver: address(0)
})
);
bytes32 _transactionDigest = _hashTypedData(_executionStructHash);
if (
!SignatureCheckerLib.isValidSignatureNow(
execRequest.executor, _transactionDigest, execRequest.executorSignature
)
) {
revert InvalidExecutor();
}
TransactionValidator(transactionValidator).validatePreExecutorTransaction(
msg.sender, execRequest.account, _executionStructHash, execRequest.validatorSignature
);
}
function _domainNameAndVersion() internal pure override returns (string memory name, string memory version) {
return (_NAME, _VERSION);
}
}
文件 7 的 19：ExecutorRegistry.sol
pragma solidity 0.8.19;
import {AddressProviderService} from "../AddressProviderService.sol";
import {WalletRegistry} from "./WalletRegistry.sol";
import {EnumerableSet} from "openzeppelin-contracts/utils/structs/EnumerableSet.sol";
contract ExecutorRegistry is AddressProviderService {
using EnumerableSet for EnumerableSet.AddressSet;
error NotAuthorized();
error AlreadyExists();
error DoesNotExist();
error NoPolicyCommit();
event RegisterExecutor(address indexed _account, address indexed _authorizer, address indexed _executor);
event DeRegisterExecutor(address indexed _account, address indexed _authorizer, address indexed _executor);
mapping(address account => EnumerableSet.AddressSet) private accountExecutors;
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function registerExecutor(address _account, address _executor) external {
_validateMsgSenderConsoleAccount(_account);
if (!accountExecutors[_account].add(_executor)) revert AlreadyExists();
emit RegisterExecutor(_account, msg.sender, _executor);
}
function deRegisterExecutor(address _account, address _executor) external {
_validateMsgSenderConsoleAccount(_account);
if (!accountExecutors[_account].remove(_executor)) revert DoesNotExist();
emit DeRegisterExecutor(_account, msg.sender, _executor);
}
function isExecutor(address _account, address _executor) external view returns (bool) {
return accountExecutors[_account].contains(_executor);
}
function getExecutorsForAccount(address _account) external view returns (address[] memory) {
return accountExecutors[_account].values();
}
function _validateMsgSenderConsoleAccount(address _account) internal view {
if (msg.sender == _account && WalletRegistry(walletRegistry).isWallet(msg.sender)) return;
if (WalletRegistry(walletRegistry).subAccountToWallet(_account) == msg.sender) return;
revert NotAuthorized();
}
}
文件 8 的 19：IAddressProviderService.sol
pragma solidity 0.8.19;
interface IAddressProviderService {
function addressProviderTarget() external view returns (address);
}
文件 9 的 19：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 10 的 19：ISafeWallet.sol
pragma solidity 0.8.19;
import {IERC165} from "openzeppelin-contracts/utils/introspection/IERC165.sol";
contract Enum {
enum Operation {
Call,
DelegateCall
}
}
interface ISafeWallet {
function execTransactionFromModule(address to, uint256 value, bytes calldata data, Enum.Operation operation)
external
returns (bool success);
function execTransactionFromModuleReturnData(address to, uint256 value, bytes memory data, Enum.Operation operation)
external
returns (bool success, bytes memory returnData);
function getStorageAt(uint256 offset, uint256 length) external view returns (bytes memory);
function isOwner(address owner) external view returns (bool);
function nonce() external view returns (uint256);
function getThreshold() external view returns (uint256);
function isModuleEnabled(address module) external view returns (bool);
function enableModule(address module) external;
function disableModule(address prevModule, address module) external;
function removeOwner(address prevOwner, address owner, uint256 _threshold) external;
function swapOwner(address prevOwner, address oldOwner, address newOwner) external;
function getOwners() external view returns (address[] memory);
function approveHash(bytes32 hashToApprove) external;
function signedMessages(bytes32 _dataHash) external returns (uint256 _signatures);
function execTransaction(
address to,
uint256 value,
bytes calldata data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address payable refundReceiver,
bytes memory signatures
) external payable returns (bool);
function setup(
address[] memory _owners,
uint256 _threshold,
address to,
bytes memory data,
address fallbackHandler,
address paymentToken,
uint256 payment,
address paymentReceiver
) external;
function addOwnerWithThreshold(address owner, uint256 _threshold) external;
function domainSeparator() external view returns (bytes32);
function setFallbackHandler(address _fallbackHandler) external;
function setGuard(address guard) external;
function encodeTransactionData(
address to,
uint256 value,
bytes calldata data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address refundReceiver,
uint256 _nonce
) external view returns (bytes memory);
}
interface Guard is IERC165 {
function checkTransaction(
address to,
uint256 value,
bytes memory data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address payable refundReceiver,
bytes memory signatures,
address msgSender
) external;
function checkAfterExecution(bytes32 txHash, bool success) external;
}
文件 11 的 19：PolicyRegistry.sol
pragma solidity 0.8.19;
import {AddressProviderService} from "src/core/AddressProviderService.sol";
import {WalletRegistry} from "src/core/registries/WalletRegistry.sol";
contract PolicyRegistry is AddressProviderService {
error PolicyCommitInvalid();
error UnauthorizedPolicyUpdate();
event UpdatedPolicyCommit(address indexed account, bytes32 policyCommit, bytes32 oldPolicyCommit);
mapping(address account => bytes32 policyCommit) public commitments;
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function updatePolicy(address account, bytes32 policyCommit) external {
if (policyCommit == bytes32(0)) {
revert PolicyCommitInvalid();
}
bytes32 currentCommit = commitments[account];
if (
currentCommit == bytes32(0)
&& msg.sender == AddressProviderService._getAuthorizedAddress(_SAFE_DEPLOYER_HASH)
) {
} else {
if (WalletRegistry(walletRegistry).subAccountToWallet(account) == msg.sender) {
} else if (msg.sender == account && WalletRegistry(walletRegistry).isWallet(msg.sender)) {
} else {
revert UnauthorizedPolicyUpdate();
}
}
_updatePolicy(account, policyCommit, currentCommit);
}
function _updatePolicy(address account, bytes32 policyCommit, bytes32 oldPolicyCommit) internal {
emit UpdatedPolicyCommit(account, policyCommit, oldPolicyCommit);
commitments[account] = policyCommit;
}
}
文件 12 的 19：PolicyValidator.sol
pragma solidity 0.8.19;
import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
import {EIP712} from "solady/utils/EIP712.sol";
import {AddressProviderService} from "src/core/AddressProviderService.sol";
import {PolicyRegistry} from "src/core/registries/PolicyRegistry.sol";
import {TypeHashHelper} from "src/libraries/TypeHashHelper.sol";
import {ISafeWallet, Enum} from "interfaces/external/ISafeWallet.sol";
contract PolicyValidator is AddressProviderService, EIP712 {
error InvalidSignature();
error NoPolicyCommit();
error TxnExpired(uint32 expiryEpoch);
error InvalidSignatures();
string private constant _NAME = "PolicyValidator";
string private constant _VERSION = "1.0";
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function isPolicySignatureValid(TypeHashHelper.ExecutionParams memory executionParams, bytes calldata signatures)
external
view
returns (bool)
{
bytes32 executionStructHash = TypeHashHelper._buildExecutionParamsHash(executionParams);
return isPolicySignatureValid(executionParams.account, executionStructHash, signatures);
}
function isPolicySignatureValid(address account, bytes32 executionStructHash, bytes calldata signatures)
public
view
returns (bool)
{
bytes32 policyHash = PolicyRegistry(policyRegistry).commitments(account);
if (policyHash == bytes32(0)) {
revert NoPolicyCommit();
}
(uint32 expiryEpoch, bytes memory validatorSignature) = _decompileSignatures(signatures);
if (expiryEpoch < uint32(block.timestamp)) {
revert TxnExpired(expiryEpoch);
}
bytes32 validationStructHash = TypeHashHelper._buildValidationParamsHash(
TypeHashHelper.ValidationParams({
executionStructHash: executionStructHash,
policyHash: policyHash,
expiryEpoch: expiryEpoch
})
);
bytes32 txnValidityDigest = _hashTypedData(validationStructHash);
address policyAuthenticator = AddressProviderService._getAuthorizedAddress(_POLICY_AUTHENTICATOR_HASH);
if (validatorSignature.length == 0) {
uint256 _codesize;
assembly {
_codesize := extcodesize(policyAuthenticator)
}
if (_codesize == 0) {
revert InvalidSignature();
}
}
return SignatureCheckerLib.isValidSignatureNow(policyAuthenticator, txnValidityDigest, validatorSignature);
}
function _decompileSignatures(bytes calldata _signatures)
internal
pure
returns (uint32 expiryEpoch, bytes memory validatorSignature)
{
if (_signatures.length < 8) revert InvalidSignatures();
uint32 sigLength = uint32(bytes4(_signatures[_signatures.length - 8:_signatures.length - 4]));
if (_signatures.length - 8 < sigLength) revert InvalidSignatures();
expiryEpoch = uint32(bytes4(_signatures[_signatures.length - 4:_signatures.length]));
validatorSignature = _signatures[_signatures.length - 8 - sigLength:_signatures.length - 8];
}
function _domainNameAndVersion() internal pure override returns (string memory name, string memory version) {
return (_NAME, _VERSION);
}
}
文件 13 的 19：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
文件 14 的 19：SafeHelper.sol
pragma solidity 0.8.19;
import {Enum, ISafeWallet} from "interfaces/external/ISafeWallet.sol";
import {Types} from "interfaces/Types.sol";
library SafeHelper {
error InvalidMultiSendInput();
error UnableToParseOperation();
uint256 internal constant _GUARD_STORAGE_SLOT =
33528237782592280163068556224972516439282563014722366175641814928123294921928;
uint256 internal constant _FALLBACK_HANDLER_STORAGE_SLOT =
49122629484629529244014240937346711770925847994644146912111677022347558721749;
bytes32 internal constant _GUARD_REMOVAL_CALLDATA_HASH =
0xc0e2c16ecb99419a40dd8b9c0b339b27acebd27c481a28cd606927aeb86f5079;
bytes32 internal constant _FALLBACK_REMOVAL_CALLDATA_HASH =
0x5bdf8c44c012c1347b2b15694dc5cc39b899eb99e32614676b7661001be925b7;
function _packMultisendTxns(Types.Executable[] memory _txns) internal pure returns (bytes memory packedTxns) {
uint256 len = _txns.length;
if (len == 0) revert InvalidMultiSendInput();
uint256 i = 0;
do {
uint8 call = uint8(_parseOperationEnum(_txns[i].callType));
uint256 calldataLength = _txns[i].data.length;
bytes memory encodedTxn = abi.encodePacked(
bytes1(call), bytes20(_txns[i].target), bytes32(_txns[i].value), bytes32(calldataLength), _txns[i].data
);
if (i != 0) {
packedTxns = abi.encodePacked(packedTxns, encodedTxn);
} else {
packedTxns = encodedTxn;
}
unchecked {
++i;
}
} while (i < len);
}
function _getGuard(address safe) internal view returns (address) {
bytes memory guardAddress = ISafeWallet(safe).getStorageAt(_GUARD_STORAGE_SLOT, 1);
return address(uint160(uint256(bytes32(guardAddress))));
}
function _getFallbackHandler(address safe) internal view returns (address) {
bytes memory fallbackHandlerAddress = ISafeWallet(safe).getStorageAt(_FALLBACK_HANDLER_STORAGE_SLOT, 1);
return address(uint160(uint256(bytes32(fallbackHandlerAddress))));
}
function _parseOperationEnum(Types.CallType callType) internal pure returns (Enum.Operation operation) {
if (callType == Types.CallType.DELEGATECALL) {
operation = Enum.Operation.DelegateCall;
} else if (callType == Types.CallType.CALL) {
operation = Enum.Operation.Call;
} else {
revert UnableToParseOperation();
}
}
}
文件 15 的 19：SignatureCheckerLib.sol
pragma solidity ^0.8.4;
library SignatureCheckerLib {
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
if eq(mload(signature), 65) {
mstore(0x00, hash)
mstore(0x20, byte(0, mload(add(signature, 0x60))))
mstore(0x40, mload(add(signature, 0x20)))
mstore(0x60, mload(add(signature, 0x40)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
mstore(0x60, 0)
mstore(0x40, m)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
let n := add(0x20, mload(signature))
pop(staticcall(gas(), 4, signature, n, add(m, 0x44), n))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(returndatasize(), 0x44),
d,
0x20
)
)
break
}
}
}
function isValidSignatureNowCalldata(address signer, bytes32 hash, bytes calldata signature)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
if eq(signature.length, 65) {
mstore(0x00, hash)
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40))))
calldatacopy(0x40, signature.offset, 0x40)
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
mstore(0x60, 0)
mstore(0x40, m)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), signature.length)
calldatacopy(add(m, 0x64), signature.offset, signature.length)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(signature.length, 0x64),
d,
0x20
)
)
break
}
}
}
function isValidSignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27))
mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs)))
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), mload(0x60))
mstore8(add(m, 0xa4), mload(0x20))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
}
function isValidSignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
assembly {
for { signer := shr(96, shl(96, signer)) } signer {} {
let m := mload(0x40)
mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
let t :=
staticcall(
gas(),
1,
0x00,
0x80,
0x01,
0x20
)
if iszero(or(iszero(returndatasize()), xor(signer, mload(t)))) {
isValid := 1
mstore(0x60, 0)
mstore(0x40, m)
break
}
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), s)
mstore8(add(m, 0xa4), v)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
mstore(0x60, 0)
mstore(0x40, m)
break
}
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes memory signature)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
let n := add(0x20, mload(signature))
pop(staticcall(gas(), 4, signature, n, add(m, 0x44), n))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(returndatasize(), 0x44),
d,
0x20
)
)
}
}
function isValidERC1271SignatureNowCalldata(
address signer,
bytes32 hash,
bytes calldata signature
) internal view returns (bool isValid) {
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), signature.length)
calldatacopy(add(m, 0x64), signature.offset, signature.length)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
add(signature.length, 0x64),
d,
0x20
)
)
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, bytes32 r, bytes32 vs)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), shr(1, shl(1, vs)))
mstore8(add(m, 0xa4), add(shr(255, vs), 27))
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
}
}
function isValidERC1271SignatureNow(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internal
view
returns (bool isValid)
{
assembly {
let m := mload(0x40)
let f := shl(224, 0x1626ba7e)
mstore(m, f)
mstore(add(m, 0x04), hash)
let d := add(m, 0x24)
mstore(d, 0x40)
mstore(add(m, 0x44), 65)
mstore(add(m, 0x64), r)
mstore(add(m, 0x84), s)
mstore8(add(m, 0xa4), v)
isValid := and(
eq(mload(d), f),
staticcall(
gas(),
signer,
m,
0xa5,
d,
0x20
)
)
}
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 result) {
assembly {
mstore(0x20, hash)
mstore(0x00, "\x00\x00\x00\x00\x19Ethereum Signed Message:\n32")
result := keccak256(0x04, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32 result) {
assembly {
let sLength := mload(s)
let o := 0x20
mstore(o, "\x19Ethereum Signed Message:\n")
mstore(0x00, 0x00)
for { let temp := sLength } 1 {} {
o := sub(o, 1)
mstore8(o, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let n := sub(0x3a, o)
returndatacopy(returndatasize(), returndatasize(), gt(n, 0x20))
mstore(s, or(mload(0x00), mload(n)))
result := keccak256(add(s, sub(0x20, n)), add(n, sLength))
mstore(s, sLength)
}
}
function emptySignature() internal pure returns (bytes calldata signature) {
assembly {
signature.length := 0
}
}
}
文件 16 的 19：TransactionValidator.sol
pragma solidity 0.8.19;
import {ISafeWallet, Enum} from "interfaces/external/ISafeWallet.sol";
import {PolicyValidator} from "src/core/PolicyValidator.sol";
import {SafeHelper} from "src/libraries/SafeHelper.sol";
import {AddressProviderService} from "src/core/AddressProviderService.sol";
import {WalletRegistry} from "src/core/registries/WalletRegistry.sol";
import {TypeHashHelper} from "src/libraries/TypeHashHelper.sol";
contract TransactionValidator is AddressProviderService {
error AccountNotFound(address);
error InvalidGuard();
error InvalidFallbackHandler();
error InvalidModule();
error InvalidExecutorPlugin();
error TxnUnAuthorized();
struct SafeTransactionParams {
Enum.Operation operation;
address from;
address to;
address payable refundReceiver;
address gasToken;
address msgSender;
uint256 value;
uint256 safeTxGas;
uint256 baseGas;
uint256 gasPrice;
bytes data;
bytes signatures;
}
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function validatePreTransactionOverridable(SafeTransactionParams memory txParams) external view {
_validatePolicySignature(
TypeHashHelper.ExecutionParams({
to: txParams.to,
value: txParams.value,
data: txParams.data,
operation: uint8(txParams.operation),
account: txParams.from,
executor: address(0),
nonce: ISafeWallet(txParams.from).nonce(),
safeTxGas: txParams.safeTxGas,
baseGas: txParams.baseGas,
gasPrice: txParams.gasPrice,
gasToken: txParams.gasToken,
refundReceiver: txParams.refundReceiver
}),
txParams.signatures
);
}
function validatePostTransactionOverridable(bytes32, bool, address )
external
view
{}
function validatePreTransaction(SafeTransactionParams memory txParams) external view {
_validatePolicySignature(
TypeHashHelper.ExecutionParams({
to: txParams.to,
value: txParams.value,
data: txParams.data,
operation: uint8(txParams.operation),
account: txParams.from,
executor: address(0),
nonce: ISafeWallet(txParams.from).nonce(),
safeTxGas: txParams.safeTxGas,
baseGas: txParams.baseGas,
gasPrice: txParams.gasPrice,
gasToken: txParams.gasToken,
refundReceiver: txParams.refundReceiver
}),
txParams.signatures
);
}
function validatePostTransaction(bytes32, bool, address subAccount) external view {
_checkSubAccountSecurityConfig(subAccount);
}
function validatePreExecutorTransaction(
address,
address from,
bytes32 executionStructHash,
bytes calldata signatures
) external view {
_validatePolicySignature(from, executionStructHash, signatures);
}
function validatePostExecutorTransaction(address, address account) external view {
if (!ISafeWallet(account).isModuleEnabled(AddressProviderService._getAuthorizedAddress(_EXECUTOR_PLUGIN_HASH)))
{
revert InvalidExecutorPlugin();
}
if (WalletRegistry(walletRegistry).isWallet(account)) {
_checkConsoleAccountSecurityConfig(account);
} else if (WalletRegistry(walletRegistry).subAccountToWallet(account) != address(0)) {
_checkSubAccountSecurityConfig(account);
} else {
revert AccountNotFound(account);
}
}
function _checkSubAccountSecurityConfig(address _subAccount) internal view {
address guard = SafeHelper._getGuard(_subAccount);
address fallbackHandler = SafeHelper._getFallbackHandler(_subAccount);
if (guard != AddressProviderService._getAuthorizedAddress(_SAFE_MODERATOR_HASH)) revert InvalidGuard();
if (fallbackHandler != AddressProviderService._getAuthorizedAddress(_CONSOLE_FALLBACK_HANDLER_HASH)) {
revert InvalidFallbackHandler();
}
address ownerConsole = WalletRegistry(walletRegistry).subAccountToWallet(_subAccount);
if (!ISafeWallet(_subAccount).isModuleEnabled(ownerConsole)) revert InvalidModule();
}
function _checkConsoleAccountSecurityConfig(address _consoleAccount) internal view {
address guard = SafeHelper._getGuard(_consoleAccount);
address fallbackHandler = SafeHelper._getFallbackHandler(_consoleAccount);
if (guard != AddressProviderService._getAuthorizedAddress(_SAFE_MODERATOR_OVERRIDABLE_HASH)) {
revert InvalidGuard();
}
if (fallbackHandler != AddressProviderService._getAuthorizedAddress(_CONSOLE_FALLBACK_HANDLER_HASH)) {
revert InvalidFallbackHandler();
}
}
function _validatePolicySignature(TypeHashHelper.ExecutionParams memory _executionParams, bytes memory _signatures)
internal
view
{
if (
!PolicyValidator(AddressProviderService._getAuthorizedAddress(_POLICY_VALIDATOR_HASH)).isPolicySignatureValid(
_executionParams, _signatures
)
) {
revert TxnUnAuthorized();
}
}
function _validatePolicySignature(address _from, bytes32 _executionStructHash, bytes memory _signatures)
internal
view
{
if (
!PolicyValidator(AddressProviderService._getAuthorizedAddress(_POLICY_VALIDATOR_HASH)).isPolicySignatureValid(
_from, _executionStructHash, _signatures
)
) {
revert TxnUnAuthorized();
}
}
}
文件 17 的 19：TypeHashHelper.sol
pragma solidity 0.8.19;
library TypeHashHelper {
struct ExecutionParams {
uint8 operation;
address to;
address account;
address executor;
address gasToken;
address refundReceiver;
uint256 value;
uint256 nonce;
uint256 safeTxGas;
uint256 baseGas;
uint256 gasPrice;
bytes data;
}
struct ValidationParams {
uint32 expiryEpoch;
bytes32 executionStructHash;
bytes32 policyHash;
}
bytes32 public constant EXECUTION_PARAMS_TYPEHASH =
0x483ad580f0a8d7881e792d04b2128f3b214b18aa7336126dc2e77a59752bd6f5;
bytes32 public constant VALIDATION_PARAMS_TYPEHASH =
0x37af4ddfcab5e0a0d11676ce89534ca59ffac1c30a5a4cc21f840d2f4704a952;
function _buildExecutionParamsHash(ExecutionParams memory txn) internal pure returns (bytes32) {
return keccak256(
abi.encode(
EXECUTION_PARAMS_TYPEHASH,
txn.operation,
txn.to,
txn.account,
txn.executor,
txn.gasToken,
txn.refundReceiver,
txn.value,
txn.nonce,
txn.safeTxGas,
txn.baseGas,
txn.gasPrice,
keccak256(txn.data)
)
);
}
function _buildValidationParamsHash(ValidationParams memory validation) internal pure returns (bytes32) {
return keccak256(
abi.encode(
VALIDATION_PARAMS_TYPEHASH,
validation.expiryEpoch,
validation.executionStructHash,
validation.policyHash
)
);
}
}
文件 18 的 19：Types.sol
pragma solidity 0.8.19;
interface Types {
enum CallType {
CALL,
DELEGATECALL,
STATICCALL
}
struct Executable {
CallType callType;
address target;
uint256 value;
bytes data;
}
struct TokenRequest {
address token;
uint256 amount;
}
}
文件 19 的 19：WalletRegistry.sol
pragma solidity 0.8.19;
import {AddressProviderService} from "../AddressProviderService.sol";
contract WalletRegistry is AddressProviderService {
error AlreadyRegistered();
error InvalidSender();
error IsSubAccount();
event RegisterWallet(address indexed wallet);
event RegisterSubAccount(address indexed wallet, address indexed subAccount);
mapping(address subAccount => address wallet) public subAccountToWallet;
mapping(address wallet => address[] subAccountList) public walletToSubAccountList;
mapping(address => bool) public isWallet;
constructor(address _addressProvider) AddressProviderService(_addressProvider) {}
function registerWallet() external {
if (isWallet[msg.sender]) revert AlreadyRegistered();
if (subAccountToWallet[msg.sender] != address(0)) revert IsSubAccount();
isWallet[msg.sender] = true;
emit RegisterWallet(msg.sender);
}
function registerSubAccount(address _wallet, address _subAccount) external {
if (msg.sender != AddressProviderService._getAuthorizedAddress(_SAFE_DEPLOYER_HASH)) revert InvalidSender();
if (subAccountToWallet[_subAccount] != address(0) || isWallet[_subAccount]) revert AlreadyRegistered();
subAccountToWallet[_subAccount] = _wallet;
walletToSubAccountList[_wallet].push(_subAccount);
emit RegisterSubAccount(_wallet, _subAccount);
}
function getSubAccountsForWallet(address _wallet) external view returns (address[] memory) {
return walletToSubAccountList[_wallet];
}
}
{
"compilationTarget": {
"src/core/ExecutorPlugin.sol": "ExecutorPlugin"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 20000
},
"remappings": [
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/",
":safe-contracts/=lib/safe-contracts/contracts/",
":solady/=lib/solady/src/",
":solidity-bytes-utils/=lib/solidity-bytes-utils/contracts/",
":solmate/=lib/solady/lib/solmate/src/"
]
}[{"inputs":[{"internalType":"address","name":"_addressProvider","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidAddressProvider","type":"error"},{"inputs":[],"name":"InvalidExecutor","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"ModuleExecutionFailed","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"NotGovernance","type":"error"},{"inputs":[],"name":"UnableToParseOperation","type":"error"},{"inputs":[],"name":"addressProvider","outputs":[{"internalType":"contract AddressProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"addressProviderTarget","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"enum Types.CallType","name":"callType","type":"uint8"},{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Types.Executable","name":"exec","type":"tuple"},{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"executor","type":"address"},{"internalType":"bytes","name":"executorSignature","type":"bytes"},{"internalType":"bytes","name":"validatorSignature","type":"bytes"}],"internalType":"struct ExecutorPlugin.ExecutionRequest","name":"execRequest","type":"tuple"}],"name":"executeTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"executor","type":"address"}],"name":"executorNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"executorRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"policyRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"walletRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
