Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {IAccount, ACCOUNT_VALIDATION_SUCCESS_MAGIC} from '@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IAccount.sol';
import {Transaction, TransactionHelper} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol';
import {EfficientCall} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/EfficientCall.sol';
import {BOOTLOADER_FORMAL_ADDRESS, NONCE_HOLDER_SYSTEM_CONTRACT, DEPLOYER_SYSTEM_CONTRACT, INonceHolder} from '@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol';
import {SystemContractsCaller} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol';
import {SystemContractHelper} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractHelper.sol';
import {Utils} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/Utils.sol';
import {Initializable} from '@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol';

import {HookManager} from './managers/HookManager.sol';
import {ModuleManager} from './managers/ModuleManager.sol';
import {UpgradeManager} from './managers/UpgradeManager.sol';

import {TokenCallbackHandler, IERC165} from './helpers/TokenCallbackHandler.sol';

import {Errors} from './libraries/Errors.sol';
import {SignatureDecoder} from './libraries/SignatureDecoder.sol';

import {ERC1271Handler} from './handlers/ERC1271Handler.sol';
import {Call} from './batch/BatchCaller.sol';

import {IAGWAccount} from './interfaces/IAGWAccount.sol';
import {OperationType} from './interfaces/IValidator.sol';
import {AccountFactory} from './AccountFactory.sol';
import {BatchCaller} from './batch/BatchCaller.sol';

/**
 * @title Main account contract for the Abstract Global Wallet infrastructure
 * @dev Forked from Clave for Abstract
 * @dev The Abstract fork uses a K1 signer and validator initially
 * @author https://getclave.io
 * @author https://abs.xyz
 */
