{"constructor_args":"0x0000000000000000000000006781d5631bfe47432b089e64e3eab3b6edd26177","is_partially_verified":false,"is_changed_bytecode":false,"abi":[{"inputs":[{"internalType":"address","name":"allowedTarget_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressZeroNotAllowed","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"bytes","name":"reason","type":"bytes"}],"name":"CallFailed","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[],"name":"ETHNotAccepted","type":"error"},{"inputs":[],"name":"EmptyBatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"expected","type":"uint256"},{"internalType":"uint256","name":"provided","type":"uint256"}],"name":"InvalidNonce","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"NotDelegated","type":"error"},{"inputs":[],"name":"Reentrancy","type":"error"},{"inputs":[],"name":"RefundFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint256","name":"current","type":"uint256"}],"name":"SignatureExpired","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"UnauthorizedTarget","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"Executed","type":"event"},{"inputs":[],"name":"ALLOWED_TARGET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"domainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct GaslessDelegate.Call[]","name":"calls","type":"tuple[]"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct GaslessDelegate.Call[]","name":"calls","type":"tuple[]"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"hashTypedDataV4","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"conflicting_implementations":null,"certified":false,"additional_sources":[{"file_path":"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     *\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Variant of {tryRecover} that takes a signature in calldata\n     */\n    function tryRecoverCalldata(\n        bytes32 hash,\n        bytes calldata signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, calldata slices would work here, but are\n            // significantly more expensive (length check) than using calldataload in assembly.\n            assembly (\"memory-safe\") {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Variant of {recover} that takes a signature in calldata\n     */\n    function recoverCalldata(bytes32 hash, bytes calldata signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecoverCalldata(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Parse a signature into its `v`, `r` and `s` components. Supports 65-byte and 64-byte (ERC-2098)\n     * formats. Returns (0,0,0) for invalid signatures.\n     *\n     * For 64-byte signatures, `v` is automatically normalized to 27 or 28.\n     * For 65-byte signatures, `v` is returned as-is and MUST already be 27 or 28 for use with ecrecover.\n     *\n     * Consider validating the result before use, or use {tryRecover}/{recover} which perform full validation.\n     */\n    function parse(bytes memory signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch mload(signature)\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := mload(add(signature, 0x40))\n                r := mload(add(signature, 0x20))\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Variant of {parse} that takes a signature in calldata\n     */\n    function parseCalldata(bytes calldata signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch signature.length\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := calldataload(add(signature.offset, 0x20))\n                r := calldataload(signature.offset)\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"}],"is_verified_via_sourcify":false,"can_be_visualized_via_sol2uml":true,"evm_version":"osaka","language":"solidity","is_verified_via_eth_bytecode_db":false,"is_fully_verified":true,"license_type":"none","is_blueprint":false,"name":"GaslessDelegate","creation_bytecode":"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","external_libraries":[],"proxy_type":null,"implementations":[],"verified_at":"2026-05-16T16:49:50.523602Z","is_verified_via_verifier_alliance":false,"compiler_version":"v0.8.34+commit.80d5c536","decoded_constructor_args":[["0x6781d5631BFe47432b089e64e3EaB3b6eDd26177",{"internalType":"address","name":"allowedTarget_","type":"address"}]],"sourcify_repo_url":null,"optimization_runs":200,"compiler_settings":{"evmVersion":"osaka","libraries":{},"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"enabled":true,"runs":200},"outputSelection":{"*":{"":["*"],"*":["*"]}},"remappings":["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"viaIR":true},"is_verified":true,"verified_twin_address_hash":null,"optimization_enabled":true,"deployed_bytecode":"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","source_code":"// SPDX-License-Identifier: Apache-2.0\npragma solidity 0.8.34;\n\nimport {ECDSA} from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\n\n/**\n * @title GaslessDelegate\n * @notice Production EIP-7702 delegation target for JPYSC operator accounts.\n *\n * @dev ## Overview\n *\n * Operator EOAs (pauser, blacklister, minter, etc.) hold roles directly on\n * StablecoinV1. They cannot hold ETH for gas. A relayer (Operator B) sponsors\n * transactions by calling `execute()` on the operator's address after the\n * operator has delegated its code to this contract via an EIP-7702 authorization.\n *\n * ## EIP-7702 execution context\n *\n * When an EOA delegates to this implementation via EIP-7702, every call to\n * `execute()` on the EOA's address runs *this* bytecode but with:\n *   - `address(this)` = the delegating EOA (not this implementation contract)\n *   - `msg.sender`    = the relayer (Operator B)\n *   - Storage reads/writes target the EOA's storage slots\n *\n * External calls made inside `execute()` therefore have `msg.sender` = the\n * EOA, so all role checks on StablecoinV1 see the correct operator address.\n *\n * ## Security design (key decisions)\n *\n * 1. **`__self` anti-impersonation guard** (MetaMask pattern)\n *    `__self` captures the implementation address at deploy time. The `onlyProxy`\n *    modifier reverts whenever `address(this) == __self`, i.e. when someone calls\n *    the implementation contract directly instead of through an EOA delegation.\n *    Without this guard, an attacker could call functions on the implementation\n *    directly and obtain a domain separator bound to the implementation address.\n *\n * 2. **ERC-7201 namespaced storage for the nonce**\n *    All mutable state lives under namespace `jpysc.GaslessDelegate`. If the operator\n *    ever redelegates to a different implementation, the new implementation's\n *    variables at slot 0, 1, 2 ... won't collide with our nonce.\n *\n * 3. **Domain separator includes implementation address as salt** (Calibur pattern)\n *    `salt = bytes32(uint256(uint160(__self)))` encodes the implementation address\n *    as a domain field. If an operator redelegates to *another* implementation,\n *    `__self` changes, the salt changes, and all prior Execute signatures become\n *    invalid — preventing replay across implementations.\n *\n * 4. **Domain separator never cached**\n *    `_domainSeparator()` recomputes every call using the live `block.chainid`\n *    and `address(this)` (= the EOA). This handles chain forks and ensures the\n *    verifyingContract field is always the signing EOA, not the implementation.\n *\n * 5. **Any relayer may call `execute()`**\n *    Access control is enforced entirely by the signature requirement. No relayer\n *    allowlist is maintained. The relayer cannot forge or modify the signed call\n *    batch, nonce, or deadline.\n *\n * 6. **Allowed-target restriction**\n *    Every call in a batch must target `ALLOWED_TARGET` (set immutably at deploy time\n *    to the StablecoinV1 proxy).  Calls to any other address — including `address(this)`\n *    (the delegating EOA itself) — revert with `UnauthorizedTarget`.  This eliminates\n *    the entire class of attacks where a signed batch is used to invoke arbitrary\n *    contracts or to re-enter the delegate's own functions through the EOA.\n *\n * 7. **Reentrancy guard using transient storage** (EIP-1153, Cancun+)\n *    `_locked` is declared `transient` so it is scoped to the current transaction\n *    and automatically cleared. No persistent storage write needed for the lock.\n *\n *\n * | Feature                          | This contract  |\n * |----------------------------------|----------------|\n * | Structured typing (EIP-712)      | Yes            |\n * | Chain replay protection          | Yes (chainId)  |\n * | Cross-implementation replay      | Yes (salt)     |\n * | Deadline                         | Yes            |\n * | Nonce collision on redelegate    | No (ERC-7201)  |\n * | Anti-direct-call guard           | Yes (__self)   |\n * | Allowed-target restriction       | Yes (immutable)|\n * | Reentrancy guard                 | Yes (transient)|\n *\n * ## Some References\n *\n * - EIP-7702: https://eips.ethereum.org/EIPS/eip-7702\n * - MetaMask Delegation Framework: https://github.com/MetaMask/delegation-framework\n * - Uniswap Calibur (salt pattern): https://github.com/Uniswap/calibur\n * - ERC-7201 namespaced storage: https://eips.ethereum.org/EIPS/eip-7201\n */\ncontract GaslessDelegate {\n    using ECDSA for bytes32;\n\n    // ============ Constants ============\n\n    string public constant NAME = \"GaslessDelegate\";\n    string public constant VERSION = \"1\";\n\n    /**\n     * @dev EIP-712 domain type hash — 5-field variant including `salt`.\n     *      The salt encodes the implementation address so signatures are automatically\n     *      invalidated when the EOA redelegates to a different implementation.\n     */\n    bytes32 private constant DOMAIN_TYPEHASH =\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)\");\n\n    /**\n     * @dev EIP-712 type hash for a single call. `data` is encoded as its keccak256.\n     */\n    bytes32 private constant CALL_TYPEHASH = keccak256(\"Call(address target,uint256 value,bytes data)\");\n\n    /**\n     * @dev EIP-712 type hash for the Execute struct. Referenced types are appended\n     *      alphabetically per the EIP-712 specification.\n     */\n    bytes32 private constant EXECUTE_TYPEHASH =\n        keccak256(\"Execute(Call[] calls,uint256 nonce,uint256 deadline)Call(address target,uint256 value,bytes data)\");\n\n    /**\n     * @dev ERC-7201 storage slot for `DelegatorStorage`.\n     *      Derivation: keccak256(abi.encode(uint256(keccak256(\"jpysc.GaslessDelegate\")) - 1)) & ~bytes32(uint256(0xff))\n     */\n    bytes32 private constant DELEGATOR_STORAGE_SLOT =\n        0x8a2b8e69431cb04af2f07b033b5fb722ba1f24b0675d37ebc78453cd55662800;\n\n    // ============ Immutables ============\n\n    /**\n     * @dev Captures the implementation contract's own address at deploy time.\n     *\n     *      Two uses:\n     *      (a) `onlyProxy` guard: reverts if `address(this) == __self`, i.e. when\n     *          called directly on the implementation rather than via EIP-7702 delegation.\n     *      (b) Domain separator salt: `bytes32(uint256(uint160(__self)))` is included\n     *          as the EIP-712 domain salt so that signatures signed against one\n     *          implementation are invalid for any other implementation.\n     */\n    address private immutable __self;\n\n    /**\n     * @notice The only contract address that calls in a batch may target.\n     * @dev Set once at deploy time to the StablecoinV1 proxy address.\n     *      Any call whose `target` differs from this value reverts with\n     *      `UnauthorizedTarget`, including self-calls (`target == address(this)`).\n     */\n    address public immutable ALLOWED_TARGET;\n\n    /// @dev Pre-computed hash of the contract name for use in domain separator.\n    bytes32 private immutable _nameHash;\n\n    /// @dev Pre-computed hash of the version string for use in domain separator.\n    bytes32 private immutable _versionHash;\n\n    // ============ Transient storage (EIP-1153 / Cancun+) ============\n\n    /// @dev Reentrancy lock. Transient — automatically cleared after each transaction.\n    bool private transient _locked;\n\n    // ============ ERC-7201 Persistent Storage ============\n\n    /**\n     * @custom:storage-location erc7201:jpysc.GaslessDelegate\n     * @dev Under EIP-7702, `address(this)` is the delegating EOA, so all state\n     *      stored here belongs to the EOA's storage — not the implementation's.\n     */\n    struct DelegatorStorage {\n        /// @dev Sequential nonce for the delegating EOA.\n        uint256 nonce;\n    }\n\n    // ============ Types ============\n\n    /**\n     * @notice A single call to be executed by the delegating EOA.\n     * @param target The contract to call.\n     * @param value  ETH value to forward (in wei).\n     * @param data   Calldata to forward.\n     */\n    struct Call {\n        address target;\n        uint256 value;\n        bytes data;\n    }\n\n    // ============ Errors ============\n\n    /// @notice Thrown when `execute()` is called directly on the implementation contract.\n    error NotDelegated();\n\n    /// @notice Thrown when `execute()` is re-entered within the same transaction.\n    error Reentrancy();\n\n    /// @notice Thrown when `block.timestamp` exceeds the provided deadline.\n    error SignatureExpired(uint256 deadline, uint256 current);\n\n    /// @notice Thrown when the provided nonce does not match the current EOA nonce.\n    error InvalidNonce(uint256 expected, uint256 provided);\n\n    /// @notice Thrown when the recovered signer does not match `address(this)` (the EOA).\n    error InvalidSignature();\n\n    /// @notice Thrown when an empty call batch is provided.\n    error EmptyBatch();\n\n    /// @notice Thrown when `allowedTarget_` is the zero address in the constructor.\n    error AddressZeroNotAllowed();\n\n    /// @notice Thrown when a call targets any address other than `ALLOWED_TARGET`.\n    error UnauthorizedTarget(address target);\n\n    /// @notice Thrown when an individual call in the batch reverts.\n    error CallFailed(uint256 index, bytes reason);\n\n    /// @notice Thrown when ETH is sent directly to a delegating EOA.\n    error ETHNotAccepted();\n\n    /// @notice Thrown when the post-batch ETH refund to the relayer fails.\n    error RefundFailed();\n\n    // ============ Events ============\n\n    /**\n     * @notice Emitted when a signed batch is successfully executed.\n     * @param account The EOA that authorised the batch (= `address(this)` at execution time).\n     * @param nonce   The nonce consumed by this execution.\n     */\n    event Executed(address indexed account, uint256 nonce);\n\n    // ============ Constructor ============\n\n    /// @param allowedTarget_ The StablecoinV1 proxy address. Every call in a signed\n    ///                        batch must target this address; all others are rejected.\n    constructor(address allowedTarget_) {\n        if (allowedTarget_ == address(0)) revert AddressZeroNotAllowed();\n        __self = address(this);\n        ALLOWED_TARGET = allowedTarget_;\n        _nameHash = keccak256(bytes(NAME));\n        _versionHash = keccak256(bytes(VERSION));\n    }\n\n    // ============ Modifiers ============\n\n    /**\n     * @dev Reverts when called directly on the implementation contract.\n     *      Under EIP-7702 delegation, `address(this)` is the EOA (≠ `__self`).\n     *      Direct calls to the implementation have `address(this) == __self`.\n     */\n    modifier onlyProxy() {\n        if (address(this) == __self) revert NotDelegated();\n        _;\n    }\n\n    /// @dev Prevents reentrant calls to `execute()` within the same transaction.\n    modifier nonReentrant() {\n        if (_locked) revert Reentrancy();\n        _locked = true;\n        _;\n        _locked = false;\n    }\n\n    // ============ External: Core Execution ============\n\n    /**\n     * @notice Execute a batch of calls on behalf of the delegating EOA.\n     *\n     * @dev The EOA signs an EIP-712 `Execute` struct off-chain. Any relayer\n     *      (msg.sender) may submit this function — there is no relayer allowlist.\n     *      Authorization is enforced entirely by the signature: only the EOA whose\n     *      address matches `address(this)` at execution time can produce a valid sig.\n     *\n     *      The signed digest binds:\n     *        - The specific call batch (targets, values, calldata)\n     *        - The current sequential nonce (prevents replay)\n     *        - A deadline (limits signature lifetime)\n     *        - The chain ID (prevents cross-chain replay)\n     *        - The EOA address as verifyingContract (prevents cross-account replay)\n     *        - The implementation address as salt (prevents cross-implementation replay)\n     *\n     * @param calls     Non-empty batch of calls to execute. Every call's target must\n     *                  equal `ALLOWED_TARGET`; any other address (including the EOA itself)\n     *                  reverts with `UnauthorizedTarget`.\n     * @param nonce     Must equal the EOA's current nonce (`nonce()`).\n     * @param deadline  Unix timestamp after which the signature is no longer valid.\n     * @param signature EOA's EIP-712 signature over the `Execute` struct.\n     */\n    function execute(Call[] calldata calls, uint256 nonce, uint256 deadline, bytes calldata signature)\n        external\n        payable\n        onlyProxy\n        nonReentrant\n    {\n        // 1. Non-empty batch — prevents nonce consumption for a no-op\n        if (calls.length == 0) revert EmptyBatch();\n\n        // 2. Deadline check\n        if (block.timestamp > deadline) revert SignatureExpired(deadline, block.timestamp);\n\n        // 3. Nonce check (must match current nonce for this EOA)\n        DelegatorStorage storage $ = _storage();\n        uint256 currentNonce = $.nonce;\n        if (nonce != currentNonce) revert InvalidNonce(currentNonce, nonce);\n\n        // 4. Signature verification — signer must be the EOA itself\n        bytes32 digest = _hashTypedData(_hashExecute(calls, nonce, deadline));\n        if (digest.recover(signature) != address(this)) revert InvalidSignature();\n\n        // 5. Consume nonce before external calls (CEI pattern)\n        $.nonce = currentNonce + 1;\n\n        emit Executed(address(this), nonce);\n\n        // 6. Execute the batch\n        for (uint256 i = 0; i < calls.length; i++) {\n            if (calls[i].target != ALLOWED_TARGET) revert UnauthorizedTarget(calls[i].target);\n\n            (bool success, bytes memory reason) = calls[i].target.call{value: calls[i].value}(calls[i].data);\n            if (!success) revert CallFailed(i, reason);\n        }\n\n        // 7. Refund any residual ETH to the relayer.\n        //    STB operator EOAs are prohibited from holding ETH under Japanese trust bank\n        //    regulations. Any surplus msg.value (accidental or adversarial) is swept back\n        //    to msg.sender so it never accumulates in the regulated account.\n        uint256 remaining = address(this).balance;\n        if (remaining > 0) {\n            (bool refundSuccess,) = msg.sender.call{value: remaining}(\"\");\n            if (!refundSuccess) revert RefundFailed();\n        }\n    }\n\n    // ============ External: View Helpers ============\n\n    /**\n     * @notice Returns the current nonce for the delegating EOA.\n     * @dev Call as `GaslessDelegate(eoa).nonce()` to fetch the nonce for `eoa`.\n     */\n    function nonce() external view onlyProxy returns (uint256) {\n        return _storage().nonce;\n    }\n\n    /**\n     * @notice Returns the EIP-712 domain separator for the delegating EOA.\n     * @dev Recalculated on every call — never cached. Incorporates:\n     *        - `address(this)` as `verifyingContract` (= the EOA)\n     *        - `block.chainid` for cross-chain replay protection\n     *        - `__self` (implementation address) as `salt`\n     *      Useful for off-chain signature construction and debugging.\n     */\n    function domainSeparator() external view onlyProxy returns (bytes32) {\n        return _domainSeparator();\n    }\n\n    /**\n     * @notice Returns the full EIP-712 digest for a given Execute struct.\n     * @dev Equivalent to `_hashTypedData(_hashExecute(calls, nonce, deadline))`.\n     *      Off-chain tooling should sign this exact value.\n     */\n    function hashTypedDataV4(Call[] calldata calls, uint256 nonce, uint256 deadline)\n        external\n        view\n        onlyProxy\n        returns (bytes32)\n    {\n        return _hashTypedData(_hashExecute(calls, nonce, deadline));\n    }\n\n    // ============ Receive / Fallback ============\n\n    /**\n     * @notice Rejects all direct ETH transfers to the delegating EOA.\n     * @dev Accepting ETH via receive() would create\n     *      a vector for any party to force a compliance violation by pushing ETH onto a\n     *      regulated address. All plain ETH transfers are unconditionally rejected.\n     *      Note: SELFDESTRUCT-forced ETH and coinbase rewards cannot be blocked at the EVM\n     *      level.\n     */\n    receive() external payable {\n        revert ETHNotAccepted();\n    }\n\n    // ============ Internal: Domain Separator ============\n\n    /**\n     * @dev Computes the EIP-712 domain separator.\n     *      Uses the 5-field variant (name, version, chainId, verifyingContract, salt)\n     *      so the implementation address is included and signatures are bound to it.\n     *      Never cached — always live values of `block.chainid` and `address(this)`.\n     */\n    function _domainSeparator() internal view returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                DOMAIN_TYPEHASH,\n                _nameHash,\n                _versionHash,\n                block.chainid,\n                address(this), // verifyingContract = EOA under delegatecall\n                bytes32(uint256(uint160(__self))) // salt = implementation address\n            )\n        );\n    }\n\n    /// @dev Wraps a struct hash in the EIP-712 \\x19\\x01 prefix.\n    function _hashTypedData(bytes32 structHash) internal view returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", _domainSeparator(), structHash));\n    }\n\n    // ============ Internal: Struct Hashing ============\n\n    /// @dev Returns the EIP-712 hash of an Execute struct.\n    function _hashExecute(Call[] calldata calls, uint256 nonce, uint256 deadline) internal pure returns (bytes32) {\n        return keccak256(abi.encode(EXECUTE_TYPEHASH, _hashCalls(calls), nonce, deadline));\n    }\n\n    /**\n     * @dev Returns the EIP-712 hash of a Call[] array.\n     *      Each Call is individually hashed per EIP-712 struct encoding,\n     *      then the array of hashes is keccak256'd per EIP-712 array encoding:\n     *      `enc(T[]) = keccak256(enc(T[0]) ++ enc(T[1]) ++ ...)`\n     *      For `bytes32` elements this is equivalent to `keccak256(abi.encodePacked(hashes))`.\n     */\n    function _hashCalls(Call[] calldata calls) internal pure returns (bytes32) {\n        bytes32[] memory callHashes = new bytes32[](calls.length);\n        for (uint256 i = 0; i < calls.length; i++) {\n            callHashes[i] = keccak256(\n                abi.encode(\n                    CALL_TYPEHASH,\n                    calls[i].target,\n                    calls[i].value,\n                    keccak256(calls[i].data) // `bytes` encoded as its keccak256 per EIP-712\n                )\n            );\n        }\n        return keccak256(abi.encodePacked(callHashes));\n    }\n\n    // ============ Internal: Storage ============\n\n    /// @dev Returns a reference to the ERC-7201 namespaced storage struct.\n    function _storage() private pure returns (DelegatorStorage storage $) {\n        assembly {\n            $.slot := DELEGATOR_STORAGE_SLOT\n        }\n    }\n}\n","creation_status":"success","file_path":"src/eip7702/GaslessDelegate.sol"}