contract AGWAccount is
    Initializable,
    UpgradeManager,
    HookManager,
    ModuleManager,
    ERC1271Handler,
    TokenCallbackHandler,
    BatchCaller,
    IAGWAccount
{
    // Helper library for the Transaction struct
    using TransactionHelper for Transaction;

    uint256 public constant VERSION = 1;

    address public immutable KNOWN_TRUSTED_EOA_VALIDATOR;

    /**
     * @notice Constructor for the account implementation
     */
    constructor(address knownTrustedEoaValidator) {
        KNOWN_TRUSTED_EOA_VALIDATOR = knownTrustedEoaValidator;
        _disableInitializers();
    }

    /**
     * @notice Initializer function for the account contract
     * @param initialK1Owner bytes address - The initial k1 owner of the account
     * @param initialK1Validator address    - The initial k1 validator of the account
     * @param modules bytes[] calldata      - The list of modules to enable for the account
     * @param initCall Call calldata         - The initial call to be executed after the account is created
     */
    function initialize(
        address initialK1Owner,
        address initialK1Validator,
        bytes[] calldata modules,
        Call calldata initCall
    ) public payable initializer {
        __ERC1271Handler_init();
        // check that this account is being deployed by the initial signer or the factory authorized deployer
        AccountFactory factory = AccountFactory(msg.sender);
        // require a specific salt for the acccount based on the initial k1 owner
        address expectedAddress = factory.getAddressForSalt(keccak256(abi.encodePacked(initialK1Owner)));
        if (address(this) != expectedAddress) {
            revert Errors.INVALID_SALT();
        }

        // add the initial k1 owner as an owner
        _k1AddOwner(initialK1Owner);

        address thisDeployer = factory.accountToDeployer(address(this));
        if (!factory.authorizedDeployers(thisDeployer)) {
            if (initialK1Owner != thisDeployer) {
                // disregard any modules and initial call as the deployer is untrusted
                _k1AddValidator(KNOWN_TRUSTED_EOA_VALIDATOR);
                return;
            }
        }

        _k1AddValidator(initialK1Validator);

        for (uint256 i = 0; i < modules.length; ) {
            _addModule(modules[i]);
            unchecked {
                i++;
            }
        }

        if (initCall.target != address(0)) {
            uint128 value = Utils.safeCastToU128(initCall.value);
            _executeCall(initCall.target, value, initCall.callData, initCall.allowFailure);
        }
    }

    // Receive function to allow ETH to be sent to the account
    // with no additional calldata
    receive() external payable {}
    
    // Fallback function to allow ETH to be sent to the account
    // with arbitrary calldata to mirror the behavior of an EOA
    fallback() external payable {
        // Simulate the behavior of the EOA if it is called via `delegatecall`.
        address codeAddress = SystemContractHelper.getCodeAddress();
        if (codeAddress != address(this)) {
            // If the function was delegate called, behave like an EOA.
            assembly {
                return(0, 0)
            }
        }

        // fallback of default account shouldn't be called by bootloader under any circumstances
        assert(msg.sender != BOOTLOADER_FORMAL_ADDRESS);

        // If the contract is called directly, behave like an EOA
    }

    /**
     * @notice Called by the bootloader to validate that an account agrees to process the transaction
     * (and potentially pay for it).
     * @dev The developer should strive to preserve as many steps as possible both for valid
     * and invalid transactions as this very method is also used during the gas fee estimation
     * (without some of the necessary data, e.g. signature).
     * @param - bytes32                        - Not used
     * @param suggestedSignedHash bytes32      - The suggested hash of the transaction that is signed by the signer
     * @param transaction Transaction calldata - The transaction itself
     * @return magic bytes4 - The magic value that should be equal to the signature of this function
     * if the user agrees to proceed with the transaction.
     */
    function validateTransaction(
        bytes32,
        bytes32 suggestedSignedHash,
        Transaction calldata transaction
    ) external payable override onlyBootloader returns (bytes4 magic) {
        _incrementNonce(transaction.nonce);

        // The fact there is enough balance for the account
        // should be checked explicitly to prevent user paying for fee for a
        // transaction that wouldn't be included on Ethereum.
        if (transaction.totalRequiredBalance() > address(this).balance) {
            revert Errors.INSUFFICIENT_FUNDS();
        }

        // While the suggested signed hash is usually provided, it is generally
        // not recommended to rely on it to be present, since in the future
        // there may be tx types with no suggested signed hash.
        bytes32 signedHash = suggestedSignedHash == bytes32(0)
            ? transaction.encodeHash()
            : suggestedSignedHash;

        magic = _validateTransaction(signedHash, transaction);
    }

    /**
     * @notice Called by the bootloader to make the account execute the transaction.
     * @dev The transaction is considered successful if this function does not revert
     * @param - bytes32                        - Not used
     * @param - bytes32                        - Not used
     * @param transaction Transaction calldata - The transaction itself
     */
    function executeTransaction(
        bytes32,
        bytes32,
        Transaction calldata transaction
    ) external payable override onlyBootloader {
        _executeTransaction(transaction);
    }

    /**
     * @notice This function allows an EOA to start a transaction for the account.
     * @dev There is no point in providing possible signed hash in the `executeTransactionFromOutside` method,
     * since it typically should not be trusted.
     * @param transaction Transaction calldata - The transaction itself
     */
    function executeTransactionFromOutside(
        Transaction calldata transaction
    ) external payable override {
        // Check if msg.sender is authorized
        if (!_k1IsOwner(msg.sender)) {
            revert Errors.UNAUTHORIZED_OUTSIDE_TRANSACTION();
        }

        // Extract hook data from transaction.signature
        bytes[] memory hookData = SignatureDecoder.decodeSignatureOnlyHookData(
            transaction.signature
        );

        // Get the hash of the transaction
        bytes32 signedHash = transaction.encodeHash();

        // Run the validation hooks
        if (!runValidationHooks(signedHash, transaction, hookData)) {
            revert Errors.VALIDATION_HOOK_FAILED();
        }

        _incrementNonce(transaction.nonce);
        _executeTransaction(transaction);
    }

    /**
     * @notice This function allows the account to pay for its own gas and used when there is no paymaster
     * @param - bytes32                        - not used
     * @param - bytes32                        - not used
     * @param transaction Transaction calldata - Transaction to pay for
     * @dev "This method must send at least `tx.gasprice * tx.gasLimit` ETH to the bootloader address."
     */
    function payForTransaction(
        bytes32,
        bytes32,
        Transaction calldata transaction
    ) external payable override onlyBootloader {
        bool success = transaction.payToTheBootloader();

        if (!success) {
            revert Errors.FEE_PAYMENT_FAILED();
        }

        emit FeePaid();
    }

    /**
     * @notice This function is called by the system if the transaction has a paymaster
        and prepares the interaction with the paymaster
     * @param - bytes32               - not used 
     * @param - bytes32               - not used 
     * @param transaction Transaction - The transaction itself
     */
    function prepareForPaymaster(
        bytes32,
        bytes32,
        Transaction calldata transaction
    ) external payable override onlyBootloader {
        transaction.processPaymasterInput();
    }

    /// @dev type(IAGWAccount).interfaceId indicates AGW accounts
    function supportsInterface(
        bytes4 interfaceId
    ) public view override(IERC165, TokenCallbackHandler) returns (bool) {
        return
            interfaceId == type(IAGWAccount).interfaceId || super.supportsInterface(interfaceId);
    }

    function _validateTransaction(
        bytes32 signedHash,
        Transaction calldata transaction
    ) internal returns (bytes4 magicValue) {
        if (transaction.signature.length == 65) {
            // This is a gas estimation
            return bytes4(0);
        }
        
        // Extract the signature, validator address and hook data from the transaction.signature
        (bytes memory signature, address validator, bytes[] memory hookData) = SignatureDecoder
            .decodeSignature(transaction.signature);

        // Run validation hooks
        bool hookSuccess = runValidationHooks(signedHash, transaction, hookData);

        // Handle validation
        bool valid = _handleValidation(validator, OperationType.Transaction, signedHash, signature);

        magicValue = (hookSuccess && valid) ? ACCOUNT_VALIDATION_SUCCESS_MAGIC : bytes4(0);
    }

    function _executeTransaction(
        Transaction calldata transaction
    ) internal runExecutionHooks(transaction) {
        address to = _safeCastToAddress(transaction.to);
        uint128 value = Utils.safeCastToU128(transaction.value);
        bytes calldata data = transaction.data;

        _executeCall(to, value, data, false);
    }

    function _executeCall(
        address to,
        uint128 value,
        bytes calldata data,
        bool allowFailure
    ) internal {
        uint32 gas = Utils.safeCastToU32(gasleft());

        if (to == address(DEPLOYER_SYSTEM_CONTRACT)) {
            // Note, that the deployer contract can only be called
            // with a "systemCall" flag.
            (bool success, bytes memory returnData) = SystemContractsCaller
                .systemCallWithReturndata(gas, to, value, data);
            if (!success && !allowFailure) {
                assembly {
                    let size := mload(returnData)
                    revert(add(returnData, 0x20), size)
                }
            }
        } else {
            bool success = EfficientCall.rawCall(gas, to, value, data, false);
            if (!success && !allowFailure) {
                EfficientCall.propagateRevert();
            }
        }
    }

    function _incrementNonce(uint256 nonce) internal {
        SystemContractsCaller.systemCallWithPropagatedRevert(
            uint32(gasleft()),
            address(NONCE_HOLDER_SYSTEM_CONTRACT),
            0,
            abi.encodeCall(INonceHolder.incrementMinNonceIfEquals, (nonce))
        );
    }

    function _safeCastToAddress(uint256 value) internal pure returns (address) {
        if (value > type(uint160).max) revert();
        return address(uint160(value));
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {DEPLOYER_SYSTEM_CONTRACT, IContractDeployer} from '@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol';
import {SystemContractsCaller} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol';
import {Ownable, Ownable2Step} from '@openzeppelin/contracts/access/Ownable2Step.sol';
import {EfficientCall} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/EfficientCall.sol';
import {Errors} from './libraries/Errors.sol';
import {IAGWRegistry} from './interfaces/IAGWRegistry.sol';

/**
 * @title Factory contract to create AGW accounts
 * @dev Forked from Clave for Abstract
 * @author https://abs.xyz
 * @author https://getclave.io
 */
contract AccountFactory is Ownable2Step {
    
    /**
     * @notice Address of the account implementation
     */
    address public implementationAddress;
    /**
     * @notice Allowed selector for account initialization
     */
    bytes4 public initializerSelector;

    /**
     * @notice Account registry contract address
     */
    address public registry;

    /**
     * @notice Account creation bytecode hash
     */
    bytes32 public proxyBytecodeHash;
    
    /**
     * @notice Authorized deployers of AGW accounts
     */
    mapping (address deployer => bool authorized) public authorizedDeployers;
    
    /**
     * @notice Tracks the initial deployer of each account
     */
    mapping (address account => address deployer) public accountToDeployer;
    
    /**
     * @notice Account address deployed for a given salt the same account
     * @dev This is used to override the deterministic account address if the account is already deployed
     *      and the initial implementation has been changed
     */
    mapping (bytes32 salt => address accountAddress) public saltToAccount;

    /**
     * @notice Event emmited when a new AGW account is created
     * @param accountAddress Address of the newly created AGW account
     */
    event AGWAccountCreated(address indexed accountAddress);

    /**
     * @notice Event emmited when a new AGW account is deployed
     * @param accountAddress Address of the newly deployed AGW account
     */
    event AGWAccountDeployed(address indexed accountAddress);

    /**
     * @notice Event emmited when a deployer account is authorized
     * @param deployer Address of the deployer account
     * @param authorized Whether the deployer is authorized to deploy AGW accounts
     */
    event DeployerAuthorized(address indexed deployer, bool indexed authorized);

    /**
     * @notice Event emmited when the implementation contract is changed
     * @param newImplementation Address of the new implementation contract
     */
    event ImplementationChanged(address indexed newImplementation);

    /**
     * @notice Event emmited when the registry contract is changed
     * @param newRegistry Address of the new registry contract
     */
    event RegistryChanged(address indexed newRegistry);

    /**
     * @notice Constructor function of the factory contract
     * @param _implementation address     - Address of the implementation contract
     * @param _registry address           - Address of the registry contract
     * @param _proxyBytecodeHash address - Hash of the bytecode of the AGW proxy contract
     * @param _deployer address           - Address of the account authorized to deploy AGW accounts
     */
    constructor(
        address _implementation,
        bytes4 _initializerSelector,
        address _registry,
        bytes32 _proxyBytecodeHash,
        address _deployer,
        address _owner
    ) Ownable(_owner) {
        implementationAddress = _implementation;
        emit ImplementationChanged(_implementation);
        initializerSelector = _initializerSelector;
        registry = _registry;
        proxyBytecodeHash = _proxyBytecodeHash;
        authorizedDeployers[_deployer] = true;
        emit DeployerAuthorized(_deployer, true);
    }

    /**
     * @notice Deploys a new AGW account
     * @dev Account address depends only on salt
     * @param salt bytes32             - Salt to be used for the account creation
     * @param initializer bytes memory - Initializer data for the account
     * @return accountAddress address - Address of the newly created AGW account
     */
    function deployAccount(
        bytes32 salt,
        bytes calldata initializer
    ) external payable returns (address accountAddress) {
        if (saltToAccount[salt] != address(0)) {
            revert Errors.ALREADY_CREATED();
        }
        // Check that the initializer is not empty
        if (initializer.length < 4) {
            revert Errors.INVALID_INITIALIZER();
        }
        // Check that the initializer selector is correct
        {
            bytes4 selector = bytes4(initializer[0:4]);
            if (selector != initializerSelector) {
                revert Errors.INVALID_INITIALIZER();
            }
        }
        // Deploy the implementation contract
        (bool success, bytes memory returnData) = SystemContractsCaller.systemCallWithReturndata(
            uint32(gasleft()),
            address(DEPLOYER_SYSTEM_CONTRACT),
            uint128(0),
            abi.encodeCall(
                DEPLOYER_SYSTEM_CONTRACT.create2Account,
                (
                    salt,
                    proxyBytecodeHash,
                    abi.encode(implementationAddress),
                    IContractDeployer.AccountAbstractionVersion.Version1
                )
            )
        );

        if (!success) {
            revert Errors.DEPLOYMENT_FAILED();
        }

        // Decode the account address
        (accountAddress) = abi.decode(returnData, (address));
        // Store the deployer of the account
        accountToDeployer[accountAddress] = msg.sender;
        saltToAccount[salt] = accountAddress;
        
        // This propagates the revert if the initialization fails
        EfficientCall.call(gasleft(), accountAddress, msg.value, initializer, false);

        IAGWRegistry(registry).register(accountAddress);

        emit AGWAccountDeployed(accountAddress);
    }

    /**
     * @notice To emit an event when a AGW account is created but not yet deployed
     * @dev This event is so that we can index accounts that are created but not yet deployed
     * @param accountAddress address - Address of the AGW account that was created
     */
    function agwAccountCreated(address accountAddress) external {
        if (!authorizedDeployers[msg.sender]) {
            revert Errors.NOT_FROM_DEPLOYER();
        }
        emit AGWAccountCreated(accountAddress);
    }

    /**
     * @notice Sets authorization to deploy AGW accounts
     * @param deployer address - Address of the new account authorized to deploy AGW accounts
     * @param authorized bool - Whether the new deployer is authorized to deploy AGW accounts
     */
    function setDeployer(address deployer, bool authorized) external onlyOwner {
        authorizedDeployers[deployer] = authorized;

        emit DeployerAuthorized(deployer, authorized);
    }

    /**
     * @notice Changes the implementation contract address
     * @param newImplementation address - Address of the new implementation contract
     */
    function changeImplementation(address newImplementation, bytes4 newInitializerSelector) external onlyOwner {
        implementationAddress = newImplementation;
        initializerSelector = newInitializerSelector;

        emit ImplementationChanged(newImplementation);
    }

    /**
     * @notice Changes the registry contract address
     * @param newRegistry address - Address of the new registry contract
     */
    function changeRegistry(address newRegistry) external onlyOwner {
        registry = newRegistry;

        emit RegistryChanged(newRegistry);
    }

    /**
     * @notice Returns the address of the AGW account that would be created with the given salt
     * @dev If the account already exists, it returns the existing account address
     * @param salt bytes32 - Salt to be used for the account creation
     * @return accountAddress address - Address of the AGW account that would be created with the given salt
     */
    function getAddressForSalt(bytes32 salt) external view returns (address accountAddress) {
        // Check if the account is already deployed
        accountAddress = saltToAccount[salt];
        if (accountAddress == address(0)) {
            // If not, get the deterministic account address for the current implementation
            accountAddress = IContractDeployer(DEPLOYER_SYSTEM_CONTRACT).getNewAddressCreate2(
                address(this),
                proxyBytecodeHash,
                salt,
                abi.encode(implementationAddress)
            );
        }
    }

    /**
     * @notice Returns the address of the AGW account that would be created with the given salt and implementation
     * @param salt bytes32 - Salt to be used for the account creation
     * @param _implementation address - Address of the implementation contract
     * @return accountAddress address - Address of the AGW account that would be created with the given salt and implementation
     */
    function getAddressForSaltAndImplementation(
        bytes32 salt,
        address _implementation
    ) external view returns (address accountAddress) {
        accountAddress = IContractDeployer(DEPLOYER_SYSTEM_CONTRACT).getNewAddressCreate2(
            address(this),
            proxyBytecodeHash,
            salt,
            abi.encode(_implementation)
        );
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {ERC165Checker} from '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol';
import {ExcessivelySafeCall} from '@nomad-xyz/excessively-safe-call/src/ExcessivelySafeCall.sol';

import {AGWStorage} from '../libraries/AGWStorage.sol';
import {Auth} from '../auth/Auth.sol';
import {AddressLinkedList} from '../libraries/LinkedList.sol';
import {Errors} from '../libraries/Errors.sol';
import {IModule} from '../interfaces/IModule.sol';
import {IInitable} from '../interfaces/IInitable.sol';
import {IAGWAccount} from '../interfaces/IAGWAccount.sol';
import {IModuleManager} from '../interfaces/IModuleManager.sol';

/**
 * @title Manager contract for modules
 * @notice Abstract contract for managing the enabled modules of the account
 * @dev Module addresses are stored in a linked list
 * @author https://getclave.io
 */
abstract contract ModuleManager is IModuleManager, Auth {
    // Helper library for address to address mappings
    using AddressLinkedList for mapping(address => address);
    // Interface helper library
    using ERC165Checker for address;
    // Low level calls helper library
    using ExcessivelySafeCall for address;

    /// @inheritdoc IModuleManager
    function addModule(bytes calldata moduleAndData) external override onlySelfOrModule {
        _addModule(moduleAndData);
    }

    /// @inheritdoc IModuleManager
    function removeModule(address module) external override onlySelfOrModule {
        _removeModule(module);
    }

    /// @inheritdoc IModuleManager
    function executeFromModule(
        address to,
        uint256 value,
        bytes memory data
    ) external override onlyModule {
        if (to == address(this)) revert Errors.RECUSIVE_MODULE_CALL();

        assembly {
            let result := call(gas(), to, value, add(data, 0x20), mload(data), 0, 0)
            if iszero(result) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }
        }
    }

    /// @inheritdoc IModuleManager
    function isModule(address addr) external view override returns (bool) {
        return _isModule(addr);
    }

    /// @inheritdoc IModuleManager
    function listModules() external view override returns (address[] memory moduleList) {
        moduleList = _modulesLinkedList().list();
    }

    function _addModule(bytes calldata moduleAndData) internal {
        if (moduleAndData.length < 20) {
            revert Errors.EMPTY_MODULE_ADDRESS();
        }

        address moduleAddress = address(bytes20(moduleAndData[0:20]));
        bytes calldata initData = moduleAndData[20:];

        if (!_supportsModule(moduleAddress)) {
            revert Errors.MODULE_ERC165_FAIL();
        }

        _modulesLinkedList().add(moduleAddress);

        IModule(moduleAddress).init(initData);

        emit AddModule(moduleAddress);
    }

    function _removeModule(address module) internal {

        (bool success, ) = module.excessivelySafeCall(
            gasleft(),
            0,
            0,
            abi.encodeWithSelector(IInitable.disable.selector)
        );
        (success); // silence unused local variable warning

        _modulesLinkedList().remove(module);

        emit RemoveModule(module);
    }

    function _isModule(address addr) internal view override returns (bool) {
        return _modulesLinkedList().exists(addr);
    }

    function _modulesLinkedList()
        private
        view
        returns (mapping(address => address) storage modules)
    {
        modules = AGWStorage.layout().modules;
    }

    function _supportsModule(address module) internal view returns (bool) {
        return module.supportsInterface(type(IModule).interfaceId);
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;
import '@openzeppelin/contracts/utils/introspection/IERC165.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol';

/**
 * Token callback handler.
 *   Handles supported tokens' callbacks, allowing account receiving these tokens.
 */
contract TokenCallbackHandler is IERC721Receiver, IERC1155Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    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;
    }

    /// @dev functon visibility changed to public to allow overriding
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return
            interfaceId == type(IERC721Receiver).interfaceId ||
            interfaceId == type(IERC1155Receiver).interfaceId ||
            interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {IERC1271} from '@openzeppelin/contracts/interfaces/IERC1271.sol';

import {SignatureDecoder} from '../libraries/SignatureDecoder.sol';
import {ValidationHandler} from './ValidationHandler.sol';
import {EIP712Upgradeable} from '@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol';
import {OperationType} from '../interfaces/IValidator.sol';

/**
 * @title ERC1271Handler
 * @notice Contract which provides ERC1271 signature validation
 * @dev Forked from Clave for Abstract
 * @author https://getclave.io
 * @author https://abs.xyz
 */
abstract contract ERC1271Handler is
    IERC1271,
    EIP712Upgradeable,
    ValidationHandler
{
    struct AGWMessage {
        bytes32 signedHash;
    }

    bytes32 constant _AGW_MESSAGE_TYPEHASH = keccak256('AGWMessage(bytes32 signedHash)');

    bytes4 private constant _ERC1271_MAGIC = 0x1626ba7e;

    function __ERC1271Handler_init() internal onlyInitializing {
        __EIP712_init('AbstractGlobalWallet', '1.0.0');
    }

    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param signedHash bytes32                   - Hash of the data that is signed
     * @param signatureAndValidator bytes calldata - Validator address concatenated to signature
     * @return magicValue bytes4 - Magic value if the signature is valid, 0 otherwise
     */
    function isValidSignature(
        bytes32 signedHash,
        bytes memory signatureAndValidator
    ) public view override returns (bytes4 magicValue) {
        (bytes memory signature, address validator) = SignatureDecoder.decodeSignatureNoHookData(
            signatureAndValidator
        );

        bytes32 eip712Hash = _hashTypedDataV4(_agwMessageHash(AGWMessage(signedHash)));

        bool valid = _handleValidation(validator, OperationType.Signature, eip712Hash, signature);

        magicValue = valid ? _ERC1271_MAGIC : bytes4(0);
    }

    /**
     * @notice Returns the EIP-712 hash of the AGW message
     * @param agwMessage AGWMessage calldata - The message containing signedHash
     * @return bytes32 - EIP712 hash of the message
     */
    function getEip712Hash(AGWMessage calldata agwMessage) external view returns (bytes32) {
        return _hashTypedDataV4(_agwMessageHash(agwMessage));
    }

    /**
     * @notice Returns the typehash for the AGW message struct
     * @return bytes32 - AGW message typehash
     */
    function agwMessageTypeHash() external pure returns (bytes32) {
        return _AGW_MESSAGE_TYPEHASH;
    }

    function _agwMessageHash(AGWMessage memory agwMessage) internal pure returns (bytes32) {
        return keccak256(abi.encode(_AGW_MESSAGE_TYPEHASH, agwMessage.signedHash));
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';
import {Auth} from '../auth/Auth.sol';

import {IUpgradeManager} from '../interfaces/IUpgradeManager.sol';

/**
 * @title Upgrade Manager
 * @notice Abstract contract for managing the upgrade process of the account
 * @author https://getclave.io
 */
abstract contract UpgradeManager is IUpgradeManager, Auth {
    // keccak-256 of "eip1967.proxy.implementation" subtracted by 1
    bytes32 private constant _IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /// @inheritdoc IUpgradeManager
    function upgradeTo(address newImplementation) external override onlySelf {
        address oldImplementation;
        assembly {
            oldImplementation := and(
                sload(_IMPLEMENTATION_SLOT),
                0xffffffffffffffffffffffffffffffffffffffff
            )
        }
        if (oldImplementation == newImplementation) {
            revert Errors.SAME_IMPLEMENTATION();
        }
        assembly {
            sstore(_IMPLEMENTATION_SLOT, newImplementation)
        }

        emit Upgraded(oldImplementation, newImplementation);
    }

    /// @inheritdoc IUpgradeManager
    function implementationAddress() external view override returns (address) {
        address impl;
        assembly {
            impl := and(sload(_IMPLEMENTATION_SLOT), 0xffffffffffffffffffffffffffffffffffffffff)
        }

        return impl;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';

library SignatureDecoder {
    // Decode transaction.signature into signature, validator and hook data
    function decodeSignature(
        bytes calldata txSignature
    ) internal pure returns (bytes memory signature, address validator, bytes[] memory hookData) {
        (signature, validator, hookData) = abi.decode(txSignature, (bytes, address, bytes[]));
    }

    // Decode transaction.signature into hook data
    function decodeSignatureOnlyHookData(
        bytes calldata txSignature
    ) internal pure returns (bytes[] memory hookData) {
        (hookData) = abi.decode(txSignature, (bytes[]));
    }

    // Decode signature into signature and validator
    function decodeSignatureNoHookData(
        bytes memory signatureAndValidator
    ) internal pure returns (bytes memory signature, address validator) {
        (signature, validator) = abi.decode(signatureAndValidator, (bytes, address));
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {ERC165Checker} from '@openzeppelin/contracts/utils/introspection/ERC165Checker.sol';
import {Transaction} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol';
import {ExcessivelySafeCall} from '@nomad-xyz/excessively-safe-call/src/ExcessivelySafeCall.sol';

import {Auth} from '../auth/Auth.sol';
import {AGWStorage} from '../libraries/AGWStorage.sol';
import {AddressLinkedList} from '../libraries/LinkedList.sol';
import {Errors} from '../libraries/Errors.sol';
import {IExecutionHook, IValidationHook} from '../interfaces/IHook.sol';
import {IInitable} from '../interfaces/IInitable.sol';
import {IHookManager} from '../interfaces/IHookManager.sol';

/**
 * @title Manager contract for hooks
 * @notice Abstract contract for managing the enabled hooks of the account
 * @dev Hook addresses are stored in a linked list
 * @author https://getclave.io
 */
abstract contract HookManager is IHookManager, Auth {
    // Helper library for address to address mappings
    using AddressLinkedList for mapping(address => address);
    // Interface helper library
    using ERC165Checker for address;
    // Low level calls helper library
    using ExcessivelySafeCall for address;

    // Slot for execution hooks to store context
    bytes32 private constant CONTEXT_KEY = keccak256('HookManager.context');

    /// @inheritdoc IHookManager
    function addHook(
        bytes calldata hookAndData,
        bool isValidation
    ) external override onlySelfOrModule {
        _addHook(hookAndData, isValidation);
    }

    /// @inheritdoc IHookManager
    function removeHook(address hook, bool isValidation) external override onlySelfOrModule {
        _removeHook(hook, isValidation);
    }

    /// @inheritdoc IHookManager
    function setHookData(bytes32 key, bytes calldata data) external override onlyHook {
        if (key == CONTEXT_KEY) {
            revert Errors.INVALID_KEY();
        }

        _hookDataStore()[msg.sender][key] = data;
    }

    /// @inheritdoc IHookManager
    function getHookData(address hook, bytes32 key) external view override returns (bytes memory) {
        return _hookDataStore()[hook][key];
    }

    /// @inheritdoc IHookManager
    function isHook(address addr) external view override returns (bool) {
        return _isHook(addr);
    }

    /// @inheritdoc IHookManager
    function listHooks(
        bool isValidation
    ) external view override returns (address[] memory hookList) {
        if (isValidation) {
            hookList = _validationHooksLinkedList().list();
        } else {
            hookList = _executionHooksLinkedList().list();
        }
    }

    // Runs the validation hooks that are enabled by the account and returns true if none reverts
    function runValidationHooks(
        bytes32 signedHash,
        Transaction calldata transaction,
        bytes[] memory hookData
    ) internal returns (bool) {
        mapping(address => address) storage validationHooks = _validationHooksLinkedList();

        address cursor = validationHooks[AddressLinkedList.SENTINEL_ADDRESS];
        uint256 idx = 0;
        // Iterate through hooks
        while (cursor > AddressLinkedList.SENTINEL_ADDRESS) {
            // hookData array is out of bounds for the number of hooks
            if (idx >= hookData.length) {
                return false;
            }

            // Call it with corresponding hookData
            bool success = _call(
                cursor,
                abi.encodeWithSelector(
                    IValidationHook.validationHook.selector,
                    signedHash,
                    transaction,
                    hookData[idx++]
                )
            );

            if (!success) {
                return false;
            }

            cursor = validationHooks[cursor];
        }

        // Ensure that hookData is not tampered with
        if (hookData.length != idx) return false;

        return true;
    }

    // Runs the execution hooks that are enabled by the account before and after _executeTransaction
    modifier runExecutionHooks(Transaction calldata transaction) {
        mapping(address => address) storage executionHooks = _executionHooksLinkedList();

        address cursor = executionHooks[AddressLinkedList.SENTINEL_ADDRESS];
        // Iterate through hooks
        while (cursor > AddressLinkedList.SENTINEL_ADDRESS) {
            // Call the preExecutionHook function with transaction struct
            bytes memory context = IExecutionHook(cursor).preExecutionHook(transaction);
            // Store returned data as context
            _setContext(cursor, context);

            cursor = executionHooks[cursor];
        }

        _;

        cursor = executionHooks[AddressLinkedList.SENTINEL_ADDRESS];
        // Iterate through hooks
        while (cursor > AddressLinkedList.SENTINEL_ADDRESS) {
            bytes memory context = _getContext(cursor);
            if (context.length > 0) {
                // Call the postExecutionHook function with stored context
                IExecutionHook(cursor).postExecutionHook(context);
                // Delete context
                _deleteContext(cursor);
            }

            cursor = executionHooks[cursor];
        }
    }

    function _addHook(bytes calldata hookAndData, bool isValidation) internal {
        if (hookAndData.length < 20) {
            revert Errors.EMPTY_HOOK_ADDRESS();
        }

        address hookAddress = address(bytes20(hookAndData[0:20]));

        if (!_supportsHook(hookAddress, isValidation)) {
            revert Errors.HOOK_ERC165_FAIL();
        }

        bytes calldata initData = hookAndData[20:];

        if (isValidation) {
            _validationHooksLinkedList().add(hookAddress);
        } else {
            _executionHooksLinkedList().add(hookAddress);
        }

        IInitable(hookAddress).init(initData);

        emit AddHook(hookAddress);
    }

    function _removeHook(address hook, bool isValidation) internal {
        if (isValidation) {
            _validationHooksLinkedList().remove(hook);
        } else {
            _executionHooksLinkedList().remove(hook);
        }
        
        // if the hook removal occured during execution of hooks, the hook 
        // context will not be cleaned up during post execution so we need
        // to delete it manually
        _deleteContext(hook);

        (bool success, ) = hook.excessivelySafeCall(
            gasleft(),
            0,
            0,
            abi.encodeWithSelector(IInitable.disable.selector)
        );
        (success); // silence unused local variable warning

        emit RemoveHook(hook);
    }

    function _isHook(address addr) internal view override returns (bool) {
        return
            _validationHooksLinkedList().exists(addr) || _executionHooksLinkedList().exists(addr);
    }

    function _setContext(address hook, bytes memory context) private {
        _hookDataStore()[hook][CONTEXT_KEY] = context;
    }

    function _deleteContext(address hook) private {
        delete _hookDataStore()[hook][CONTEXT_KEY];
    }

    function _getContext(address hook) private view returns (bytes memory context) {
        context = _hookDataStore()[hook][CONTEXT_KEY];
    }

    function _call(address target, bytes memory data) private returns (bool success) {
        assembly ('memory-safe') {
            success := call(gas(), target, 0, add(data, 0x20), mload(data), 0, 0)
        }
    }

    function _validationHooksLinkedList()
        private
        view
        returns (mapping(address => address) storage validationHooks)
    {
        validationHooks = AGWStorage.layout().validationHooks;
    }

    function _executionHooksLinkedList()
        private
        view
        returns (mapping(address => address) storage executionHooks)
    {
        executionHooks = AGWStorage.layout().executionHooks;
    }

    function _hookDataStore()
        private
        view
        returns (mapping(address => mapping(bytes32 => bytes)) storage hookDataStore)
    {
        hookDataStore = AGWStorage.layout().hookDataStore;
    }

    function _supportsHook(address hook, bool isValidation) internal view returns (bool) {
        return
            isValidation
                ? hook.supportsInterface(type(IValidationHook).interfaceId)
                : hook.supportsInterface(type(IExecutionHook).interfaceId);
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

library Errors {
    /*//////////////////////////////////////////////////////////////
                               AGW
    //////////////////////////////////////////////////////////////*/

    error INSUFFICIENT_FUNDS(); // 0xe7931438
    error FEE_PAYMENT_FAILED(); // 0x3d40a3a3
    error UNAUTHORIZED_OUTSIDE_TRANSACTION(); // 0xfc82da4e
    error VALIDATION_HOOK_FAILED(); // 0x52c9d27a

    /*//////////////////////////////////////////////////////////////
                               LINKED LIST
    //////////////////////////////////////////////////////////////*/

    error INVALID_PREV(); // 0x5a4c0eb3
    // Bytes
    error INVALID_BYTES(); // 0xb6dfaaff
    error BYTES_ALREADY_EXISTS(); // 0xdf6cac6b
    error BYTES_NOT_EXISTS(); // 0x689908a6
    // Address
    error INVALID_ADDRESS(); // 0x5963709b
    error ADDRESS_ALREADY_EXISTS(); // 0xf2d4d191
    error ADDRESS_NOT_EXISTS(); // 0xad6ab975

    /*//////////////////////////////////////////////////////////////
                              OWNER MANAGER
    //////////////////////////////////////////////////////////////*/

    error EMPTY_OWNERS(); // 0xc957eb7e
    error INVALID_PUBKEY_LENGTH(); // 0x04c4d8f7

    /*//////////////////////////////////////////////////////////////
                             VALIDATOR MANAGER
    //////////////////////////////////////////////////////////////*/

    error EMPTY_VALIDATORS(); // 0xd7c64d89
    error VALIDATOR_ERC165_FAIL(); // 0x5d5273ad

    /*//////////////////////////////////////////////////////////////
                              UPGRADE MANAGER
    //////////////////////////////////////////////////////////////*/

    error SAME_IMPLEMENTATION(); // 0x5e741005

    /*//////////////////////////////////////////////////////////////
                              HOOK MANAGER
    //////////////////////////////////////////////////////////////*/

    error EMPTY_HOOK_ADDRESS(); // 0x413348ae
    error HOOK_ERC165_FAIL(); // 0x9f93f87d
    error INVALID_KEY(); // 0xce7045bd

    /*//////////////////////////////////////////////////////////////
                             MODULE MANAGER
    //////////////////////////////////////////////////////////////*/

    error EMPTY_MODULE_ADDRESS(); // 0x912fe2f2
    error RECUSIVE_MODULE_CALL(); // 0x2cf7b9c8
    error MODULE_ERC165_FAIL(); // 0xc1ad2a50

    /*//////////////////////////////////////////////////////////////
                              AUTH
    //////////////////////////////////////////////////////////////*/

    error NOT_FROM_BOOTLOADER(); // 0x93887e3b
    error NOT_FROM_MODULE(); // 0x574a805d
    error NOT_FROM_HOOK(); // 0xd675a4f1
    error NOT_FROM_SELF(); // 0xa70c28d1
    error NOT_FROM_SELF_OR_MODULE(); // 0x22a1259f

    /*//////////////////////////////////////////////////////////////
                            R1 VALIDATOR
    //////////////////////////////////////////////////////////////*/

    error INVALID_SIGNATURE(); // 0xa3402a38

    /*//////////////////////////////////////////////////////////////
                          SOCIAL RECOVERY
    //////////////////////////////////////////////////////////////*/

    error INVALID_RECOVERY_CONFIG(); // 0xf774f439
    error INVALID_RECOVERY_NONCE(); // 0x098c9f8e
    error INVALID_GUARDIAN(); // 0x11a2a82b
    error INVALID_GUARDIAN_SIGNATURE(); // 0xcc117c1c
    error ZERO_ADDRESS_GUARDIAN(); // 0x6de9b401
    error GUARDIANS_MUST_BE_SORTED(); // 0xc52b41f7
    error RECOVERY_TIMELOCK(); // 0x1506ac5a
    error RECOVERY_NOT_STARTED(); // 0xa6a4a3aa
    error RECOVERY_NOT_INITED(); // 0xd0f6fdbf
    error RECOVERY_IN_PROGRESS(); // 0x8daa42a9
    error INSUFFICIENT_GUARDIANS(); // 0x7629075d
    error ALREADY_INITED(); // 0xdb0c77c8

    /*//////////////////////////////////////////////////////////////
                            FACTORY
    //////////////////////////////////////////////////////////////*/

    error DEPLOYMENT_FAILED(); // 0x0f02d218
    error INITIALIZATION_FAILED(); // 0x5b101091
    error INVALID_INITIALIZER(); // 0x350366d7
    error INVALID_SALT(); // 0x8b3152e6
    error ALREADY_CREATED(); // 0x26ebf2e8

    /*//////////////////////////////////////////////////////////////
                            PAYMASTER
    //////////////////////////////////////////////////////////////*/

    error UNSUPPORTED_FLOW(); // 0xd721e389
    error UNAUTHORIZED_WITHDRAW(); // 0x7809a0b4
    error INVALID_TOKEN(); // 0xd0995cf2
    error SHORT_PAYMASTER_INPUT(); // 0x48d170f6
    error UNSUPPORTED_TOKEN(); // 0xce706f70
    error LESS_ALLOWANCE_FOR_PAYMASTER(); // 0x11f7d13f
    error FAILED_FEE_TRANSFER(); // 0xf316e09d
    error INVALID_MARKUP(); // 0x4af7ffe3
    error USER_LIMIT_REACHED(); // 0x07235346
    error INVALID_USER_LIMIT(); // 0x2640fa41
    error NOT_AGW_ACCOUNT(); // 0x1ae1d6fd
    error EXCEEDS_MAX_SPONSORED_ETH(); // 0x3f379f40

    /*//////////////////////////////////////////////////////////////
                             REGISTRY
    //////////////////////////////////////////////////////////////*/

    error NOT_FROM_FACTORY(); // 0x238438ed
    error NOT_FROM_DEPLOYER(); // 0x83f090e3

    /*//////////////////////////////////////////////////////////////
                            BatchCaller
    //////////////////////////////////////////////////////////////*/

    error ONLY_DELEGATECALL(); // 0x43d22ee9
    error CALL_FAILED(); // 0x84aed38d

    /*//////////////////////////////////////////////////////////////
                            INITABLE
    //////////////////////////////////////////////////////////////*/

    error MODULE_NOT_ADDED_CORRECTLY(); // 0xb66e8ec4
    error MODULE_NOT_REMOVED_CORRECTLY(); // 0x680c8744

    error MsgValueMismatch(uint256 actualValue, uint256 expectedValue);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';

enum OperationType {
    Signature,
    Transaction
}

/**
 * @title secp256r1 ec keys' signature validator interface
 * @author https://getclave.io
 */
interface IR1Validator is IERC165 {
    /**
     * @notice Allows to validate secp256r1 ec signatures
     * @param signedHash bytes32          - hash of the data that is signed by the key
     * @param signature bytes             - signature
     * @param pubKey bytes32[2]           - public key coordinates array for the x and y values
     * @return valid bool                 - validation result
     */
    function validateSignature(
        OperationType operationType,
        bytes32 signedHash,
        bytes calldata signature,
        bytes32[2] calldata pubKey
    ) external view returns (bool valid);
}

/**
 * @title secp256k1 ec keys' signature validator interface
 * @author https://getclave.io
 */
interface IK1Validator is IERC165 {
    /**
     * @notice Allows to validate secp256k1 ec signatures
     * @param signedHash bytes32          - hash of the transaction signed by the key
     * @param signature bytes             - signature
     * @return signer address             - recovered signer address
     */
    function validateSignature(
        OperationType operationType,
        bytes32 signedHash,
        bytes calldata signature
    ) external view returns (address signer);
}

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

import {SystemContractsCaller} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol';
import {EfficientCall} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/EfficientCall.sol';
import { DEPLOYER_SYSTEM_CONTRACT } from "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import {Errors} from '../libraries/Errors.sol';
import {SelfAuth} from '../auth/SelfAuth.sol';
// Each call data for batches
struct Call {
    address target; // Target contract address
    bool allowFailure; // Whether to revert if the call fails
    uint256 value; // Amount of ETH to send with call
    bytes callData; // Calldata to send
}

/// @title BatchCaller
/// @notice Make multiple calls in a single transaction
abstract contract BatchCaller is SelfAuth {
  /// @notice Make multiple calls, ensure success if required.
  /// @dev The total Ether sent across all calls must be equal to `msg.value` to maintain the invariant
  /// that `msg.value` + `tx.fee` is the maximum amount of Ether that can be spent on the transaction.
  /// @param _calls Array of Call structs, each representing an individual external call to be made.
  function batchCall(Call[] calldata _calls) external payable onlySelf {
    uint256 totalValue;
    uint256 len = _calls.length;
    for (uint256 i = 0; i < len; ++i) {
      totalValue += _calls[i].value;
      bool success;
      if (_calls[i].target == address(DEPLOYER_SYSTEM_CONTRACT)) {
        // Note, that the deployer contract can only be called with a "systemCall" flag.
        success = SystemContractsCaller.systemCall(
          uint32(gasleft()),
          _calls[i].target,
          _calls[i].value,
          _calls[i].callData
        );
      } else {
        success = EfficientCall.rawCall(gasleft(), _calls[i].target, _calls[i].value, _calls[i].callData, false);
      }

      if (!_calls[i].allowFailure && !success) {
        revert Errors.CALL_FAILED();
      }
    }

    if (totalValue != msg.value) {
      revert Errors.MsgValueMismatch(msg.value, totalValue);
    }
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {IAccount} from '@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IAccount.sol';

import {IERC1271} from '@openzeppelin/contracts/interfaces/IERC1271.sol';
import {IERC777Recipient} from '@openzeppelin/contracts/interfaces/IERC777Recipient.sol';
import {IERC721Receiver} from '@openzeppelin/contracts/interfaces/IERC721Receiver.sol';
import {IERC1155Receiver} from '@openzeppelin/contracts/interfaces/IERC1155Receiver.sol';

import {IHookManager} from './IHookManager.sol';
import {IModuleManager} from './IModuleManager.sol';
import {IOwnerManager} from './IOwnerManager.sol';
import {IUpgradeManager} from './IUpgradeManager.sol';
import {IValidatorManager} from './IValidatorManager.sol';

/**
 * @title IAGWAccount
 * @notice Interface for the AGW contract
 * @dev Implementations of this interface are contracts that can be used as an AGW account
 * @dev Forked from Clave for Abstract
 * @author https://getclave.io
 * @author https://abs.xyz
 */
interface IAGWAccount is
    IERC1271,
    IERC721Receiver,
    IERC1155Receiver,
    IHookManager,
    IModuleManager,
    IOwnerManager,
    IValidatorManager,
    IUpgradeManager,
    IAccount
{
    event FeePaid();
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/IAccountCodeStorage.sol";
import "./interfaces/INonceHolder.sol";
import "./interfaces/IContractDeployer.sol";
import "./interfaces/IKnownCodesStorage.sol";
import "./interfaces/IImmutableSimulator.sol";
import "./interfaces/IEthToken.sol";
import "./interfaces/IL1Messenger.sol";
import "./interfaces/ISystemContext.sol";
import "./interfaces/IBytecodeCompressor.sol";
import "./BootloaderUtilities.sol";

/// @dev All the system contracts introduced by zkSync have their addresses
/// started from 2^15 in order to avoid collision with Ethereum precompiles.
uint160 constant SYSTEM_CONTRACTS_OFFSET = 0x8000; // 2^15

/// @dev All the system contracts must be located in the kernel space,
/// i.e. their addresses must be below 2^16.
uint160 constant MAX_SYSTEM_CONTRACT_ADDRESS = 0xffff; // 2^16 - 1

address constant ECRECOVER_SYSTEM_CONTRACT = address(0x01);
address constant SHA256_SYSTEM_CONTRACT = address(0x02);

/// @dev The current maximum deployed precompile address.
/// Note: currently only two precompiles are deployed:
/// 0x01 - ecrecover
/// 0x02 - sha256
/// Important! So the constant should be updated if more precompiles are deployed.
uint256 constant CURRENT_MAX_PRECOMPILE_ADDRESS = uint256(uint160(SHA256_SYSTEM_CONTRACT));

address payable constant BOOTLOADER_FORMAL_ADDRESS = payable(address(SYSTEM_CONTRACTS_OFFSET + 0x01));
IAccountCodeStorage constant ACCOUNT_CODE_STORAGE_SYSTEM_CONTRACT = IAccountCodeStorage(
    address(SYSTEM_CONTRACTS_OFFSET + 0x02)
);
INonceHolder constant NONCE_HOLDER_SYSTEM_CONTRACT = INonceHolder(address(SYSTEM_CONTRACTS_OFFSET + 0x03));
IKnownCodesStorage constant KNOWN_CODE_STORAGE_CONTRACT = IKnownCodesStorage(address(SYSTEM_CONTRACTS_OFFSET + 0x04));
IImmutableSimulator constant IMMUTABLE_SIMULATOR_SYSTEM_CONTRACT = IImmutableSimulator(
    address(SYSTEM_CONTRACTS_OFFSET + 0x05)
);
IContractDeployer constant DEPLOYER_SYSTEM_CONTRACT = IContractDeployer(address(SYSTEM_CONTRACTS_OFFSET + 0x06));

// A contract that is allowed to deploy any codehash
// on any address. To be used only during an upgrade.
address constant FORCE_DEPLOYER = address(SYSTEM_CONTRACTS_OFFSET + 0x07);
IL1Messenger constant L1_MESSENGER_CONTRACT = IL1Messenger(address(SYSTEM_CONTRACTS_OFFSET + 0x08));
address constant MSG_VALUE_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x09);

IEthToken constant ETH_TOKEN_SYSTEM_CONTRACT = IEthToken(address(SYSTEM_CONTRACTS_OFFSET + 0x0a));

address constant KECCAK256_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x10);

ISystemContext constant SYSTEM_CONTEXT_CONTRACT = ISystemContext(payable(address(SYSTEM_CONTRACTS_OFFSET + 0x0b)));

BootloaderUtilities constant BOOTLOADER_UTILITIES = BootloaderUtilities(address(SYSTEM_CONTRACTS_OFFSET + 0x0c));

address constant EVENT_WRITER_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x0d);

IBytecodeCompressor constant BYTECODE_COMPRESSOR_CONTRACT = IBytecodeCompressor(
    address(SYSTEM_CONTRACTS_OFFSET + 0x0e)
);

/// @dev If the bitwise AND of the extraAbi[2] param when calling the MSG_VALUE_SIMULATOR
/// is non-zero, the call will be assumed to be a system one.
uint256 constant MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT = 1;

/// @dev The maximal msg.value that context can have
uint256 constant MAX_MSG_VALUE = 2 ** 128 - 1;

/// @dev Prefix used during derivation of account addresses using CREATE2
/// @dev keccak256("zksyncCreate2")
bytes32 constant CREATE2_PREFIX = 0x2020dba91b30cc0006188af794c2fb30dd8520db7e2c088b7fc7c103c00ca494;
/// @dev Prefix used during derivation of account addresses using CREATE
/// @dev keccak256("zksyncCreate")
bytes32 constant CREATE_PREFIX = 0x63bae3a9951d38e8a3fbb7b70909afc1200610fc5bc55ade242f815974674f23;

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../libraries/TransactionHelper.sol";

bytes4 constant ACCOUNT_VALIDATION_SUCCESS_MAGIC = IAccount.validateTransaction.selector;

interface IAccount {
    /// @notice Called by the bootloader to validate that an account agrees to process the transaction
    /// (and potentially pay for it).
    /// @param _txHash The hash of the transaction to be used in the explorer
    /// @param _suggestedSignedHash The hash of the transaction is signed by EOAs
    /// @param _transaction The transaction itself
    /// @return magic The magic value that should be equal to the signature of this function
    /// if the user agrees to proceed with the transaction.
    /// @dev The developer should strive to preserve as many steps as possible both for valid
    /// and invalid transactions as this very method is also used during the gas fee estimation
    /// (without some of the necessary data, e.g. signature).
    function validateTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable returns (bytes4 magic);

    function executeTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable;

    // There is no point in providing possible signed hash in the `executeTransactionFromOutside` method,
    // since it typically should not be trusted.
    function executeTransactionFromOutside(Transaction calldata _transaction) external payable;

    function payForTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable;

    function prepareForPaymaster(
        bytes32 _txHash,
        bytes32 _possibleSignedHash,
        Transaction calldata _transaction
    ) external payable;
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity ^0.8.0;

import "./SystemContractHelper.sol";
import "./Utils.sol";
import {SHA256_SYSTEM_CONTRACT, KECCAK256_SYSTEM_CONTRACT} from "../Constants.sol";

/**
 * @author Matter Labs
 * @notice This library is used to perform ultra-efficient calls using zkEVM-specific features.
 * @dev EVM calls always accept a memory slice as input and return a memory slice as output.
 * Therefore, even if the user has a ready-made calldata slice, they still need to copy it to memory
 * before calling. This is especially inefficient for large inputs (proxies, multi-calls, etc.).
 * In turn, zkEVM operates over a fat pointer, which is a set of (memory page, offset, start, length) in the memory/calldata/returndata.
 * This allows forwarding the calldata slice as is, without copying it to memory.
 * @dev Fat pointer is not just an integer, it is an extended data type supported on the VM level.
 * zkEVM creates the wellformed fat pointers for all the calldata/returndata regions, later
 * the contract may manipulate the already created fat pointers to forward a slice of the data, but not
 * to create new fat pointers!
 * @dev The allowed operation on fat pointers are:
 * 1. `ptr.add` - Transforms `ptr.offset` into `ptr.offset + u32(_value)`. If overflow happens then it panics.
 * 2. `ptr.sub` - Transforms `ptr.offset` into `ptr.offset - u32(_value)`. If underflow happens then it panics.
 * 3. `ptr.pack` - Do the concatenation between the lowest 128 bits of the pointer itself and the highest 128 bits of `_value`. It is typically used to prepare the ABI for external calls.
 * 4. `ptr.shrink` - Transforms `ptr.length` into `ptr.length - u32(_shrink)`. If underflow happens then it panics.
 * @dev The call opcodes accept the fat pointer and change it to its canonical form before passing it to the child call
 * 1. `ptr.start` is transformed into `ptr.offset + ptr.start`
 * 2. `ptr.length` is transformed into `ptr.length - ptr.offset`
 * 3. `ptr.offset` is transformed into `0`
 */
library EfficientCall {
    /// @notice Call the `keccak256` without copying calldata to memory.
    /// @param _data The preimage data.
    /// @return The `keccak256` hash.
    function keccak(bytes calldata _data) internal view returns (bytes32) {
        bytes memory returnData = staticCall(gasleft(), KECCAK256_SYSTEM_CONTRACT, _data);
        require(returnData.length == 32, "keccak256 returned invalid data");
        return bytes32(returnData);
    }

    /// @notice Call the `sha256` precompile without copying calldata to memory.
    /// @param _data The preimage data.
    /// @return The `sha256` hash.
    function sha(bytes calldata _data) internal view returns (bytes32) {
        bytes memory returnData = staticCall(gasleft(), SHA256_SYSTEM_CONTRACT, _data);
        require(returnData.length == 32, "sha returned invalid data");
        return bytes32(returnData);
    }

    /// @notice Perform a `call` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _value The `msg.value` to send.
    /// @param _data The calldata to use for the call.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return returnData The copied to memory return data.
    function call(
        uint256 _gas,
        address _address,
        uint256 _value,
        bytes calldata _data,
        bool _isSystem
    ) internal returns (bytes memory returnData) {
        bool success = rawCall(_gas, _address, _value, _data, _isSystem);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `staticCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return returnData The copied to memory return data.
    function staticCall(
        uint256 _gas,
        address _address,
        bytes calldata _data
    ) internal view returns (bytes memory returnData) {
        bool success = rawStaticCall(_gas, _address, _data);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `delegateCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return returnData The copied to memory return data.
    function delegateCall(
        uint256 _gas,
        address _address,
        bytes calldata _data
    ) internal returns (bytes memory returnData) {
        bool success = rawDelegateCall(_gas, _address, _data);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `mimicCall` (a call with custom msg.sender) without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @param _whoToMimic The `msg.sender` for the next call.
    /// @param _isConstructor Whether the call should contain the `isConstructor` flag.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return returnData The copied to memory return data.
    function mimicCall(
        uint256 _gas,
        address _address,
        bytes calldata _data,
        address _whoToMimic,
        bool _isConstructor,
        bool _isSystem
    ) internal returns (bytes memory returnData) {
        bool success = rawMimicCall(_gas, _address, _data, _whoToMimic, _isConstructor, _isSystem);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `call` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _value The `msg.value` to send.
    /// @param _data The calldata to use for the call.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return success whether the call was successful.
    function rawCall(
        uint256 _gas,
        address _address,
        uint256 _value,
        bytes calldata _data,
        bool _isSystem
    ) internal returns (bool success) {
        if (_value == 0) {
            _loadFarCallABIIntoActivePtr(_gas, _data, false, _isSystem);

            address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
            assembly {
                success := call(_address, callAddr, 0, 0, 0xFFFF, 0, 0)
            }
        } else {
            _loadFarCallABIIntoActivePtr(_gas, _data, false, true);

            // If there is provided `msg.value` call the `MsgValueSimulator` to forward ether.
            address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
            address callAddr = SYSTEM_CALL_BY_REF_CALL_ADDRESS;
            // We need to supply the mask to the MsgValueSimulator to denote
            // that the call should be a system one.
            uint256 forwardMask = _isSystem ? MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT : 0;

            assembly {
                success := call(msgValueSimulator, callAddr, _value, _address, 0xFFFF, forwardMask, 0)
            }
        }
    }

    /// @notice Perform a `staticCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return success whether the call was successful.
    function rawStaticCall(uint256 _gas, address _address, bytes calldata _data) internal view returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, false, false);

        address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
        assembly {
            success := staticcall(_address, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Perform a `delegatecall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return success whether the call was successful.
    function rawDelegateCall(uint256 _gas, address _address, bytes calldata _data) internal returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, false, false);

        address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
        assembly {
            success := delegatecall(_address, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Perform a `mimicCall` (call with custom msg.sender) without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @param _whoToMimic The `msg.sender` for the next call.
    /// @param _isConstructor Whether the call should contain the `isConstructor` flag.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return success whether the call was successful.
    /// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
    function rawMimicCall(
        uint256 _gas,
        address _address,
        bytes calldata _data,
        address _whoToMimic,
        bool _isConstructor,
        bool _isSystem
    ) internal returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, _isConstructor, _isSystem);

        address callAddr = MIMIC_CALL_BY_REF_CALL_ADDRESS;
        uint256 cleanupMask = ADDRESS_MASK;
        assembly {
            // Clearing values before usage in assembly, since Solidity
            // doesn't do it by default
            _whoToMimic := and(_whoToMimic, cleanupMask)

            success := call(_address, callAddr, 0, 0, _whoToMimic, 0, 0)
        }
    }

    /// @dev Verify that a low-level call was successful, and revert if it wasn't, by bubbling the revert reason.
    /// @param _success Whether the call was successful.
    /// @return returnData The copied to memory return data.
    function _verifyCallResult(bool _success) private pure returns (bytes memory returnData) {
        if (_success) {
            uint256 size;
            assembly {
                size := returndatasize()
            }

            returnData = new bytes(size);
            assembly {
                returndatacopy(add(returnData, 0x20), 0, size)
            }
        } else {
            propagateRevert();
        }
    }

    /// @dev Propagate the revert reason from the current call to the caller.
    function propagateRevert() internal pure {
        assembly {
            let size := returndatasize()
            returndatacopy(0, 0, size)
            revert(0, size)
        }
    }

    /// @dev Load the far call ABI into active ptr, that will be used for the next call by reference.
    /// @param _gas The gas to be passed to the call.
    /// @param _data The calldata to be passed to the call.
    /// @param _isConstructor Whether the call is a constructor call.
    /// @param _isSystem Whether the call is a system call.
    function _loadFarCallABIIntoActivePtr(
        uint256 _gas,
        bytes calldata _data,
        bool _isConstructor,
        bool _isSystem
    ) private view {
        SystemContractHelper.loadCalldataIntoActivePtr();

        // Currently, zkEVM considers the pointer valid if(ptr.offset < ptr.length || (ptr.length == 0 && ptr.offset == 0)), otherwise panics.
        // So, if the data is empty we need to make the `ptr.length = ptr.offset = 0`, otherwise follow standard logic.
        if (_data.length == 0) {
            // Safe to cast, offset is never bigger than `type(uint32).max`
            SystemContractHelper.ptrShrinkIntoActive(uint32(msg.data.length));
        } else {
            uint256 dataOffset;
            assembly {
                dataOffset := _data.offset
            }

            // Safe to cast, offset is never bigger than `type(uint32).max`
            SystemContractHelper.ptrAddIntoActive(uint32(dataOffset));
            // Safe to cast, `data.length` is never bigger than `type(uint32).max`
            uint32 shrinkTo = uint32(msg.data.length - (_data.length + dataOffset));
            SystemContractHelper.ptrShrinkIntoActive(shrinkTo);
        }

        uint32 gas = Utils.safeCastToU32(_gas);
        uint256 farCallAbi = SystemContractsCaller.getFarCallABIWithEmptyFatPointer(
            gas,
            // Only rollup is supported for now
            0,
            CalldataForwardingMode.ForwardFatPointer,
            _isConstructor,
            _isSystem
        );
        SystemContractHelper.ptrPackIntoActivePtr(farCallAbi);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8;

import {MSG_VALUE_SYSTEM_CONTRACT, MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT} from "../Constants.sol";
import "./Utils.sol";

// Addresses used for the compiler to be replaced with the
// zkSync-specific opcodes during the compilation.
// IMPORTANT: these are just compile-time constants and are used
// only if used in-place by Yul optimizer.
address constant TO_L1_CALL_ADDRESS = address((1 << 16) - 1);
address constant CODE_ADDRESS_CALL_ADDRESS = address((1 << 16) - 2);
address constant PRECOMPILE_CALL_ADDRESS = address((1 << 16) - 3);
address constant META_CALL_ADDRESS = address((1 << 16) - 4);
address constant MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 5);
address constant SYSTEM_MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 6);
address constant MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 7);
address constant SYSTEM_MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 8);
address constant RAW_FAR_CALL_CALL_ADDRESS = address((1 << 16) - 9);
address constant RAW_FAR_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 10);
address constant SYSTEM_CALL_CALL_ADDRESS = address((1 << 16) - 11);
address constant SYSTEM_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 12);
address constant SET_CONTEXT_VALUE_CALL_ADDRESS = address((1 << 16) - 13);
address constant SET_PUBDATA_PRICE_CALL_ADDRESS = address((1 << 16) - 14);
address constant INCREMENT_TX_COUNTER_CALL_ADDRESS = address((1 << 16) - 15);
address constant PTR_CALLDATA_CALL_ADDRESS = address((1 << 16) - 16);
address constant CALLFLAGS_CALL_ADDRESS = address((1 << 16) - 17);
address constant PTR_RETURNDATA_CALL_ADDRESS = address((1 << 16) - 18);
address constant EVENT_INITIALIZE_ADDRESS = address((1 << 16) - 19);
address constant EVENT_WRITE_ADDRESS = address((1 << 16) - 20);
address constant LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 21);
address constant LOAD_LATEST_RETURNDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 22);
address constant PTR_ADD_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 23);
address constant PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 24);
address constant PTR_PACK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 25);
address constant MULTIPLICATION_HIGH_ADDRESS = address((1 << 16) - 26);
address constant GET_EXTRA_ABI_DATA_ADDRESS = address((1 << 16) - 27);

// All the offsets are in bits
uint256 constant META_GAS_PER_PUBDATA_BYTE_OFFSET = 0 * 8;
uint256 constant META_HEAP_SIZE_OFFSET = 8 * 8;
uint256 constant META_AUX_HEAP_SIZE_OFFSET = 12 * 8;
uint256 constant META_SHARD_ID_OFFSET = 28 * 8;
uint256 constant META_CALLER_SHARD_ID_OFFSET = 29 * 8;
uint256 constant META_CODE_SHARD_ID_OFFSET = 30 * 8;

/// @notice The way to forward the calldata:
/// - Use the current heap (i.e. the same as on EVM).
/// - Use the auxiliary heap.
/// - Forward via a pointer
/// @dev Note, that currently, users do not have access to the auxiliary
/// heap and so the only type of forwarding that will be used by the users
/// are UseHeap and ForwardFatPointer for forwarding a slice of the current calldata
/// to the next call.
enum CalldataForwardingMode {
    UseHeap,
    ForwardFatPointer,
    UseAuxHeap
}

/**
 * @author Matter Labs
 * @notice A library that allows calling contracts with the `isSystem` flag.
 * @dev It is needed to call ContractDeployer and NonceHolder.
 */
library SystemContractsCaller {
    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return success Whether the transaction has been successful.
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCall(uint32 gasLimit, address to, uint256 value, bytes memory data) internal returns (bool success) {
        address callAddr = SYSTEM_CALL_CALL_ADDRESS;

        uint32 dataStart;
        assembly {
            dataStart := add(data, 0x20)
        }
        uint32 dataLength = uint32(Utils.safeCastToU32(data.length));

        uint256 farCallAbi = SystemContractsCaller.getFarCallABI(
            0,
            0,
            dataStart,
            dataLength,
            gasLimit,
            // Only rollup is supported for now
            0,
            CalldataForwardingMode.UseHeap,
            false,
            true
        );

        if (value == 0) {
            // Doing the system call directly
            assembly {
                success := call(to, callAddr, 0, 0, farCallAbi, 0, 0)
            }
        } else {
            address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
            // We need to supply the mask to the MsgValueSimulator to denote
            // that the call should be a system one.
            uint256 forwardMask = MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT;

            assembly {
                success := call(msgValueSimulator, callAddr, value, to, farCallAbi, forwardMask, 0)
            }
        }
    }

    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return success Whether the transaction has been successful.
    /// @return returnData The returndata of the transaction (revert reason in case the transaction has failed).
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCallWithReturndata(
        uint32 gasLimit,
        address to,
        uint128 value,
        bytes memory data
    ) internal returns (bool success, bytes memory returnData) {
        success = systemCall(gasLimit, to, value, data);

        uint256 size;
        assembly {
            size := returndatasize()
        }

        returnData = new bytes(size);
        assembly {
            returndatacopy(add(returnData, 0x20), 0, size)
        }
    }

    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return returnData The returndata of the transaction. In case the transaction reverts, the error
    /// bubbles up to the parent frame.
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCallWithPropagatedRevert(
        uint32 gasLimit,
        address to,
        uint128 value,
        bytes memory data
    ) internal returns (bytes memory returnData) {
        bool success;
        (success, returnData) = systemCallWithReturndata(gasLimit, to, value, data);

        if (!success) {
            assembly {
                let size := mload(returnData)
                revert(add(returnData, 0x20), size)
            }
        }
    }

    /// @notice Calculates the packed representation of the FarCallABI.
    /// @param dataOffset Calldata offset in memory. Provide 0 unless using custom pointer.
    /// @param memoryPage Memory page to use. Provide 0 unless using custom pointer.
    /// @param dataStart The start of the calldata slice. Provide the offset in memory
    /// if not using custom pointer.
    /// @param dataLength The calldata length. Provide the length of the calldata in bytes
    /// unless using custom pointer.
    /// @param gasPassed The gas to pass with the call.
    /// @param shardId Of the account to call. Currently only 0 is supported.
    /// @param forwardingMode The forwarding mode to use:
    /// - provide CalldataForwardingMode.UseHeap when using your current memory
    /// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
    /// @param isConstructorCall Whether the call will be a call to the constructor
    /// (ignored when the caller is not a system contract).
    /// @param isSystemCall Whether the call will have the `isSystem` flag.
    /// @return farCallAbi The far call ABI.
    /// @dev The `FarCallABI` has the following structure:
    /// pub struct FarCallABI {
    ///     pub memory_quasi_fat_pointer: FatPointer,
    ///     pub gas_passed: u32,
    ///     pub shard_id: u8,
    ///     pub forwarding_mode: FarCallForwardPageType,
    ///     pub constructor_call: bool,
    ///     pub to_system: bool,
    /// }
    ///
    /// The FatPointer struct:
    ///
    /// pub struct FatPointer {
    ///     pub offset: u32, // offset relative to `start`
    ///     pub memory_page: u32, // memory page where slice is located
    ///     pub start: u32, // absolute start of the slice
    ///     pub length: u32, // length of the slice
    /// }
    ///
    /// @dev Note, that the actual layout is the following:
    ///
    /// [0..32) bits -- the calldata offset
    /// [32..64) bits -- the memory page to use. Can be left blank in most of the cases.
    /// [64..96) bits -- the absolute start of the slice
    /// [96..128) bits -- the length of the slice.
    /// [128..192) bits -- empty bits.
    /// [192..224) bits -- gasPassed.
    /// [224..232) bits -- forwarding_mode
    /// [232..240) bits -- shard id.
    /// [240..248) bits -- constructor call flag
    /// [248..256] bits -- system call flag
    function getFarCallABI(
        uint32 dataOffset,
        uint32 memoryPage,
        uint32 dataStart,
        uint32 dataLength,
        uint32 gasPassed,
        uint8 shardId,
        CalldataForwardingMode forwardingMode,
        bool isConstructorCall,
        bool isSystemCall
    ) internal pure returns (uint256 farCallAbi) {
        // Fill in the call parameter fields
        farCallAbi = getFarCallABIWithEmptyFatPointer(
            gasPassed,
            shardId,
            forwardingMode,
            isConstructorCall,
            isSystemCall
        );
        // Fill in the fat pointer fields
        farCallAbi |= dataOffset;
        farCallAbi |= (uint256(memoryPage) << 32);
        farCallAbi |= (uint256(dataStart) << 64);
        farCallAbi |= (uint256(dataLength) << 96);
    }

    /// @notice Calculates the packed representation of the FarCallABI with zero fat pointer fields.
    /// @param gasPassed The gas to pass with the call.
    /// @param shardId Of the account to call. Currently only 0 is supported.
    /// @param forwardingMode The forwarding mode to use:
    /// - provide CalldataForwardingMode.UseHeap when using your current memory
    /// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
    /// @param isConstructorCall Whether the call will be a call to the constructor
    /// (ignored when the caller is not a system contract).
    /// @param isSystemCall Whether the call will have the `isSystem` flag.
    /// @return farCallAbiWithEmptyFatPtr The far call ABI with zero fat pointer fields.
    function getFarCallABIWithEmptyFatPointer(
        uint32 gasPassed,
        uint8 shardId,
        CalldataForwardingMode forwardingMode,
        bool isConstructorCall,
        bool isSystemCall
    ) internal pure returns (uint256 farCallAbiWithEmptyFatPtr) {
        farCallAbiWithEmptyFatPtr |= (uint256(gasPassed) << 192);
        farCallAbiWithEmptyFatPtr |= (uint256(forwardingMode) << 224);
        farCallAbiWithEmptyFatPtr |= (uint256(shardId) << 232);
        if (isConstructorCall) {
            farCallAbiWithEmptyFatPtr |= (1 << 240);
        }
        if (isSystemCall) {
            farCallAbiWithEmptyFatPtr |= (1 << 248);
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "./EfficientCall.sol";

/**
 * @author Matter Labs
 * @dev Common utilities used in zkSync system contracts
 */
library Utils {
    /// @dev Bit mask of bytecode hash "isConstructor" marker
    bytes32 constant IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK =
        0x00ff000000000000000000000000000000000000000000000000000000000000;

    /// @dev Bit mask to set the "isConstructor" marker in the bytecode hash
    bytes32 constant SET_IS_CONSTRUCTOR_MARKER_BIT_MASK =
        0x0001000000000000000000000000000000000000000000000000000000000000;

    function safeCastToU128(uint256 _x) internal pure returns (uint128) {
        require(_x <= type(uint128).max, "Overflow");

        return uint128(_x);
    }

    function safeCastToU32(uint256 _x) internal pure returns (uint32) {
        require(_x <= type(uint32).max, "Overflow");

        return uint32(_x);
    }

    function safeCastToU24(uint256 _x) internal pure returns (uint24) {
        require(_x <= type(uint24).max, "Overflow");

        return uint24(_x);
    }

    /// @return codeLength The bytecode length in bytes
    function bytecodeLenInBytes(bytes32 _bytecodeHash) internal pure returns (uint256 codeLength) {
        codeLength = bytecodeLenInWords(_bytecodeHash) << 5; // _bytecodeHash * 32
    }

    /// @return codeLengthInWords The bytecode length in machine words
    function bytecodeLenInWords(bytes32 _bytecodeHash) internal pure returns (uint256 codeLengthInWords) {
        unchecked {
            codeLengthInWords = uint256(uint8(_bytecodeHash[2])) * 256 + uint256(uint8(_bytecodeHash[3]));
        }
    }

    /// @notice Denotes whether bytecode hash corresponds to a contract that already constructed
    function isContractConstructed(bytes32 _bytecodeHash) internal pure returns (bool) {
        return _bytecodeHash[1] == 0x00;
    }

    /// @notice Denotes whether bytecode hash corresponds to a contract that is on constructor or has already been constructed
    function isContractConstructing(bytes32 _bytecodeHash) internal pure returns (bool) {
        return _bytecodeHash[1] == 0x01;
    }

    /// @notice Sets "isConstructor" flag to TRUE for the bytecode hash
    /// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
    /// @return The bytecode hash with "isConstructor" flag set to TRUE
    function constructingBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
        // Clear the "isConstructor" marker and set it to 0x01.
        return constructedBytecodeHash(_bytecodeHash) | SET_IS_CONSTRUCTOR_MARKER_BIT_MASK;
    }

    /// @notice Sets "isConstructor" flag to FALSE for the bytecode hash
    /// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
    /// @return The bytecode hash with "isConstructor" flag set to FALSE
    function constructedBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
        return _bytecodeHash & ~IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK;
    }

    /// @notice Validate the bytecode format and calculate its hash.
    /// @param _bytecode The bytecode to hash.
    /// @return hashedBytecode The 32-byte hash of the bytecode.
    /// Note: The function reverts the execution if the bytecode has non expected format:
    /// - Bytecode bytes length is not a multiple of 32
    /// - Bytecode bytes length is not less than 2^21 bytes (2^16 words)
    /// - Bytecode words length is not odd
    function hashL2Bytecode(bytes calldata _bytecode) internal view returns (bytes32 hashedBytecode) {
        // Note that the length of the bytecode must be provided in 32-byte words.
        require(_bytecode.length % 32 == 0, "po");

        uint256 bytecodeLenInWords = _bytecode.length / 32;
        require(bytecodeLenInWords < 2 ** 16, "pp"); // bytecode length must be less than 2^16 words
        require(bytecodeLenInWords % 2 == 1, "pr"); // bytecode length in words must be odd
        hashedBytecode =
            EfficientCall.sha(_bytecode) &
            0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
        // Setting the version of the hash
        hashedBytecode = (hashedBytecode | bytes32(uint256(1 << 248)));
        // Setting the length
        hashedBytecode = hashedBytecode | bytes32(bytecodeLenInWords << 224);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../openzeppelin/token/ERC20/IERC20.sol";
import "../openzeppelin/token/ERC20/utils/SafeERC20.sol";

import "../interfaces/IPaymasterFlow.sol";
import "../interfaces/IContractDeployer.sol";
import {ETH_TOKEN_SYSTEM_CONTRACT, BOOTLOADER_FORMAL_ADDRESS} from "../Constants.sol";
import "./RLPEncoder.sol";
import "./EfficientCall.sol";

/// @dev The type id of zkSync's EIP-712-signed transaction.
uint8 constant EIP_712_TX_TYPE = 0x71;

/// @dev The type id of legacy transactions.
uint8 constant LEGACY_TX_TYPE = 0x0;
/// @dev The type id of legacy transactions.
uint8 constant EIP_2930_TX_TYPE = 0x01;
/// @dev The type id of EIP1559 transactions.
uint8 constant EIP_1559_TX_TYPE = 0x02;

/// @notice Structure used to represent zkSync transaction.
struct Transaction {
    // The type of the transaction.
    uint256 txType;
    // The caller.
    uint256 from;
    // The callee.
    uint256 to;
    // The gasLimit to pass with the transaction.
    // It has the same meaning as Ethereum's gasLimit.
    uint256 gasLimit;
    // The maximum amount of gas the user is willing to pay for a byte of pubdata.
    uint256 gasPerPubdataByteLimit;
    // The maximum fee per gas that the user is willing to pay.
    // It is akin to EIP1559's maxFeePerGas.
    uint256 maxFeePerGas;
    // The maximum priority fee per gas that the user is willing to pay.
    // It is akin to EIP1559's maxPriorityFeePerGas.
    uint256 maxPriorityFeePerGas;
    // The transaction's paymaster. If there is no paymaster, it is equal to 0.
    uint256 paymaster;
    // The nonce of the transaction.
    uint256 nonce;
    // The value to pass with the transaction.
    uint256 value;
    // In the future, we might want to add some
    // new fields to the struct. The `txData` struct
    // is to be passed to account and any changes to its structure
    // would mean a breaking change to these accounts. In order to prevent this,
    // we should keep some fields as "reserved".
    // It is also recommended that their length is fixed, since
    // it would allow easier proof integration (in case we will need
    // some special circuit for preprocessing transactions).
    uint256[4] reserved;
    // The transaction's calldata.
    bytes data;
    // The signature of the transaction.
    bytes signature;
    // The properly formatted hashes of bytecodes that must be published on L1
    // with the inclusion of this transaction. Note, that a bytecode has been published
    // before, the user won't pay fees for its republishing.
    bytes32[] factoryDeps;
    // The input to the paymaster.
    bytes paymasterInput;
    // Reserved dynamic type for the future use-case. Using it should be avoided,
    // But it is still here, just in case we want to enable some additional functionality.
    bytes reservedDynamic;
}

/**
 * @author Matter Labs
 * @notice Library is used to help custom accounts to work with common methods for the Transaction type.
 */
library TransactionHelper {
    using SafeERC20 for IERC20;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 constant EIP712_DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId)");

    bytes32 constant EIP712_TRANSACTION_TYPE_HASH =
        keccak256(
            "Transaction(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,bytes data,bytes32[] factoryDeps,bytes paymasterInput)"
        );

    /// @notice Whether the token is Ethereum.
    /// @param _addr The address of the token
    /// @return `true` or `false` based on whether the token is Ether.
    /// @dev This method assumes that address is Ether either if the address is 0 (for convenience)
    /// or if the address is the address of the L2EthToken system contract.
    function isEthToken(uint256 _addr) internal pure returns (bool) {
        return _addr == uint256(uint160(address(ETH_TOKEN_SYSTEM_CONTRACT))) || _addr == 0;
    }

    /// @notice Calculate the suggested signed hash of the transaction,
    /// i.e. the hash that is signed by EOAs and is recommended to be signed by other accounts.
    function encodeHash(Transaction calldata _transaction) internal view returns (bytes32 resultHash) {
        if (_transaction.txType == LEGACY_TX_TYPE) {
            resultHash = _encodeHashLegacyTransaction(_transaction);
        } else if (_transaction.txType == EIP_712_TX_TYPE) {
            resultHash = _encodeHashEIP712Transaction(_transaction);
        } else if (_transaction.txType == EIP_1559_TX_TYPE) {
            resultHash = _encodeHashEIP1559Transaction(_transaction);
        } else if (_transaction.txType == EIP_2930_TX_TYPE) {
            resultHash = _encodeHashEIP2930Transaction(_transaction);
        } else {
            // Currently no other transaction types are supported.
            // Any new transaction types will be processed in a similar manner.
            revert("Encoding unsupported tx");
        }
    }

    /// @notice Encode hash of the zkSync native transaction type.
    /// @return keccak256 hash of the EIP-712 encoded representation of transaction
    function _encodeHashEIP712Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        bytes32 structHash = keccak256(
            abi.encode(
                EIP712_TRANSACTION_TYPE_HASH,
                _transaction.txType,
                _transaction.from,
                _transaction.to,
                _transaction.gasLimit,
                _transaction.gasPerPubdataByteLimit,
                _transaction.maxFeePerGas,
                _transaction.maxPriorityFeePerGas,
                _transaction.paymaster,
                _transaction.nonce,
                _transaction.value,
                EfficientCall.keccak(_transaction.data),
                keccak256(abi.encodePacked(_transaction.factoryDeps)),
                EfficientCall.keccak(_transaction.paymasterInput)
            )
        );

        bytes32 domainSeparator = keccak256(
            abi.encode(EIP712_DOMAIN_TYPEHASH, keccak256("zkSync"), keccak256("2"), block.chainid)
        );

        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }

    /// @notice Encode hash of the legacy transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashLegacyTransaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of legacy transactions are encoded as one of the:
        // - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
        // - RLP(nonce, gasPrice, gasLimit, to, value, data)
        //
        // In this RLP encoding, only the first one above list appears, so we encode each element
        // inside list and then concatenate the length of all elements with them.

        bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
        // Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
        bytes memory encodedGasParam;
        {
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
        }

        bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
        bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // Encode `chainId` according to EIP-155, but only if the `chainId` is specified in the transaction.
        bytes memory encodedChainId;
        if (_transaction.reserved[0] != 0) {
            encodedChainId = bytes.concat(RLPEncoder.encodeUint256(block.chainid), hex"80_80");
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedNonce.length +
                encodedGasParam.length +
                encodedTo.length +
                encodedValue.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedChainId.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    encodedListLength,
                    encodedNonce,
                    encodedGasParam,
                    encodedTo,
                    encodedValue,
                    encodedDataLength,
                    _transaction.data,
                    encodedChainId
                )
            );
    }

    /// @notice Encode hash of the EIP2930 transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashEIP2930Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of EIP2930 transactions is encoded the following way:
        // H(0x01 || RLP(chain_id, nonce, gas_price, gas_limit, destination, amount, data, access_list))
        //
        // Note, that on zkSync access lists are not supported and should always be empty.

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedGasPrice,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x01",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength
                )
            );
    }

    /// @notice Encode hash of the EIP1559 transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashEIP1559Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of EIP1559 transactions is encoded the following way:
        // H(0x02 || RLP(chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, amount, data, access_list))
        //
        // Note, that on zkSync access lists are not supported and should always be empty.

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
            bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedMaxPriorityFeePerGas,
                encodedMaxFeePerGas,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x02",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength
                )
            );
    }

    /// @notice Processes the common paymaster flows, e.g. setting proper allowance
    /// for tokens, etc. For more information on the expected behavior, check out
    /// the "Paymaster flows" section in the documentation.
    function processPaymasterInput(Transaction calldata _transaction) internal {
        require(_transaction.paymasterInput.length >= 4, "The standard paymaster input must be at least 4 bytes long");

        bytes4 paymasterInputSelector = bytes4(_transaction.paymasterInput[0:4]);
        if (paymasterInputSelector == IPaymasterFlow.approvalBased.selector) {
            require(
                _transaction.paymasterInput.length >= 68,
                "The approvalBased paymaster input must be at least 68 bytes long"
            );

            // While the actual data consists of address, uint256 and bytes data,
            // the data is needed only for the paymaster, so we ignore it here for the sake of optimization
            (address token, uint256 minAllowance) = abi.decode(_transaction.paymasterInput[4:68], (address, uint256));
            address paymaster = address(uint160(_transaction.paymaster));

            uint256 currentAllowance = IERC20(token).allowance(address(this), paymaster);
            if (currentAllowance < minAllowance) {
                // Some tokens, e.g. USDT require that the allowance is firsty set to zero
                // and only then updated to the new value.

                IERC20(token).safeApprove(paymaster, 0);
                IERC20(token).safeApprove(paymaster, minAllowance);
            }
        } else if (paymasterInputSelector == IPaymasterFlow.general.selector) {
            // Do nothing. general(bytes) paymaster flow means that the paymaster must interpret these bytes on his own.
        } else {
            revert("Unsupported paymaster flow");
        }
    }

    /// @notice Pays the required fee for the transaction to the bootloader.
    /// @dev Currently it pays the maximum amount "_transaction.maxFeePerGas * _transaction.gasLimit",
    /// it will change in the future.
    function payToTheBootloader(Transaction calldata _transaction) internal returns (bool success) {
        address bootloaderAddr = BOOTLOADER_FORMAL_ADDRESS;
        uint256 amount = _transaction.maxFeePerGas * _transaction.gasLimit;

        assembly {
            success := call(gas(), bootloaderAddr, amount, 0, 0, 0, 0)
        }
    }

    // Returns the balance required to process the transaction.
    function totalRequiredBalance(Transaction calldata _transaction) internal pure returns (uint256 requiredBalance) {
        if (address(uint160(_transaction.paymaster)) != address(0)) {
            // Paymaster pays for the fee
            requiredBalance = _transaction.value;
        } else {
            // The user should have enough balance for both the fee and the value of the transaction
            requiredBalance = _transaction.maxFeePerGas * _transaction.gasLimit + _transaction.value;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8;

import {MAX_SYSTEM_CONTRACT_ADDRESS, MSG_VALUE_SYSTEM_CONTRACT} from "../Constants.sol";

import "./SystemContractsCaller.sol";
import "./Utils.sol";

uint256 constant UINT32_MASK = 0xffffffff;
uint256 constant UINT128_MASK = 0xffffffffffffffffffffffffffffffff;
/// @dev The mask that is used to convert any uint256 to a proper address.
/// It needs to be padded with `00` to be treated as uint256 by Solidity
uint256 constant ADDRESS_MASK = 0x00ffffffffffffffffffffffffffffffffffffffff;

struct ZkSyncMeta {
    uint32 gasPerPubdataByte;
    uint32 heapSize;
    uint32 auxHeapSize;
    uint8 shardId;
    uint8 callerShardId;
    uint8 codeShardId;
}

enum Global {
    CalldataPtr,
    CallFlags,
    ExtraABIData1,
    ExtraABIData2,
    ReturndataPtr
}

/**
 * @author Matter Labs
 * @notice Library used for accessing zkEVM-specific opcodes, needed for the development
 * of system contracts.
 * @dev While this library will be eventually available to public, some of the provided
 * methods won't work for non-system contracts. We will not recommend this library
 * for external use.
 */
library SystemContractHelper {
    /// @notice Send an L2Log to L1.
    /// @param _isService The `isService` flag.
    /// @param _key The `key` part of the L2Log.
    /// @param _value The `value` part of the L2Log.
    /// @dev The meaning of all these parameters is context-dependent, but they
    /// have no intrinsic meaning per se.
    function toL1(bool _isService, bytes32 _key, bytes32 _value) internal {
        address callAddr = TO_L1_CALL_ADDRESS;
        assembly {
            // Ensuring that the type is bool
            _isService := and(_isService, 1)
            // This `success` is always 0, but the method always succeeds
            // (except for the cases when there is not enough gas)
            let success := call(_isService, callAddr, _key, _value, 0xFFFF, 0, 0)
        }
    }

    /// @notice Get address of the currently executed code.
    /// @dev This allows differentiating between `call` and `delegatecall`.
    /// During the former `this` and `codeAddress` are the same, while
    /// during the latter they are not.
    function getCodeAddress() internal view returns (address addr) {
        address callAddr = CODE_ADDRESS_CALL_ADDRESS;
        assembly {
            addr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Provide a compiler hint, by placing calldata fat pointer into virtual `ACTIVE_PTR`,
    /// that can be manipulated by `ptr.add`/`ptr.sub`/`ptr.pack`/`ptr.shrink` later.
    /// @dev This allows making a call by forwarding calldata pointer to the child call.
    /// It is a much more efficient way to forward calldata, than standard EVM bytes copying.
    function loadCalldataIntoActivePtr() internal view {
        address callAddr = LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS;
        assembly {
            pop(staticcall(0, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.pack` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Do the concatenation between lowest part of `ACTIVE_PTR` and highest part of `_farCallAbi`
    /// forming packed fat pointer for a far call or ret ABI when necessary.
    /// Note: Panics if the lowest 128 bits of `_farCallAbi` are not zeroes.
    function ptrPackIntoActivePtr(uint256 _farCallAbi) internal view {
        address callAddr = PTR_PACK_INTO_ACTIVE_CALL_ADDRESS;
        assembly {
            pop(staticcall(_farCallAbi, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.add` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Transforms `ACTIVE_PTR.offset` into `ACTIVE_PTR.offset + u32(_value)`. If overflow happens then it panics.
    function ptrAddIntoActive(uint32 _value) internal view {
        address callAddr = PTR_ADD_INTO_ACTIVE_CALL_ADDRESS;
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _value := and(_value, cleanupMask)
            pop(staticcall(_value, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.shrink` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Transforms `ACTIVE_PTR.length` into `ACTIVE_PTR.length - u32(_shrink)`. If underflow happens then it panics.
    function ptrShrinkIntoActive(uint32 _shrink) internal view {
        address callAddr = PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS;
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _shrink := and(_shrink, cleanupMask)
            pop(staticcall(_shrink, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice packs precompile parameters into one word
    /// @param _inputMemoryOffset The memory offset in 32-byte words for the input data for calling the precompile.
    /// @param _inputMemoryLength The length of the input data in words.
    /// @param _outputMemoryOffset The memory offset in 32-byte words for the output data.
    /// @param _outputMemoryLength The length of the output data in words.
    /// @param _perPrecompileInterpreted The constant, the meaning of which is defined separately for
    /// each precompile. For information, please read the documentation of the precompilecall log in
    /// the VM.
    function packPrecompileParams(
        uint32 _inputMemoryOffset,
        uint32 _inputMemoryLength,
        uint32 _outputMemoryOffset,
        uint32 _outputMemoryLength,
        uint64 _perPrecompileInterpreted
    ) internal pure returns (uint256 rawParams) {
        rawParams = _inputMemoryOffset;
        rawParams |= uint256(_inputMemoryLength) << 32;
        rawParams |= uint256(_outputMemoryOffset) << 64;
        rawParams |= uint256(_outputMemoryLength) << 96;
        rawParams |= uint256(_perPrecompileInterpreted) << 192;
    }

    /// @notice Call precompile with given parameters.
    /// @param _rawParams The packed precompile params. They can be retrieved by
    /// the `packPrecompileParams` method.
    /// @param _gasToBurn The number of gas to burn during this call.
    /// @return success Whether the call was successful.
    /// @dev The list of currently available precompiles sha256, keccak256, ecrecover.
    /// NOTE: The precompile type depends on `this` which calls precompile, which means that only
    /// system contracts corresponding to the list of precompiles above can do `precompileCall`.
    /// @dev If used not in the `sha256`, `keccak256` or `ecrecover` contracts, it will just burn the gas provided.
    function precompileCall(uint256 _rawParams, uint32 _gasToBurn) internal view returns (bool success) {
        address callAddr = PRECOMPILE_CALL_ADDRESS;

        // After `precompileCall` gas will be burned down to 0 if there are not enough of them,
        // thats why it should be checked before the call.
        require(gasleft() >= _gasToBurn);
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _gasToBurn := and(_gasToBurn, cleanupMask)
            success := staticcall(_rawParams, callAddr, _gasToBurn, 0xFFFF, 0, 0)
        }
    }

    /// @notice Set `msg.value` to next far call.
    /// @param _value The msg.value that will be used for the *next* call.
    /// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
    function setValueForNextFarCall(uint128 _value) internal returns (bool success) {
        uint256 cleanupMask = UINT128_MASK;
        address callAddr = SET_CONTEXT_VALUE_CALL_ADDRESS;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _value := and(_value, cleanupMask)
            success := call(0, callAddr, _value, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Initialize a new event.
    /// @param initializer The event initializing value.
    /// @param value1 The first topic or data chunk.
    function eventInitialize(uint256 initializer, uint256 value1) internal {
        address callAddr = EVENT_INITIALIZE_ADDRESS;
        assembly {
            pop(call(initializer, callAddr, value1, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Continue writing the previously initialized event.
    /// @param value1 The first topic or data chunk.
    /// @param value2 The second topic or data chunk.
    function eventWrite(uint256 value1, uint256 value2) internal {
        address callAddr = EVENT_WRITE_ADDRESS;
        assembly {
            pop(call(value1, callAddr, value2, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Get the packed representation of the `ZkSyncMeta` from the current context.
    /// @return meta The packed representation of the ZkSyncMeta.
    /// @dev The fields in ZkSyncMeta are NOT tightly packed, i.e. there is a special rule on how
    /// they are packed. For more information, please read the documentation on ZkSyncMeta.
    function getZkSyncMetaBytes() internal view returns (uint256 meta) {
        address callAddr = META_CALL_ADDRESS;
        assembly {
            meta := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the bits [offset..offset+size-1] of the meta.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @param offset The offset of the bits.
    /// @param size The size of the extracted number in bits.
    /// @return result The extracted number.
    function extractNumberFromMeta(uint256 meta, uint256 offset, uint256 size) internal pure returns (uint256 result) {
        // Firstly, we delete all the bits after the field
        uint256 shifted = (meta << (256 - size - offset));
        // Then we shift everything back
        result = (shifted >> (256 - size));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of gas
    /// that a single byte sent to L1 as pubdata costs.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return gasPerPubdataByte The current price in gas per pubdata byte.
    function getGasPerPubdataByteFromMeta(uint256 meta) internal pure returns (uint32 gasPerPubdataByte) {
        gasPerPubdataByte = uint32(extractNumberFromMeta(meta, META_GAS_PER_PUBDATA_BYTE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
    /// of the heap in bytes.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return heapSize The size of the memory in bytes byte.
    /// @dev The following expression: getHeapSizeFromMeta(getZkSyncMetaBytes()) is
    /// equivalent to the MSIZE in Solidity.
    function getHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 heapSize) {
        heapSize = uint32(extractNumberFromMeta(meta, META_HEAP_SIZE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
    /// of the auxilary heap in bytes.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return auxHeapSize The size of the auxilary memory in bytes byte.
    /// @dev You can read more on auxilary memory in the VM1.2 documentation.
    function getAuxHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 auxHeapSize) {
        auxHeapSize = uint32(extractNumberFromMeta(meta, META_AUX_HEAP_SIZE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of `this`.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return shardId The shardId of `this`.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getShardIdFromMeta(uint256 meta) internal pure returns (uint8 shardId) {
        shardId = uint8(extractNumberFromMeta(meta, META_SHARD_ID_OFFSET, 8));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
    /// the msg.sender.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return callerShardId The shardId of the msg.sender.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getCallerShardIdFromMeta(uint256 meta) internal pure returns (uint8 callerShardId) {
        callerShardId = uint8(extractNumberFromMeta(meta, META_CALLER_SHARD_ID_OFFSET, 8));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
    /// the currently executed code.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return codeShardId The shardId of the currently executed code.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getCodeShardIdFromMeta(uint256 meta) internal pure returns (uint8 codeShardId) {
        codeShardId = uint8(extractNumberFromMeta(meta, META_CODE_SHARD_ID_OFFSET, 8));
    }

    /// @notice Retrieves the ZkSyncMeta structure.
    /// @return meta The ZkSyncMeta execution context parameters.
    function getZkSyncMeta() internal view returns (ZkSyncMeta memory meta) {
        uint256 metaPacked = getZkSyncMetaBytes();
        meta.gasPerPubdataByte = getGasPerPubdataByteFromMeta(metaPacked);
        meta.shardId = getShardIdFromMeta(metaPacked);
        meta.callerShardId = getCallerShardIdFromMeta(metaPacked);
        meta.codeShardId = getCodeShardIdFromMeta(metaPacked);
    }

    /// @notice Returns the call flags for the current call.
    /// @return callFlags The bitmask of the callflags.
    /// @dev Call flags is the value of the first register
    /// at the start of the call.
    /// @dev The zero bit of the callFlags indicates whether the call is
    /// a constructor call. The first bit of the callFlags indicates whether
    /// the call is a system one.
    function getCallFlags() internal view returns (uint256 callFlags) {
        address callAddr = CALLFLAGS_CALL_ADDRESS;
        assembly {
            callFlags := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the current calldata pointer.
    /// @return ptr The current calldata pointer.
    /// @dev NOTE: This file is just an integer and it can not be used
    /// to forward the calldata to the next calls in any way.
    function getCalldataPtr() internal view returns (uint256 ptr) {
        address callAddr = PTR_CALLDATA_CALL_ADDRESS;
        assembly {
            ptr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the N-th extraAbiParam for the current call.
    /// @return extraAbiData The value of the N-th extraAbiParam for this call.
    /// @dev It is equal to the value of the (N+2)-th register
    /// at the start of the call.
    function getExtraAbiData(uint256 index) internal view returns (uint256 extraAbiData) {
        require(index < 10, "There are only 10 accessible registers");

        address callAddr = GET_EXTRA_ABI_DATA_ADDRESS;
        assembly {
            extraAbiData := staticcall(index, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Retuns whether the current call is a system call.
    /// @return `true` or `false` based on whether the current call is a system call.
    function isSystemCall() internal view returns (bool) {
        uint256 callFlags = getCallFlags();
        // When the system call is passed, the 2-bit it set to 1
        return (callFlags & 2) != 0;
    }

    /// @notice Returns whether the address is a system contract.
    /// @param _address The address to test
    /// @return `true` or `false` based on whether the `_address` is a system contract.
    function isSystemContract(address _address) internal pure returns (bool) {
        return uint160(_address) <= uint160(MAX_SYSTEM_CONTRACT_ADDRESS);
    }
}

/// @dev Solidity does not allow exporting modifiers via libraries, so
/// the only way to do reuse modifiers is to have a base contract
abstract contract ISystemContract {
    /// @notice Modifier that makes sure that the method
    /// can only be called via a system call.
    modifier onlySystemCall() {
        require(
            SystemContractHelper.isSystemCall() || SystemContractHelper.isSystemContract(msg.sender),
            "This method require system call flag"
        );
        _;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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 Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 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 in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._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 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._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() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @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 {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

interface IAGWRegistry {
    function register(address account) external;

    function isAGW(address account) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {IInitable} from '../interfaces/IInitable.sol';
import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';

interface IModule is IInitable, IERC165 {}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

library AGWStorage {
    //keccak256('agw.contracts.AGWStorage') - 1
    bytes32 private constant AGW_STORAGE_SLOT =
        0x67641650ff26a63f6b1fb8b1cb96de5bac5c28fcfcca35c9518ea6966d32d42d;

    struct Layout {
        // ┌───────────────────┐
        // │   Ownership Data  │
        mapping(bytes => bytes) r1Owners;
        mapping(address => address) k1Owners;
        uint256[50] __gap_0;
        // └───────────────────┘

        // ┌───────────────────┐
        // │     Fallback      │
        address defaultFallbackContract; // for next version
        uint256[50] __gap_1;
        // └───────────────────┘

        // ┌───────────────────┐
        // │     Validation    │
        mapping(address => address) r1Validators;
        mapping(address => address) k1Validators;
        mapping(address => address) moduleValidators;
        uint256[49] __gap_2;
        // └───────────────────┘

        // ┌───────────────────┐
        // │       Module      │
        mapping(address => address) modules;
        uint256[50] __gap_3;
        // └───────────────────┘

        // ┌───────────────────┐
        // │       Hooks       │
        mapping(address => address) validationHooks;
        mapping(address => address) executionHooks;
        mapping(address => mapping(bytes32 => bytes)) hookDataStore;
        uint256[50] __gap_4;
        // └───────────────────┘
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = AGW_STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

interface IInitable {
    event Inited(address indexed account);
    event Disabled(address indexed account);

    function init(bytes calldata initData) external;

    function disable() external;

    function isInited(address account) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';

/**
 * @title Bytes linked list library
 * @notice Helper library for bytes linkedlist operations
 * @author https://getclave.io
 */
library BytesLinkedList {
    bytes internal constant SENTINEL_BYTES = hex'00';
    uint8 internal constant SENTINEL_LENGTH = 1;

    modifier validBytes(bytes calldata value) {
        if (value.length <= SENTINEL_LENGTH) {
            revert Errors.INVALID_BYTES();
        }
        _;
    }

    function add(
        mapping(bytes => bytes) storage self,
        bytes calldata value
    ) internal validBytes(value) {
        if (self[value].length != 0) {
            revert Errors.BYTES_ALREADY_EXISTS();
        }

        bytes memory prev = self[SENTINEL_BYTES];
        if (prev.length < SENTINEL_LENGTH) {
            self[SENTINEL_BYTES] = value;
            self[value] = SENTINEL_BYTES;
        } else {
            self[SENTINEL_BYTES] = value;
            self[value] = prev;
        }
    }

    function replace(
        mapping(bytes => bytes) storage self,
        bytes calldata oldValue,
        bytes calldata newValue
    ) internal {
        if (!exists(self, oldValue)) {
            revert Errors.BYTES_NOT_EXISTS();
        }
        if (exists(self, newValue)) {
            revert Errors.BYTES_ALREADY_EXISTS();
        }

        bytes memory cursor = SENTINEL_BYTES;
        while (true) {
            bytes memory _value = self[cursor];
            if (equals(_value, oldValue)) {
                bytes memory next = self[_value];
                self[newValue] = next;
                self[cursor] = newValue;
                delete self[_value];
                return;
            }
            cursor = _value;
        }
    }

    function replaceUsingPrev(
        mapping(bytes => bytes) storage self,
        bytes calldata prevValue,
        bytes calldata oldValue,
        bytes calldata newValue
    ) internal {
        if (!exists(self, oldValue)) {
            revert Errors.BYTES_NOT_EXISTS();
        }
        if (exists(self, newValue)) {
            revert Errors.BYTES_ALREADY_EXISTS();
        }
        if (!equals(self[prevValue], oldValue)) {
            revert Errors.INVALID_PREV();
        }

        self[newValue] = self[oldValue];
        self[prevValue] = newValue;
        delete self[oldValue];
    }

    function remove(mapping(bytes => bytes) storage self, bytes calldata value) internal {
        if (!exists(self, value)) {
            revert Errors.BYTES_NOT_EXISTS();
        }

        bytes memory cursor = SENTINEL_BYTES;
        while (true) {
            bytes memory _value = self[cursor];
            if (equals(_value, value)) {
                bytes memory next = self[_value];
                self[cursor] = next;
                delete self[_value];
                return;
            }
            cursor = _value;
        }
    }

    function removeUsingPrev(
        mapping(bytes => bytes) storage self,
        bytes calldata prevValue,
        bytes calldata value
    ) internal {
        if (!exists(self, value)) {
            revert Errors.BYTES_NOT_EXISTS();
        }
        if (!equals(self[prevValue], value)) {
            revert Errors.INVALID_PREV();
        }

        self[prevValue] = self[value];
        delete self[value];
    }

    function clear(mapping(bytes => bytes) storage self) internal {
        bytes memory cursor = SENTINEL_BYTES;
        do {
            bytes memory nextCursor = self[cursor];
            delete self[cursor];
            cursor = nextCursor;
        } while (cursor.length > SENTINEL_LENGTH);
    }

    function exists(
        mapping(bytes => bytes) storage self,
        bytes calldata value
    ) internal view validBytes(value) returns (bool) {
        return self[value].length != 0;
    }

    function size(mapping(bytes => bytes) storage self) internal view returns (uint256) {
        uint256 result = 0;
        bytes memory cursor = self[SENTINEL_BYTES];
        while (cursor.length > SENTINEL_LENGTH) {
            cursor = self[cursor];
            unchecked {
                result++;
            }
        }
        return result;
    }

    function isEmpty(mapping(bytes => bytes) storage self) internal view returns (bool) {
        return self[SENTINEL_BYTES].length <= SENTINEL_LENGTH;
    }

    function list(mapping(bytes => bytes) storage self) internal view returns (bytes[] memory) {
        uint256 _size = size(self);
        bytes[] memory result = new bytes[](_size);
        uint256 i = 0;
        bytes memory cursor = self[SENTINEL_BYTES];
        while (cursor.length > SENTINEL_LENGTH) {
            result[i] = cursor;
            cursor = self[cursor];
            unchecked {
                i++;
            }
        }

        return result;
    }

    function equals(bytes memory a, bytes memory b) private pure returns (bool result) {
        assembly {
            result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
        }
    }
}

/**
 * @title Address linked list library
 * @notice Helper library for address linkedlist operations
 */
library AddressLinkedList {
    address internal constant SENTINEL_ADDRESS = address(1);

    modifier validAddress(address value) {
        if (value <= SENTINEL_ADDRESS) {
            revert Errors.INVALID_ADDRESS();
        }
        _;
    }

    function add(
        mapping(address => address) storage self,
        address value
    ) internal validAddress(value) {
        if (self[value] != address(0)) {
            revert Errors.ADDRESS_ALREADY_EXISTS();
        }

        address prev = self[SENTINEL_ADDRESS];
        if (prev == address(0)) {
            self[SENTINEL_ADDRESS] = value;
            self[value] = SENTINEL_ADDRESS;
        } else {
            self[SENTINEL_ADDRESS] = value;
            self[value] = prev;
        }
    }

    function replace(
        mapping(address => address) storage self,
        address oldValue,
        address newValue
    ) internal {
        if (!exists(self, oldValue)) {
            revert Errors.ADDRESS_NOT_EXISTS();
        }
        if (exists(self, newValue)) {
            revert Errors.ADDRESS_ALREADY_EXISTS();
        }

        address cursor = SENTINEL_ADDRESS;
        while (true) {
            address _value = self[cursor];
            if (_value == oldValue) {
                address next = self[_value];
                self[newValue] = next;
                self[cursor] = newValue;
                delete self[_value];
                return;
            }
            cursor = _value;
        }
    }

    function replaceUsingPrev(
        mapping(address => address) storage self,
        address prevValue,
        address oldValue,
        address newValue
    ) internal {
        if (!exists(self, oldValue)) {
            revert Errors.ADDRESS_NOT_EXISTS();
        }
        if (exists(self, newValue)) {
            revert Errors.ADDRESS_ALREADY_EXISTS();
        }
        if (self[prevValue] != oldValue) {
            revert Errors.INVALID_PREV();
        }

        self[newValue] = self[oldValue];
        self[prevValue] = newValue;
        delete self[oldValue];
    }

    function remove(mapping(address => address) storage self, address value) internal {
        if (!exists(self, value)) {
            revert Errors.ADDRESS_NOT_EXISTS();
        }

        address cursor = SENTINEL_ADDRESS;
        while (true) {
            address _value = self[cursor];
            if (_value == value) {
                address next = self[_value];
                self[cursor] = next;
                delete self[_value];
                return;
            }
            cursor = _value;
        }
    }

    function removeUsingPrev(
        mapping(address => address) storage self,
        address prevValue,
        address value
    ) internal {
        if (!exists(self, value)) {
            revert Errors.ADDRESS_NOT_EXISTS();
        }
        if (self[prevValue] != value) {
            revert Errors.INVALID_PREV();
        }

        self[prevValue] = self[value];
        delete self[value];
    }

    function clear(mapping(address => address) storage self) internal {
        address cursor = SENTINEL_ADDRESS;
        do {
            address nextCursor = self[cursor];
            delete self[cursor];
            cursor = nextCursor;
        } while (cursor > SENTINEL_ADDRESS);
    }

    function exists(
        mapping(address => address) storage self,
        address value
    ) internal view validAddress(value) returns (bool) {
        return self[value] != address(0);
    }

    function size(mapping(address => address) storage self) internal view returns (uint256) {
        uint256 result = 0;
        address cursor = self[SENTINEL_ADDRESS];
        while (cursor > SENTINEL_ADDRESS) {
            cursor = self[cursor];
            unchecked {
                result++;
            }
        }
        return result;
    }

    function isEmpty(mapping(address => address) storage self) internal view returns (bool) {
        return self[SENTINEL_ADDRESS] <= SENTINEL_ADDRESS;
    }

    function list(
        mapping(address => address) storage self
    ) internal view returns (address[] memory) {
        uint256 _size = size(self);
        address[] memory result = new address[](_size);
        uint256 i = 0;
        address cursor = self[SENTINEL_ADDRESS];
        while (cursor > SENTINEL_ADDRESS) {
            result[i] = cursor;
            cursor = self[cursor];
            unchecked {
                i++;
            }
        }

        return result;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {BootloaderAuth} from './BootloaderAuth.sol';
import {ModuleAuth} from './ModuleAuth.sol';
import {SelfAuth} from './SelfAuth.sol';
import {HookAuth} from './HookAuth.sol';
import {Errors} from '../libraries/Errors.sol';

/**
 * @title Auth
 * @notice Abstract contract that organizes authentification logic for the contract
 * @author https://getclave.io
 */
abstract contract Auth is BootloaderAuth, SelfAuth, ModuleAuth, HookAuth {
    modifier onlySelfOrModule() {
        if (msg.sender != address(this) && !_isModule(msg.sender)) {
            revert Errors.NOT_FROM_SELF_OR_MODULE();
        }
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

/**
 * @title Interface of the manager contract for modules
 * @author https://getclave.io
 */
interface IModuleManager {
    /**
     * @notice Event emitted when a module is added
     * @param module address - Address of the added module
     */
    event AddModule(address indexed module);

    /**
     * @notice Event emitted when a module is removed
     * @param module address - Address of the removed module
     */
    event RemoveModule(address indexed module);

    /**
     * @notice Add a module to the list of modules and call it's init function
     * @dev Can only be called by self or a module
     * @param moduleAndData bytes calldata - Address of the module and data to initialize it with
     */
    function addModule(bytes calldata moduleAndData) external;

    /**
     * @notice Remove a module from the list of modules and call it's disable function
     * @dev Can only be called by self or a module
     * @param module address - Address of the module to remove
     */
    function removeModule(address module) external;

    /**
     * @notice Allow modules to execute arbitrary calls on behalf of the account
     * @dev Can only be called by a module
     * @param to address - Address to call
     * @param value uint256 - Eth to send with call
     * @param data bytes memory - Data to make the call with
     */
    function executeFromModule(address to, uint256 value, bytes memory data) external;

    /**
     * @notice Check if an address is in the list of modules
     * @param addr address - Address to check
     * @return bool - True if the address is a module, false otherwise
     */
    function isModule(address addr) external view returns (bool);

    /**
     * @notice Get the list of modules
     * @return moduleList address[] memory - List of modules
     */
    function listModules() external view returns (address[] memory moduleList);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {SignatureDecoder} from '../libraries/SignatureDecoder.sol';
import {BytesLinkedList, AddressLinkedList} from '../libraries/LinkedList.sol';
import {OwnerManager} from '../managers/OwnerManager.sol';
import {ValidatorManager} from '../managers/ValidatorManager.sol';

import {IK1Validator, IR1Validator} from '../interfaces/IValidator.sol';
import {IModuleValidator} from '../interfaces/IModuleValidator.sol';
import {OperationType} from '../interfaces/IValidator.sol';

/**
 * @title ValidationHandler
 * @notice Contract which calls validators for signature validation
 * @author https://getclave.io
 */
abstract contract ValidationHandler is OwnerManager, ValidatorManager {
    function _handleValidation(
        address validator,
        OperationType operationType,
        bytes32 signedHash,
        bytes memory signature
    ) internal view returns (bool) {
        if (validator <= AddressLinkedList.SENTINEL_ADDRESS) {
            // address less than or equal to sentinel address can't be used in linked list
            // implementation so this scenario is never valid
            return false;
        } else if (_r1IsValidator(validator)) {
            mapping(bytes => bytes) storage owners = OwnerManager._r1OwnersLinkedList();
            bytes memory cursor = owners[BytesLinkedList.SENTINEL_BYTES];
            while (cursor.length > BytesLinkedList.SENTINEL_LENGTH) {
                bytes32[2] memory pubKey = abi.decode(cursor, (bytes32[2]));

                bool _success = IR1Validator(validator).validateSignature(
                    operationType,
                    signedHash,
                    signature,
                    pubKey
                );

                if (_success) {
                    return true;
                }

                cursor = owners[cursor];
            }
        } else if (_k1IsValidator(validator)) {
            address recoveredAddress = IK1Validator(validator).validateSignature(
                operationType,
                signedHash,
                signature
            );

            if (recoveredAddress == address(0)) {
                return false;
            }

            if (OwnerManager._k1IsOwner(recoveredAddress)) {
                return true;
            }
        } else if ( _isModuleValidator(validator)) {
            return IModuleValidator(validator).handleValidation(operationType, signedHash, signature);
        }

        return false;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

/**
 * @title Interface of the upgrade manager contract
 * @author https://getclave.io
 */
interface IUpgradeManager {
    /**
     * @notice Event emitted when the contract is upgraded
     * @param oldImplementation address - Address of the old implementation contract
     * @param newImplementation address - Address of the new implementation contract
     */
    event Upgraded(address indexed oldImplementation, address indexed newImplementation);

    /**
     * @notice Upgrades the account contract to a new implementation
     * @dev Can only be called by self
     * @param newImplementation address - Address of the new implementation contract
     */
    function upgradeTo(address newImplementation) external;

    /**
     * @notice Returns the current implementation address
     * @return address - Address of the current implementation contract
     */
    function implementationAddress() external view returns (address);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Transaction} from '@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol';
import {IInitable} from '../interfaces/IInitable.sol';
import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';

interface IValidationHook is IInitable, IERC165 {
    function validationHook(
        bytes32 signedHash,
        Transaction calldata transaction,
        bytes calldata hookData
    ) external;
}

interface IExecutionHook is IInitable, IERC165 {
    function preExecutionHook(
        Transaction calldata transaction
    ) external returns (bytes memory context);

    function postExecutionHook(bytes memory context) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

/**
 * @title Interface of the manager contract for hooks
 * @author https://getclave.io
 */
interface IHookManager {
    /**
     * @notice Event emitted when a hook is added
     * @param hook address - Address of the added hook
     */
    event AddHook(address indexed hook);

    /**
     * @notice Event emitted when a hook is removed
     * @param hook address - Address of the removed hook
     */
    event RemoveHook(address indexed hook);

    /**
     * @notice Add a hook to the list of hooks and call it's init function
     * @dev Can only be called by self or a module
     * @param hookAndData bytes calldata - Address of the hook and data to initialize it with
     * @param isValidation bool          - True if the hook is a validation hook, false otherwise
     */
    function addHook(bytes calldata hookAndData, bool isValidation) external;

    /**
     * @notice Remove a hook from the list of hooks and call it's disable function
     * @dev Can only be called by self or a module
     * @param hook address      - Address of the hook to remove
     * @param isValidation bool - True if the hook is a validation hook, false otherwise
     */
    function removeHook(address hook, bool isValidation) external;

    /**
     * @notice Allow a hook to store data in the contract
     * @dev Can only be called by a hook
     * @param key bytes32         - Slot to store data at
     * @param data bytes calldata - Data to store
     */
    function setHookData(bytes32 key, bytes calldata data) external;

    /**
     * @notice Get the data stored by a hook
     * @param hook address  - Address of the hook to retrieve data for
     * @param key bytes32   - Slot to retrieve data from
     * @return bytes memory - Data stored at the slot
     */
    function getHookData(address hook, bytes32 key) external view returns (bytes memory);

    /**
     * @notice Check if an address is in the list of hooks
     * @param addr address - Address to check
     * @return bool        - True if the address is a hook, false otherwise
     */
    function isHook(address addr) external view returns (bool);

    /**
     * @notice Get the list of validation or execution hooks
     * @param isValidation bool          - True if the list of validation hooks should be returned, false otherwise
     * @return hookList address[] memory - List of validation or exeuction hooks
     */
    function listHooks(bool isValidation) external view returns (address[] memory hookList);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';

/**
 * @title SelfAuth
 * @notice Abstract contract that allows only calls by the self contract
 * @author https://getclave.io
 */
abstract contract SelfAuth {
    modifier onlySelf() {
        if (msg.sender != address(this)) {
            revert Errors.NOT_FROM_SELF();
        }
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

/**
 * @title Interface of the manager contract for owners
 * @author https://getclave.io
 */
interface IOwnerManager {
    /**
     * @notice Event emitted when a r1 owner is added
     * @param pubKey bytes - r1 owner that has been added
     */
    event R1AddOwner(bytes pubKey);

    /**
     * @notice Event emitted when a k1 owner is added
     * @param addr address - k1 owner that has been added
     */
    event K1AddOwner(address indexed addr);

    /**
     * @notice Event emitted when a r1 owner is removed
     * @param pubKey bytes - r1 owner that has been removed
     */
    event R1RemoveOwner(bytes pubKey);

    /**
     * @notice Event emitted when a k1 owner is removed
     * @param addr address - k1 owner that has been removed
     */
    event K1RemoveOwner(address indexed addr);

    /**
     * @notice Event emitted when all owners are cleared
     */
    event ResetOwners();

    /**
     * @notice Adds a r1 owner to the list of r1 owners
     * @dev Can only be called by self or a whitelisted module
     * @dev Public Key length must be 64 bytes
     * @param pubKey bytes calldata - Public key to add to the list of r1 owners
     */
    function r1AddOwner(bytes calldata pubKey) external;

    /**
     * @notice Adds a k1 owner to the list of k1 owners
     * @dev Can only be called by self or a whitelisted module
     * @dev Address can not be the zero address
     * @param addr address - Address to add to the list of k1 owners
     */
    function k1AddOwner(address addr) external;

    /**
     * @notice Removes a r1 owner from the list of r1 owners
     * @dev Can only be called by self or a whitelisted module
     * @dev Can not remove the last r1 owner
     * @param pubKey bytes calldata - Public key to remove from the list of r1 owners
     */
    function r1RemoveOwner(bytes calldata pubKey) external;

    /**
     * @notice Removes a k1 owner from the list of k1 owners
     * @dev Can only be called by self or a whitelisted module
     * @param addr address - Address to remove from the list of k1 owners
     */
    function k1RemoveOwner(address addr) external;

    /**
     * @notice Clears both r1 owners and k1 owners and adds an r1 owner
     * @dev Can only be called by self or a whitelisted module
     * @dev Public Key length must be 64 bytes
     * @param pubKey bytes calldata - new r1 owner to add
     */
    function resetOwners(bytes calldata pubKey) external;

    /**
     * @notice Checks if a public key is in the list of r1 owners
     * @param pubKey bytes calldata - Public key to check
     * @return bool - True if the public key is in the list, false otherwise
     */
    function r1IsOwner(bytes calldata pubKey) external view returns (bool);

    /**
     * @notice Checks if an address is in the list of k1 owners
     * @param addr address - Address to check
     * @return bool - True if the address is in the list, false otherwise
     */
    function k1IsOwner(address addr) external view returns (bool);

    /**
     * @notice Returns the list of r1 owners
     * @return r1OwnerList bytes[] memory - Array of r1 owner public keys
     */
    function r1ListOwners() external view returns (bytes[] memory r1OwnerList);

    /**
     * @notice Returns the list of k1 owners
     * @return k1OwnerList address[] memory - Array of k1 owner addresses
     */
    function k1ListOwners() external view returns (address[] memory k1OwnerList);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

/**
 * @title Manager contract for validators
 * @author https://getclave.io
 */
interface IValidatorManager {
    /**
     * @notice Event emitted when a r1 validator is added
     * @param validator address - Address of the added r1 validator
     */
    event R1AddValidator(address indexed validator);

    /**
     * @notice Event emitted when a k1 validator is added
     * @param validator address - Address of the added k1 validator
     */
    event K1AddValidator(address indexed validator);

    /**
     * @notice Event emitted when a modular validator is added
     * @param validator address - Address of the added modular validator
     */
    event AddModuleValidator(address indexed validator);

    /**
     * @notice Event emitted when a r1 validator is removed
     * @param validator address - Address of the removed r1 validator
     */
    event R1RemoveValidator(address indexed validator);

    /**
     * @notice Event emitted when a k1 validator is removed
     * @param validator address - Address of the removed k1 validator
     */
    event K1RemoveValidator(address indexed validator);

    /**
     * @notice Event emitted when a modular validator is removed
     * @param validator address - Address of the removed modular validator
     */
    event RemoveModuleValidator(address indexed validator);

    /**
     * @notice Adds a validator to the list of r1 validators
     * @dev Can only be called by self or a whitelisted module
     * @param validator address - Address of the r1 validator to add
     */
    function r1AddValidator(address validator) external;

    /**
     * @notice Adds a validator to the list of modular validators
     * @dev Can only be called by self or a whitelisted module
     * @param validator address - Address of the generic validator to add
     * @param accountValidationKey bytes - data for the validator to use to validate the account
     */
    function addModuleValidator(address validator, bytes memory accountValidationKey) external;

    /**
     * @notice Adds a validator to the list of k1 validators
     * @dev Can only be called by self or a whitelisted module
     * @param validator address - Address of the k1 validator to add
     */
    function k1AddValidator(address validator) external;

    /**
     * @notice Removes a validator from the list of r1 validators
     * @dev Can only be called by self or a whitelisted module
     * @dev Can not remove the last validator
     * @param validator address - Address of the validator to remove
     */
    function r1RemoveValidator(address validator) external;

    /**
     * @notice Removes a validator from the list of k1 validators
     * @dev Can only be called by self or a whitelisted module
     * @param validator address - Address of the validator to remove
     */
    function k1RemoveValidator(address validator) external;

    /**
     * @notice Removes a validator from the list of modular validators
     * @dev Can only be called by self or a whitelisted module
     * @param validator address - Address of the validator to remove
     */
    function removeModuleValidator(address validator) external;

    /**
     * @notice Checks if an address is in the r1 validator list
     * @param validator address -Address of the validator to check
     * @return True if the address is a validator, false otherwise
     */
    function r1IsValidator(address validator) external view returns (bool);

    /**
     * @notice Checks if an address is in the k1 validator list
     * @param validator address - Address of the validator to check
     * @return True if the address is a validator, false otherwise
     */
    function k1IsValidator(address validator) external view returns (bool);

    /**
     * @notice Checks if an address is in the modular validator list
     * @param validator address - Address of the validator to check
     * @return True if the address is a validator, false otherwise
     */
    function isModuleValidator(address validator) external view returns (bool);

    /**
     * @notice Returns the list of r1 validators
     * @return validatorList address[] memory - Array of r1 validator addresses
     */
    function r1ListValidators() external view returns (address[] memory validatorList);

    /**
     * @notice Returns the list of k1 validators
     * @return validatorList address[] memory - Array of k1 validator addresses
     */
    function k1ListValidators() external view returns (address[] memory validatorList);


    /**
     * @notice Returns the list of modular validators
     * @return validatorList address[] memory - Array of modular validator addresses
     */
    function listModuleValidators() external view returns (address[] memory validatorList);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.20;

import {Ownable} from "./Ownable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This extension of the {Ownable} contract includes a two-step mechanism to transfer
 * ownership, where the new owner must call {acceptOwnership} in order to replace the
 * old one. This can help prevent common mistakes, such as transfers of ownership to
 * incorrect accounts, or to contracts that are unable to interact with the
 * permission system.
 *
 * The initial owner is specified at deployment time in the constructor for `Ownable`. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     *
     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        if (pendingOwner() != sender) {
            revert OwnableUnauthorizedAccount(sender);
        }
        _transferOwnership(sender);
    }
}

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

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.7.6;

library ExcessivelySafeCall {
    uint256 constant LOW_28_MASK =
        0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    /// @notice Use when you _really_ really _really_ don't trust the called
    /// contract. This prevents the called contract from causing reversion of
    /// the caller in as many ways as we can.
    /// @dev The main difference between this and a solidity low-level call is
    /// that we limit the number of bytes that the callee can cause to be
    /// copied to caller memory. This prevents stupid things like malicious
    /// contracts returning 10,000,000 bytes causing a local OOG when copying
    /// to memory.
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _value The value in wei to send to the remote contract
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function excessivelySafeCall(
        address _target,
        uint256 _gas,
        uint256 _value,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal returns (bool, bytes memory) {
        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := call(
                _gas, // gas
                _target, // recipient
                _value, // ether value
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 256 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }

    /// @notice Use when you _really_ really _really_ don't trust the called
    /// contract. This prevents the called contract from causing reversion of
    /// the caller in as many ways as we can.
    /// @dev The main difference between this and a solidity low-level call is
    /// that we limit the number of bytes that the callee can cause to be
    /// copied to caller memory. This prevents stupid things like malicious
    /// contracts returning 10,000,000 bytes causing a local OOG when copying
    /// to memory.
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function excessivelySafeStaticCall(
        address _target,
        uint256 _gas,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal view returns (bool, bytes memory) {
        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := staticcall(
                _gas, // gas
                _target, // recipient
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 256 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }

    /**
     * @notice Swaps function selectors in encoded contract calls
     * @dev Allows reuse of encoded calldata for functions with identical
     * argument types but different names. It simply swaps out the first 4 bytes
     * for the new selector. This function modifies memory in place, and should
     * only be used with caution.
     * @param _newSelector The new 4-byte selector
     * @param _buf The encoded contract args
     */
    function swapSelector(bytes4 _newSelector, bytes memory _buf)
        internal
        pure
    {
        require(_buf.length >= 4);
        uint256 _mask = LOW_28_MASK;
        assembly {
            // load the first word of
            let _word := mload(add(_buf, 0x20))
            // mask out the top 4 bytes
            // /x
            _word := and(_word, _mask)
            _word := or(_newSelector, _word)
            mstore(add(_buf, 0x20), _word)
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-777 Tokens Recipient standard as defined in the ERC.
 *
 * 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[ERC-1820 global registry].
 *
 * See {IERC1820Registry} and {IERC1820Implementer}.
 */
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;
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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 v5.0.0) (interfaces/IERC721Receiver.sol)

pragma solidity ^0.8.20;

import {IERC721Receiver} from "../token/ERC721/IERC721Receiver.sol";

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

pragma solidity ^0.8.20;

import {IERC165} from "./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 ERC-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 ERC-165 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 ERC-165 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}.
     */
    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 ERC-165 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 ERC-165 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 ERC-165 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 ERC-165, 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.encodeCall(IERC165.supportsInterface, (interfaceId));

        // perform static call
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            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: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

import {IERC1155Receiver} from "../token/ERC1155/IERC1155Receiver.sol";

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

pragma solidity ^0.8.20;

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 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 v5.1.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC-1155 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 ERC-1155 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 v5.1.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;

import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 */
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @custom:storage-location erc7201:openzeppelin.storage.EIP712
    struct EIP712Storage {
        /// @custom:oz-renamed-from _HASHED_NAME
        bytes32 _hashedName;
        /// @custom:oz-renamed-from _HASHED_VERSION
        bytes32 _hashedVersion;

        string _name;
        string _version;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.EIP712")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;

    function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
        assembly {
            $.slot := EIP712StorageLocation
        }
    }

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        EIP712Storage storage $ = _getEIP712Storage();
        $._name = name;
        $._version = version;

        // Reset prior values in storage if upgrading
        $._hashedName = 0;
        $._hashedVersion = 0;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator();
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        EIP712Storage storage $ = _getEIP712Storage();
        // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
        // and the EIP712 domain is not reliable, as it will be missing name and version.
        require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");

        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Name() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._name;
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Version() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._version;
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
     */
    function _EIP712NameHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory name = _EIP712Name();
        if (bytes(name).length > 0) {
            return keccak256(bytes(name));
        } else {
            // If the name is empty, the contract may have been upgraded without initializing the new storage.
            // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
            bytes32 hashedName = $._hashedName;
            if (hashedName != 0) {
                return hashedName;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
     */
    function _EIP712VersionHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory version = _EIP712Version();
        if (bytes(version).length > 0) {
            return keccak256(bytes(version));
        } else {
            // If the version is empty, the contract may have been upgraded without initializing the new storage.
            // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
            bytes32 hashedVersion = $._hashedVersion;
            if (hashedVersion != 0) {
                return hashedVersion;
            } else {
                return keccak256("");
            }
        }
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {BOOTLOADER_FORMAL_ADDRESS} from '@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol';
import {Errors} from '../libraries/Errors.sol';

/**
 * @title BootloaderAuth
 * @notice Abstract contract that allows only calls from bootloader
 * @author https://getclave.io
 */
abstract contract BootloaderAuth {
    modifier onlyBootloader() {
        if (msg.sender != BOOTLOADER_FORMAL_ADDRESS) {
            revert Errors.NOT_FROM_BOOTLOADER();
        }
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';

/**
 * @title ModuleAuth
 * @notice Abstract contract that allows only calls from modules
 * @author https://getclave.io
 */
abstract contract ModuleAuth {
    function _isModule(address addr) internal view virtual returns (bool);

    modifier onlyModule() {
        if (!_isModule(msg.sender)) {
            revert Errors.NOT_FROM_MODULE();
        }
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {Errors} from '../libraries/Errors.sol';

/**
 * @title HookAuth
 * @notice Abstract contract that allows only calls from hooks
 * @author https://getclave.io
 */
abstract contract HookAuth {
    function _isHook(address addr) internal view virtual returns (bool);

    modifier onlyHook() {
        if (!_isHook(msg.sender)) {
            revert Errors.NOT_FROM_HOOK();
        }
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.17;

import {AGWStorage} from '../libraries/AGWStorage.sol';
import {BytesLinkedList, AddressLinkedList} from '../libraries/LinkedList.sol';
import {Errors} from '../libraries/Errors.sol';
import {Auth} from '../auth/Auth.sol';
import {IAGWAccount} from '../interfaces/IAGWAccount.sol';
import {IOwnerManager} from '../interfaces/IOwnerManager.sol';

/**
 * @title Manager contract for owners
 * @notice Abstract contract for managing the owners of the account
 * @dev R1 Owners are 64 byte secp256r1 public keys
 * @dev K1 Owners are secp256k1 addresses
 * @dev Owners are stored in a linked list
 * @author https://getclave.io
 */
abstract contract OwnerManager is IOwnerManager, Auth {
    // Helper library for bytes to bytes mappings
    using BytesLinkedList for mapping(bytes => bytes);
    // Helper library for address to address mappings
    using AddressLinkedList for mapping(address => address);

    /// @inheritdoc IOwnerManager
    function r1AddOwner(bytes calldata pubKey) external override onlySelfOrModule {
        _r1AddOwner(pubKey);
    }

    /// @inheritdoc IOwnerManager
    function k1AddOwner(address addr) external override onlySelfOrModule {
        _k1AddOwner(addr);
    }

    /// @inheritdoc IOwnerManager
    function r1RemoveOwner(bytes calldata pubKey) external override onlySelfOrModule {
        _r1RemoveOwner(pubKey);
    }

    /// @inheritdoc IOwnerManager
    function k1RemoveOwner(address addr) external override onlySelfOrModule {
        _k1RemoveOwner(addr);
    }

    /// @inheritdoc IOwnerManager
    function resetOwners(bytes calldata pubKey) external override onlySelfOrModule {
        _r1ClearOwners();
        _k1ClearOwners();

        emit ResetOwners();

        _r1AddOwner(pubKey);
    }

    /// @inheritdoc IOwnerManager
    function r1IsOwner(bytes calldata pubKey) external view override returns (bool) {
        return _r1IsOwner(pubKey);
    }

    /// @inheritdoc IOwnerManager
    function k1IsOwner(address addr) external view override returns (bool) {
        return _k1IsOwner(addr);
    }

    /// @inheritdoc IOwnerManager
    function r1ListOwners() external view override returns (bytes[] memory r1OwnerList) {
        r1OwnerList = _r1OwnersLinkedList().list();
    }

    /// @inheritdoc IOwnerManager
    function k1ListOwners() external view override returns (address[] memory k1OwnerList) {
        k1OwnerList = _k1OwnersLinkedList().list();
    }

    function _r1AddOwner(bytes calldata pubKey) internal {
        if (pubKey.length != 64) {
            revert Errors.INVALID_PUBKEY_LENGTH();
        }

        _r1OwnersLinkedList().add(pubKey);

        emit R1AddOwner(pubKey);
    }

    function _k1AddOwner(address addr) internal {
        _k1OwnersLinkedList().add(addr);

        emit K1AddOwner(addr);
    }

    function _r1RemoveOwner(bytes calldata pubKey) internal {
        _r1OwnersLinkedList().remove(pubKey);

        emit R1RemoveOwner(pubKey);
    }

    function _k1RemoveOwner(address addr) internal {
        _k1OwnersLinkedList().remove(addr);

        // The wallet should have at least one owner
        if (_k1OwnersLinkedList().isEmpty()) {
            revert Errors.EMPTY_OWNERS();
        }

        emit K1RemoveOwner(addr);
    }

    function _r1IsOwner(bytes calldata pubKey) internal view returns (bool) {
        return _r1OwnersLinkedList().exists(pubKey);
    }

    function _k1IsOwner(address addr) internal view returns (bool) {
        return _k1OwnersLinkedList().exists(addr);
    }

    function _r1OwnersLinkedList()
        internal
        view
        returns (mapping(bytes => bytes) storage r1Owners)
    {
        r1Owners = AGWStorage.layout().r1Owners;
    }

    function _k1OwnersLinkedList()
        internal
        view
        returns (mapping(address => address) storage k1Owners)
    {
        k1Owners = AGWStorage.layout().k1Owners;
    }

    function _r1ClearOwners() private {
        _r1OwnersLinkedList().clear();
    }

    function _k1ClearOwners() private {
        _k1OwnersLinkedList().clear();
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";

import { Auth } from "../auth/Auth.sol";
import { Errors } from "../libraries/Errors.sol";
import {AGWStorage} from '../libraries/AGWStorage.sol';
import { AddressLinkedList } from "../libraries/LinkedList.sol";
import { IR1Validator, IK1Validator } from "../interfaces/IValidator.sol";
import { IValidatorManager } from "../interfaces/IValidatorManager.sol";
import { IModuleValidator } from "../interfaces/IModuleValidator.sol";

/**
 * @title Manager contract for validators
 * @notice Abstract contract for managing the validators of the account
 * @dev Validators are stored in a linked list
 * @author https://getclave.io
 */
abstract contract ValidatorManager is IValidatorManager, Auth {
    // Helper library for address to address mappings
    using AddressLinkedList for mapping(address => address);
    // Interface helper library
    using ERC165Checker for address;

    /// @inheritdoc IValidatorManager
    function r1AddValidator(address validator) external override onlySelfOrModule {
        _r1AddValidator(validator);
    }

    function addModuleValidator(address validator, bytes memory initialAccountValidationKey) external onlySelfOrModule {
        _addModuleValidator(validator, initialAccountValidationKey);
    }

    /// @inheritdoc IValidatorManager
    function k1AddValidator(address validator) external override onlySelfOrModule {
        _k1AddValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function r1RemoveValidator(address validator) external override onlySelfOrModule {
        _r1RemoveValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function k1RemoveValidator(address validator) external override onlySelfOrModule {
        _k1RemoveValidator(validator);
    }

    ///@inheritdoc IValidatorManager
    function removeModuleValidator(address validator) external onlySelfOrModule {
        _removeModuleValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function r1IsValidator(address validator) external view override returns (bool) {
        return _r1IsValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function k1IsValidator(address validator) external view override returns (bool) {
        return _k1IsValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function isModuleValidator(address validator) external view override returns (bool) {
        return _isModuleValidator(validator);
    }

    /// @inheritdoc IValidatorManager
    function r1ListValidators() external view override returns (address[] memory validatorList) {
        validatorList = _r1ValidatorsLinkedList().list();
    }

    /// @inheritdoc IValidatorManager
    function k1ListValidators() external view override returns (address[] memory validatorList) {
        validatorList = _k1ValidatorsLinkedList().list();
    }

    /// @inheritdoc IValidatorManager
    function listModuleValidators() external view override returns (address[] memory validatorList) {
        validatorList = _moduleValidatorsLinkedList().list();
    }

    function _r1AddValidator(address validator) internal {
        if (!_supportsR1(validator)) {
            revert Errors.VALIDATOR_ERC165_FAIL();
        }

        _r1ValidatorsLinkedList().add(validator);

        emit R1AddValidator(validator);
    }

    function _addModuleValidator(address validator, bytes memory accountValidationKey) internal {
        if (!_supportsModuleValidator(validator)) {
          revert Errors.VALIDATOR_ERC165_FAIL();
        }

        _moduleValidatorsLinkedList().add(validator);
        IModuleValidator(validator).addValidationKey(accountValidationKey);

        emit AddModuleValidator(validator);
    }

    function _k1AddValidator(address validator) internal {
        if (!_supportsK1(validator)) {
            revert Errors.VALIDATOR_ERC165_FAIL();
        }

        _k1ValidatorsLinkedList().add(validator);

        emit K1AddValidator(validator);
    }

    function _r1RemoveValidator(address validator) internal {
        _r1ValidatorsLinkedList().remove(validator);

        emit R1RemoveValidator(validator);
    }

    function _k1RemoveValidator(address validator) internal {
        _k1ValidatorsLinkedList().remove(validator);

        // At least one validator must be present
        if (_k1ValidatorsLinkedList().isEmpty()) {
            revert Errors.EMPTY_VALIDATORS();
        }

        emit K1RemoveValidator(validator);
    }

    function _removeModuleValidator(address validator) internal {
        _moduleValidatorsLinkedList().remove(validator);

        emit RemoveModuleValidator(validator);
    }

    function _r1IsValidator(address validator) internal view returns (bool) {
        return _r1ValidatorsLinkedList().exists(validator);
    }

    function _isModuleValidator(address validator) internal view returns (bool) {
        return _moduleValidatorsLinkedList().exists(validator);
    }

    function _k1IsValidator(address validator) internal view returns (bool) {
        return _k1ValidatorsLinkedList().exists(validator);
    }

    function _supportsR1(address validator) internal view returns (bool) {
        return validator.supportsInterface(type(IR1Validator).interfaceId);
    }

    function _supportsK1(address validator) internal view returns (bool) {
        return validator.supportsInterface(type(IK1Validator).interfaceId);
    }

    function _supportsModuleValidator(address validator) internal view returns (bool) {
        return validator.supportsInterface(type(IModuleValidator).interfaceId);
    }

    function _r1ValidatorsLinkedList()
        private
        view
        returns (mapping(address => address) storage r1Validators)
    {
        r1Validators = AGWStorage.layout().r1Validators;
    }

    function _moduleValidatorsLinkedList()
        private
        view
        returns (mapping(address => address) storage moduleValidators)
    {
        moduleValidators = AGWStorage.layout().moduleValidators;
    }

    function _k1ValidatorsLinkedList()
        private
        view
        returns (mapping(address => address) storage k1Validators)
    {
        k1Validators = AGWStorage.layout().k1Validators;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import {OperationType} from './IValidator.sol';

/**
 * @title Modular validator interface for native AA
 * @dev Add signature to module or validate existing signatures for acccount
 */
interface IModuleValidator {
  function handleValidation(OperationType operationType, bytes32 signedHash, bytes memory signature) external view returns (bool);

  function addValidationKey(bytes memory key) external returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IAccountCodeStorage {
    function storeAccountConstructingCodeHash(address _address, bytes32 _hash) external;

    function storeAccountConstructedCodeHash(address _address, bytes32 _hash) external;

    function markAccountCodeHashAsConstructed(address _address) external;

    function getRawCodeHash(address _address) external view returns (bytes32 codeHash);

    function getCodeHash(uint256 _input) external view returns (bytes32 codeHash);

    function getCodeSize(uint256 _input) external view returns (uint256 codeSize);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @dev Interface of the nonce holder contract -- a contract used by the system to ensure
 * that there is always a unique identifier for a transaction with a particular account (we call it nonce).
 * In other words, the pair of (address, nonce) should always be unique.
 * @dev Custom accounts should use methods of this contract to store nonces or other possible unique identifiers
 * for the transaction.
 */
interface INonceHolder {
    event ValueSetUnderNonce(address indexed accountAddress, uint256 indexed key, uint256 value);

    /// @dev Returns the current minimal nonce for account.
    function getMinNonce(address _address) external view returns (uint256);

    /// @dev Returns the raw version of the current minimal nonce
    /// (equal to minNonce + 2^128 * deployment nonce).
    function getRawNonce(address _address) external view returns (uint256);

    /// @dev Increases the minimal nonce for the msg.sender.
    function increaseMinNonce(uint256 _value) external returns (uint256);

    /// @dev Sets the nonce value `key` as used.
    function setValueUnderNonce(uint256 _key, uint256 _value) external;

    /// @dev Gets the value stored inside a custom nonce.
    function getValueUnderNonce(uint256 _key) external view returns (uint256);

    /// @dev A convenience method to increment the minimal nonce if it is equal
    /// to the `_expectedNonce`.
    function incrementMinNonceIfEquals(uint256 _expectedNonce) external;

    /// @dev Returns the deployment nonce for the accounts used for CREATE opcode.
    function getDeploymentNonce(address _address) external view returns (uint256);

    /// @dev Increments the deployment nonce for the account and returns the previous one.
    function incrementDeploymentNonce(address _address) external returns (uint256);

    /// @dev Determines whether a certain nonce has been already used for an account.
    function validateNonceUsage(address _address, uint256 _key, bool _shouldBeUsed) external view;

    /// @dev Returns whether a nonce has been used for an account.
    function isNonceUsed(address _address, uint256 _nonce) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/IBootloaderUtilities.sol";
import "./libraries/TransactionHelper.sol";
import "./libraries/RLPEncoder.sol";
import "./libraries/EfficientCall.sol";

/**
 * @author Matter Labs
 * @notice A contract that provides some utility methods for the bootloader
 * that is very hard to write in Yul.
 */
contract BootloaderUtilities is IBootloaderUtilities {
    using TransactionHelper for *;

    /// @notice Calculates the canonical transaction hash and the recommended transaction hash.
    /// @param _transaction The transaction.
    /// @return txHash and signedTxHash of the transaction, i.e. the transaction hash to be used in the explorer and commits to all
    /// the fields of the transaction and the recommended hash to be signed for this transaction.
    /// @dev txHash must be unique for all transactions.
    function getTransactionHashes(
        Transaction calldata _transaction
    ) external view override returns (bytes32 txHash, bytes32 signedTxHash) {
        signedTxHash = _transaction.encodeHash();
        if (_transaction.txType == EIP_712_TX_TYPE) {
            txHash = keccak256(bytes.concat(signedTxHash, EfficientCall.keccak(_transaction.signature)));
        } else if (_transaction.txType == LEGACY_TX_TYPE) {
            txHash = encodeLegacyTransactionHash(_transaction);
        } else if (_transaction.txType == EIP_1559_TX_TYPE) {
            txHash = encodeEIP1559TransactionHash(_transaction);
        } else if (_transaction.txType == EIP_2930_TX_TYPE) {
            txHash = encodeEIP2930TransactionHash(_transaction);
        } else {
            revert("Unsupported tx type");
        }
    }

    /// @notice Calculates the hash for a legacy transaction.
    /// @param _transaction The legacy transaction.
    /// @return txHash The hash of the transaction.
    function encodeLegacyTransactionHash(Transaction calldata _transaction) internal view returns (bytes32 txHash) {
        // Hash of legacy transactions are encoded as one of the:
        // - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
        // - RLP(nonce, gasPrice, gasLimit, to, value, data)
        //
        // In this RLP encoding, only the first one above list appears, so we encode each element
        // inside list and then concatenate the length of all elements with them.

        bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
        // Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
        bytes memory encodedGasParam;
        {
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
        }

        bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
        bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            // If the `chainId` is specified in the transaction, then the `v` value is encoded as
            // `35 + y + 2 * chainId == vInt + 8 + 2 * chainId`, where y - parity bit (see EIP-155).
            if (_transaction.reserved[0] != 0) {
                vInt += 8 + block.chainid * 2;
            }

            vEncoded = RLPEncoder.encodeUint256(vInt);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedNonce.length +
                encodedGasParam.length +
                encodedTo.length +
                encodedValue.length +
                encodedDataLength.length +
                _transaction.data.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    encodedListLength,
                    encodedNonce,
                    encodedGasParam,
                    encodedTo,
                    encodedValue,
                    encodedDataLength,
                    _transaction.data,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }

    /// @notice Calculates the hash for an EIP2930 transaction.
    /// @param _transaction The EIP2930 transaction.
    /// @return txHash The hash of the transaction.
    function encodeEIP2930TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedGasPrice,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            vEncoded = RLPEncoder.encodeUint256(vInt - 27);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x01",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }

    /// @notice Calculates the hash for an EIP1559 transaction.
    /// @param _transaction The legacy transaction.
    /// @return txHash The hash of the transaction.
    function encodeEIP1559TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
        // The formula for hash of EIP1559 transaction in the original proposal:
        // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
            bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedMaxPriorityFeePerGas,
                encodedMaxFeePerGas,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            vEncoded = RLPEncoder.encodeUint256(vInt - 27);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x02",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IKnownCodesStorage {
    event MarkedAsKnown(bytes32 indexed bytecodeHash, bool indexed sendBytecodeToL1);

    function markFactoryDeps(bool _shouldSendToL1, bytes32[] calldata _hashes) external;

    function markBytecodeAsPublished(
        bytes32 _bytecodeHash,
        bytes32 _l1PreimageHash,
        uint256 _l1PreimageBytesLen
    ) external;

    function getMarker(bytes32 _hash) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

struct ImmutableData {
    uint256 index;
    bytes32 value;
}

interface IImmutableSimulator {
    function getImmutable(address _dest, uint256 _index) external view returns (bytes32);

    function setImmutables(address _dest, ImmutableData[] calldata _immutables) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IContractDeployer {
    /// @notice Defines the version of the account abstraction protocol
    /// that a contract claims to follow.
    /// - `None` means that the account is just a contract and it should never be interacted
    /// with as a custom account
    /// - `Version1` means that the account follows the first version of the account abstraction protocol
    enum AccountAbstractionVersion {
        None,
        Version1
    }

    /// @notice Defines the nonce ordering used by the account
    /// - `Sequential` means that it is expected that the nonces are monotonic and increment by 1
    /// at a time (the same as EOAs).
    /// - `Arbitrary` means that the nonces for the accounts can be arbitrary. The operator
    /// should serve the transactions from such an account on a first-come-first-serve basis.
    /// @dev This ordering is more of a suggestion to the operator on how the AA expects its transactions
    /// to be processed and is not considered as a system invariant.
    enum AccountNonceOrdering {
        Sequential,
        Arbitrary
    }

    struct AccountInfo {
        AccountAbstractionVersion supportedAAVersion;
        AccountNonceOrdering nonceOrdering;
    }

    event ContractDeployed(
        address indexed deployerAddress,
        bytes32 indexed bytecodeHash,
        address indexed contractAddress
    );

    event AccountNonceOrderingUpdated(address indexed accountAddress, AccountNonceOrdering nonceOrdering);

    event AccountVersionUpdated(address indexed accountAddress, AccountAbstractionVersion aaVersion);

    function getNewAddressCreate2(
        address _sender,
        bytes32 _bytecodeHash,
        bytes32 _salt,
        bytes calldata _input
    ) external view returns (address newAddress);

    function getNewAddressCreate(address _sender, uint256 _senderNonce) external pure returns (address newAddress);

    function create2(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input
    ) external payable returns (address newAddress);

    function create2Account(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input,
        AccountAbstractionVersion _aaVersion
    ) external payable returns (address newAddress);

    /// @dev While the `_salt` parameter is not used anywhere here,
    /// it is still needed for consistency between `create` and
    /// `create2` functions (required by the compiler).
    function create(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input
    ) external payable returns (address newAddress);

    /// @dev While `_salt` is never used here, we leave it here as a parameter
    /// for the consistency with the `create` function.
    function createAccount(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input,
        AccountAbstractionVersion _aaVersion
    ) external payable returns (address newAddress);

    /// @notice Returns the information about a certain AA.
    function getAccountInfo(address _address) external view returns (AccountInfo memory info);

    /// @notice Can be called by an account to update its account version
    function updateAccountVersion(AccountAbstractionVersion _version) external;

    /// @notice Can be called by an account to update its nonce ordering
    function updateNonceOrdering(AccountNonceOrdering _nonceOrdering) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IL1Messenger {
    // Possibly in the future we will be able to track the messages sent to L1 with
    // some hooks in the VM. For now, it is much easier to track them with L2 events.
    event L1MessageSent(address indexed _sender, bytes32 indexed _hash, bytes _message);

    function sendToL1(bytes memory _message) external returns (bytes32);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @notice Contract that stores some of the context variables, that may be either
 * block-scoped, tx-scoped or system-wide.
 */
interface ISystemContext {
    function chainId() external view returns (uint256);

    function origin() external view returns (address);

    function gasPrice() external view returns (uint256);

    function blockGasLimit() external view returns (uint256);

    function coinbase() external view returns (address);

    function difficulty() external view returns (uint256);

    function baseFee() external view returns (uint256);

    function blockHash(uint256 _block) external view returns (bytes32);

    function getBlockHashEVM(uint256 _block) external view returns (bytes32);

    function getBlockNumberAndTimestamp() external view returns (uint256 blockNumber, uint256 blockTimestamp);

    // Note, that for now, the implementation of the bootloader allows this variables to
    // be incremented multiple times inside a block, so it should not relied upon right now.
    function getBlockNumber() external view returns (uint256);

    function getBlockTimestamp() external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IEthToken {
    function balanceOf(uint256) external view returns (uint256);

    function transferFromTo(address _from, address _to, uint256 _amount) external;

    function totalSupply() external view returns (uint256);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function mint(address _account, uint256 _amount) external;

    function withdraw(address _l1Receiver) external payable;

    event Mint(address indexed account, uint256 amount);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Withdrawal(address indexed _l2Sender, address indexed _l1Receiver, uint256 _amount);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IBytecodeCompressor {
    function publishCompressedBytecode(
        bytes calldata _bytecode,
        bytes calldata _rawCompressedData
    ) external payable returns (bytes32 bytecodeHash);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @dev The interface that is used for encoding/decoding of
 * different types of paymaster flows.
 * @notice This is NOT an interface to be implementated
 * by contracts. It is just used for encoding.
 */
interface IPaymasterFlow {
    function general(bytes calldata input) external;

    function approvalBased(address _token, uint256 _minAllowance, bytes calldata _innerInput) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library RLPEncoder {
    function encodeAddress(address _val) internal pure returns (bytes memory encoded) {
        // The size is equal to 20 bytes of the address itself + 1 for encoding bytes length in RLP.
        encoded = new bytes(0x15);

        bytes20 shiftedVal = bytes20(_val);
        assembly {
            // In the first byte we write the encoded length as 0x80 + 0x14 == 0x94.
            mstore(add(encoded, 0x20), 0x9400000000000000000000000000000000000000000000000000000000000000)
            // Write address data without stripping zeros.
            mstore(add(encoded, 0x21), shiftedVal)
        }
    }

    function encodeUint256(uint256 _val) internal pure returns (bytes memory encoded) {
        unchecked {
            if (_val < 128) {
                encoded = new bytes(1);
                // Handle zero as a non-value, since stripping zeroes results in an empty byte array
                encoded[0] = (_val == 0) ? bytes1(uint8(128)) : bytes1(uint8(_val));
            } else {
                uint256 hbs = _highestByteSet(_val);

                encoded = new bytes(hbs + 2);
                encoded[0] = bytes1(uint8(hbs + 0x81));

                uint256 lbs = 31 - hbs;
                uint256 shiftedVal = _val << (lbs * 8);

                assembly {
                    mstore(add(encoded, 0x21), shiftedVal)
                }
            }
        }
    }

    /// @notice Encodes the size of bytes in RLP format.
    /// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
    /// NOTE: panics if the length is 1 since the length encoding is ambiguous in this case.
    function encodeNonSingleBytesLen(uint64 _len) internal pure returns (bytes memory) {
        assert(_len != 1);
        return _encodeLength(_len, 0x80);
    }

    /// @notice Encodes the size of list items in RLP format.
    /// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
    function encodeListLen(uint64 _len) internal pure returns (bytes memory) {
        return _encodeLength(_len, 0xc0);
    }

    function _encodeLength(uint64 _len, uint256 _offset) private pure returns (bytes memory encoded) {
        unchecked {
            if (_len < 56) {
                encoded = new bytes(1);
                encoded[0] = bytes1(uint8(_len + _offset));
            } else {
                uint256 hbs = _highestByteSet(uint256(_len));

                encoded = new bytes(hbs + 2);
                encoded[0] = bytes1(uint8(_offset + hbs + 56));

                uint256 lbs = 31 - hbs;
                uint256 shiftedVal = uint256(_len) << (lbs * 8);

                assembly {
                    mstore(add(encoded, 0x21), shiftedVal)
                }
            }
        }
    }

    /// @notice Computes the index of the highest byte set in number.
    /// @notice Uses little endian ordering (The least significant byte has index `0`).
    /// NOTE: returns `0` for `0`
    function _highestByteSet(uint256 _number) private pure returns (uint256 hbs) {
        unchecked {
            if (_number > type(uint128).max) {
                _number >>= 128;
                hbs += 16;
            }
            if (_number > type(uint64).max) {
                _number >>= 64;
                hbs += 8;
            }
            if (_number > type(uint32).max) {
                _number >>= 32;
                hbs += 4;
            }
            if (_number > type(uint16).max) {
                _number >>= 16;
                hbs += 2;
            }
            if (_number > type(uint8).max) {
                hbs += 1;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

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

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

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

pragma solidity ^0.8.20;

import {Strings} from "../Strings.sol";

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an ERC-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../libraries/TransactionHelper.sol";

interface IBootloaderUtilities {
    function getTransactionHashes(
        Transaction calldata _transaction
    ) external view returns (bytes32 txHash, bytes32 signedTxHash);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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
     * ====
     *
     * [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.5.11/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 v5.1.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @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;
            assembly ("memory-safe") {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                assembly ("memory-safe") {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(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) {
        uint256 localValue = value;
        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] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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 Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal
     * representation, according to EIP-55.
     */
    function toChecksumHexString(address addr) internal pure returns (string memory) {
        bytes memory buffer = bytes(toHexString(addr));

        // hash the hex part of buffer (skip length + 2 bytes, length 40)
        uint256 hashValue;
        assembly ("memory-safe") {
            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))
        }

        for (uint256 i = 41; i > 1; --i) {
            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)
            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {
                // case shift by xoring with 0x20
                buffer[i] ^= 0x20;
            }
            hashValue >>= 4;
        }
        return string(buffer);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * 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²⁵⁶ and mod 2²⁵⁶ - 1, then use
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2²⁵⁶ + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                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²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_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.

            uint256 twos = denominator & (0 - denominator);
            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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            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⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // 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²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, 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;
        }
    }

    /**
     * @dev 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) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 exp;
        unchecked {
            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
            value >>= exp;
            result += exp;

            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
            value >>= exp;
            result += exp;

            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
            value >>= exp;
            result += exp;

            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
            value >>= exp;
            result += exp;

            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
            value >>= exp;
            result += exp;

            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
            value >>= exp;
            result += exp;

            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
            value >>= exp;
            result += exp;

            result += SafeCast.toUint(value > 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
        }
    }

    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return ternary(a > b, a, b);
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return ternary(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 {
            // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson.
            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,
            // taking advantage of the most significant (or "sign" bit) in two's complement representation.
            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,
            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).
            int256 mask = n >> 255;

            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.
            return uint256((n + mask) ^ mask);
        }
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 *
 * _Available since v5.1._
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}

{
  "evmVersion": "cancun",
  "optimizer": {
    "enabled": true,
    "mode": "3"
  },
  "outputSelection": {
    "*": {
      "*": [
        "abi"
      ]
    }
  },
  "detectMissingLibraries": false,
  "forceEVMLA": false,
  "enableEraVMExtensions": true,
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"knownTrustedEoaValidator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ADDRESS_ALREADY_EXISTS","type":"error"},{"inputs":[],"name":"ADDRESS_NOT_EXISTS","type":"error"},{"inputs":[],"name":"BYTES_ALREADY_EXISTS","type":"error"},{"inputs":[],"name":"BYTES_NOT_EXISTS","type":"error"},{"inputs":[],"name":"CALL_FAILED","type":"error"},{"inputs":[],"name":"EMPTY_HOOK_ADDRESS","type":"error"},{"inputs":[],"name":"EMPTY_MODULE_ADDRESS","type":"error"},{"inputs":[],"name":"EMPTY_OWNERS","type":"error"},{"inputs":[],"name":"EMPTY_VALIDATORS","type":"error"},{"inputs":[],"name":"FEE_PAYMENT_FAILED","type":"error"},{"inputs":[],"name":"HOOK_ERC165_FAIL","type":"error"},{"inputs":[],"name":"INSUFFICIENT_FUNDS","type":"error"},{"inputs":[],"name":"INVALID_ADDRESS","type":"error"},{"inputs":[],"name":"INVALID_BYTES","type":"error"},{"inputs":[],"name":"INVALID_KEY","type":"error"},{"inputs":[],"name":"INVALID_PUBKEY_LENGTH","type":"error"},{"inputs":[],"name":"INVALID_SALT","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"MODULE_ERC165_FAIL","type":"error"},{"inputs":[{"internalType":"uint256","name":"actualValue","type":"uint256"},{"internalType":"uint256","name":"expectedValue","type":"uint256"}],"name":"MsgValueMismatch","type":"error"},{"inputs":[],"name":"NOT_FROM_BOOTLOADER","type":"error"},{"inputs":[],"name":"NOT_FROM_HOOK","type":"error"},{"inputs":[],"name":"NOT_FROM_MODULE","type":"error"},{"inputs":[],"name":"NOT_FROM_SELF","type":"error"},{"inputs":[],"name":"NOT_FROM_SELF_OR_MODULE","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"RECUSIVE_MODULE_CALL","type":"error"},{"inputs":[],"name":"SAME_IMPLEMENTATION","type":"error"},{"inputs":[],"name":"UNAUTHORIZED_OUTSIDE_TRANSACTION","type":"error"},{"inputs":[],"name":"VALIDATION_HOOK_FAILED","type":"error"},{"inputs":[],"name":"VALIDATOR_ERC165_FAIL","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"hook","type":"address"}],"name":"AddHook","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"module","type":"address"}],"name":"AddModule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"AddModuleValidator","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"FeePaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"K1AddOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"K1AddValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"K1RemoveOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"K1RemoveValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"R1AddOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"R1AddValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"R1RemoveOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"R1RemoveValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"hook","type":"address"}],"name":"RemoveHook","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"module","type":"address"}],"name":"RemoveModule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"RemoveModuleValidator","type":"event"},{"anonymous":false,"inputs":[],"name":"ResetOwners","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldImplementation","type":"address"},{"indexed":true,"internalType":"address","name":"newImplementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"KNOWN_TRUSTED_EOA_VALIDATOR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"hookAndData","type":"bytes"},{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"addHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"moduleAndData","type":"bytes"}],"name":"addModule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"},{"internalType":"bytes","name":"initialAccountValidationKey","type":"bytes"}],"name":"addModuleValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"agwMessageTypeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"allowFailure","type":"bool"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"_calls","type":"tuple[]"}],"name":"batchCall","outputs":[],"stateMutability":"payable","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"executeFromModule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"transaction","type":"tuple"}],"name":"executeTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"transaction","type":"tuple"}],"name":"executeTransactionFromOutside","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"signedHash","type":"bytes32"}],"internalType":"struct ERC1271Handler.AGWMessage","name":"agwMessage","type":"tuple"}],"name":"getEip712Hash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"getHookData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"initialK1Owner","type":"address"},{"internalType":"address","name":"initialK1Validator","type":"address"},{"internalType":"bytes[]","name":"modules","type":"bytes[]"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"allowFailure","type":"bool"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call","name":"initCall","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isHook","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isModule","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"isModuleValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"signedHash","type":"bytes32"},{"internalType":"bytes","name":"signatureAndValidator","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bytes4","name":"magicValue","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"k1AddOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"k1AddValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"k1IsOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"k1IsValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"k1ListOwners","outputs":[{"internalType":"address[]","name":"k1OwnerList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"k1ListValidators","outputs":[{"internalType":"address[]","name":"validatorList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"k1RemoveOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"k1RemoveValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"listHooks","outputs":[{"internalType":"address[]","name":"hookList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"listModuleValidators","outputs":[{"internalType":"address[]","name":"validatorList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"listModules","outputs":[{"internalType":"address[]","name":"moduleList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"transaction","type":"tuple"}],"name":"payForTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"transaction","type":"tuple"}],"name":"prepareForPaymaster","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"r1AddOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"r1AddValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"r1IsOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"r1IsValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"r1ListOwners","outputs":[{"internalType":"bytes[]","name":"r1OwnerList","type":"bytes[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"r1ListValidators","outputs":[{"internalType":"address[]","name":"validatorList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"r1RemoveOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"r1RemoveValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"removeHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"removeModule","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"removeModuleValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"resetOwners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"setHookData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"suggestedSignedHash","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"transaction","type":"tuple"}],"name":"validateTransaction","outputs":[{"internalType":"bytes4","name":"magic","type":"bytes4"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

3cda335100000000000000000000000000000000000000000000000000000000000000000100161b2e96659e6590f51aeb250c7348e91784ed883360cda61e12654ee3050000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002000000000000000000000000074b9ae28ec45e3fa11533c7954752597c3de3e7a

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

00000000000000000000000074b9ae28ec45e3fa11533c7954752597c3de3e7a

-----Decoded View---------------
Arg [0] : knownTrustedEoaValidator (address): 0x74b9ae28EC45E3FA11533c7954752597C3De3e7A

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000074b9ae28ec45e3fa11533c7954752597c3de3e7a