{"file_path":"contracts/Wrappers/ArbitrumExtension.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: Apache 2.0\n\npragma solidity 0.8.4;\n\nimport \"../Tether/TetherToken.sol\";\nimport \"../Tether/EIP3009.sol\";\nimport \"../Tether/util/SignatureChecker.sol\";\n\n/*\n\n   Copyright Tether.to 2020\n\n   Author Will Harborne\n\n   Licensed under the Apache License, Version 2.0\n   http://www.apache.org/licenses/LICENSE-2.0\n\n*/\n\ninterface IArbToken {\n    /**\n     * @notice should increase token supply by amount, and should (probably) only be callable by the L1 bridge.\n     */\n    function bridgeMint(address account, uint256 amount) external;\n    /**\n     * @notice should decrease token supply by amount, and should (probably) only be callable by the L1 bridge.\n     */\n    function bridgeBurn(address account, uint256 amount) external;\n\n    /**\n     * @return address of layer 1 token\n     */\n    function l1Address() external view returns (address);\n}\n\nabstract contract ArbitrumExtension is TetherToken, IArbToken {\n  address internal l2Gateway;\n  address public override l1Address;\n}\n\nabstract contract TetherTokenV2Arbitrum is ArbitrumExtension, EIP3009 {\n    bytes32 internal constant _PERMIT_TYPEHASH =\n        keccak256(\n            \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n        );\n\n    constructor () initializer {}\n\n    function domainSeparator()\n        internal\n        view\n        virtual\n        override\n        returns (bytes32)\n    {\n        return _domainSeparatorV4();\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n    function _permit(\n        address owner_,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        bytes memory signature\n    ) internal {\n        require(block.timestamp <= deadline, \"ERC20Permit: expired deadline\");\n\n        bytes32 structHash = keccak256(\n            abi.encode(\n                _PERMIT_TYPEHASH,\n                owner_,\n                spender,\n                value,\n                _useNonce(owner_),\n                deadline\n            )\n        );\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        require(\n            SignatureChecker.isValidSignatureNow(owner_, hash, signature),\n            \"EIP2612: invalid signature\"\n        );\n\n        _approve(owner_, spender, value);\n    }\n\n    /**\n     * @notice Update allowance with a signed permit\n     * @param owner_       Token owner's address\n     * @param spender     Spender's address\n     * @param value       Amount of allowance\n     * @param deadline    The time at which the signature expires (unix time)\n     * @param v   signature component v\n     * @param r   signature component r\n     * @param s   signature component s\n     */\n    function permit(\n        address owner_,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        _permit(owner_, spender, value, deadline, abi.encodePacked(r, s, v));\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n\n    /**\n     * @notice Update allowance with a signed permit\n     * @dev EOA wallet signatures should be packed in the order of r, s, v.\n     * @param owner_       Token owner's address (Authorizer)\n     * @param spender     Spender's address\n     * @param value       Amount of allowance\n     * @param deadline    The time at which the signature expires (unix time), or max uint256 value to signal no expiration\n     * @param signature   Signature bytes signed by an EOA wallet or a contract wallet\n     */\n    function permit(\n        address owner_,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        bytes memory signature\n    ) external {\n        _permit(owner_, spender, value, deadline, signature);\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n\n    /**\n     * @notice Execute a transfer with a signed authorization\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public onlyNotBlocked {\n        _transferWithAuthorizationValidityCheck(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            abi.encodePacked(r, s, v)\n        );\n        _transfer(from, to, value);\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n\n    /**\n     * @notice Execute a transfer with a signed authorization\n     * @dev EOA wallet signatures should be packed in the order of r, s, v.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param signature     Signature bytes signed by an EOA wallet or a contract wallet\n     */\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) external onlyNotBlocked {\n        _transferWithAuthorizationValidityCheck(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            signature\n        );\n        _transfer(from, to, value);\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n\n    /**\n     * @notice Receive a transfer with a signed authorization from the payer\n     * @dev This has an additional check to ensure that the payee's address\n     * matches the caller of this function to prevent front-running attacks.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public onlyNotBlocked {\n        _receiveWithAuthorizationValidityCheck(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            abi.encodePacked(r, s, v)\n        );\n        _transfer(from, to, value);\n    }\n\n    /**\n     * The following applies to the following function and comments to that function:\n     * \n     * SPDX-License-Identifier: Apache-2.0\n     *\n     * Copyright (c) 2023, Circle Internet Financial, LLC.\n     *\n     * Licensed under the Apache License, Version 2.0 (the \"License\");\n     * you may not use this file except in compliance with the License.\n     * You may obtain a copy of the License at\n     *\n     * http://www.apache.org/licenses/LICENSE-2.0\n     * \n     * Unless required by applicable law or agreed to in writing, software\n     * distributed under the License is distributed on an \"AS IS\" BASIS,\n     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n     * See the License for the specific language governing permissions and\n     * limitations under the License.\n     * \n     * ---------------------------------------------------------------------\n     * \n     * Adapted by Tether.to 2024 for greater flexibility and reusability\n     */\n\n    /**\n     * @notice Receive a transfer with a signed authorization from the payer\n     * @dev This has an additional check to ensure that the payee's address\n     * matches the caller of this function to prevent front-running attacks.\n     * EOA wallet signatures should be packed in the order of r, s, v.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param signature     Signature bytes signed by an EOA wallet or a contract wallet\n     */\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) external onlyNotBlocked {\n        _receiveWithAuthorizationValidityCheck(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            signature\n        );\n        _transfer(from, to, value);\n    }\n\n    uint256[48] private __gap;\n}\n\ninterface IArbL2GatewayRouter {\n  function outboundTransfer(\n        address _l1Token,\n        address _to,\n        uint256 _amount,\n        bytes calldata _data\n    ) external payable returns (bytes memory);\n}\n\ncontract ArbitrumExtensionV2 is TetherTokenV2Arbitrum {\n  event LogSetOFTContract(address indexed oftContract);\n  event Burn(address indexed from, uint256 amount); \n  error NotImplemented();\n  event LogUpdateNameAndSymbol(string name, string symbol);\n\n  address public constant USDT0_L1_LOCKBOX = 0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee;\n  IArbL2GatewayRouter internal constant ARBITRUM_L2_GATEWAY_ROUTER = IArbL2GatewayRouter(0x5288c571Fd7aD117beA99bF60FE0846C4E84F933);\n\n  bool internal isMigrating;\n\n  function migrate(\n    string memory _name,\n    string memory _symbol,\n    address _oftContract\n  ) public {\n    require(!isMigrating, \"ALREADY_MIGRATED\");\n    isMigrating = true;\n\n    require(_oftContract != address(0), \"INVALID_OFT_CONTRACT\");\n    _updateNameAndSymbol(_name, _symbol);\n    \n    ARBITRUM_L2_GATEWAY_ROUTER.outboundTransfer(l1Address, USDT0_L1_LOCKBOX, totalSupply(), bytes(\"\"));\n\n    l2Gateway = _oftContract;\n    l1Address = address(0);\n    emit LogSetOFTContract(_oftContract);\n  }\n\n  string internal _newName;\n  string internal _newSymbol;\n\n  function oftContract() public view returns (address) {\n    return l2Gateway;\n  }\n\n  modifier onlyAuthorizedSender() {\n    require(msg.sender == l2Gateway, \"Only OFT can call\");\n    _;\n  }\n\n  /**\n  * @notice Mint tokens on L2. Callable path is L1Gateway depositToken (which handles L1 escrow), which triggers L2Gateway, which calls this\n  * @param account recipient of tokens\n  * @param amount amount of tokens minted\n  */\n  function bridgeMint(address account, uint256 amount) external virtual override onlyAuthorizedSender {\n    revert NotImplemented(); \n  }\n\n  /**\n  * @notice Burn tokens on L2.\n  * @dev only the token bridge can call this\n  * @param account owner of tokens\n  * @param amount amount of tokens burnt\n  */\n  function bridgeBurn(address account, uint256 amount) external virtual override onlyAuthorizedSender {\n  }\n\n  function mint(address _destination, uint256 _amount) public override onlyAuthorizedSender {\n    _mint(_destination, _amount);\n    emit Mint(_destination, _amount);\n  }\n\n  function burn(address _from, uint256 _amount) public onlyAuthorizedSender {\n    _burn(_from, _amount);\n    emit Burn(_from, _amount);\n  }\n\n  function setOFTContract(address _oftContract) external onlyOwner {\n    l2Gateway = _oftContract;\n    emit LogSetOFTContract(_oftContract);\n  }\n\n  /**\n  * @dev The hash of the name parameter for the EIP712 domain.\n  *\n  * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\n  * are a concern.\n  */\n  function _EIP712NameHash() internal virtual override view returns (bytes32) {\n    return keccak256(bytes(name()));\n  }\n\n  function _updateNameAndSymbol(string memory _name, string memory _symbol) internal {\n    _newName = _name;\n    _newSymbol = _symbol;\n    emit LogUpdateNameAndSymbol(_name, _symbol);\n  }\n\n  function updateNameAndSymbol(string memory _name, string memory _symbol) public onlyOwner {\n    _updateNameAndSymbol(_name, _symbol);\n  }\n\n  /**\n  * @dev Returns the name of the token.\n  */\n  function name() public view virtual override returns (string memory) {\n    return bytes(_newName).length == 0 ? super.name() : _newName;\n  }\n\n  /**\n  * @dev Returns the symbol of the token, usually a shorter version of the\n  * name.\n  */\n  function symbol() public view virtual override returns (string memory) {\n    return bytes(_newSymbol).length == 0 ? super.symbol() : _newSymbol;\n  }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"github_repository_metadata":null,"compiler_settings":{"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":100000},"remappings":[]},"optimization_runs":100000,"sourcify_repo_url":null,"decoded_constructor_args":null,"compiler_version":"0.8.4+commit.c7e474f2","is_verified_via_verifier_alliance":true,"verified_at":"2025-03-05T17:28:15.947453Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"0x60806040523480156200001157600080fd5b50600054610100900460ff16806200002c575060005460ff16155b620000945760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840160405180910390fd5b600054610100900460ff16158015620000b7576000805461ffff19166101011790555b8015620000ca576000805461ff00191690555b5061493880620000db6000396000f3fe608060405234801561001057600080fd5b506004361061030a5760003560e01c80638da5cb5b1161019c578063d505accf116100ee578063eaf9d19411610097578063f2fde38b11610071578063f2fde38b1461075d578063fbac395114610770578063fe64c3701461079357600080fd5b8063eaf9d19414610724578063ee14f7d914610737578063ef55bec61461074a57600080fd5b8063dd62ed3e116100c8578063dd62ed3e14610684578063e3ee160e146106ca578063e94a0102146106dd57600080fd5b8063d505accf14610637578063d91694871461064a578063db006a751461067157600080fd5b8063a0cc6a6811610150578063b7b728991161012a578063b7b72899146105f0578063c2eeeebd14610603578063cf0929951461062457600080fd5b8063a0cc6a68146105a3578063a457c2d7146105ca578063a9059cbb146105dd57600080fd5b806396d648791161018157806396d64879146105595780639dc29fac1461057d5780639fd5a6cf1461059057600080fd5b80638da5cb5b1461053357806395d89b411461055157600080fd5b8063395093511161026057806374f4f547116102095780638040a2c7116101e35780638040a2c7146104fa57806388b7ab631461050d5780638c2a993e1461052057600080fd5b806374f4f547146104ad5780637ecebe00146104c05780637f2eecc3146104d357600080fd5b80635a049a701161023a5780635a049a701461045c57806370a082311461046f578063715018a6146104a557600080fd5b806339509351146104235780633c7c9b901461043657806340c10f191461044957600080fd5b80631a14f449116102c257806323b872dd1161029c57806323b872dd146103f2578063313ce567146104055780633644e5151461041b57600080fd5b80631a14f4491461038a5780631e89d5451461039d578063232849c3146103b057600080fd5b80630e27a385116102f35780630e27a385146103505780631624f6c61461036557806318160ddd1461037857600080fd5b806306fdde031461030f578063095ea7b31461032d575b600080fd5b6103176107ae565b60405161032491906146f5565b60405180910390f35b61034061033b36600461432f565b610863565b6040519015158152602001610324565b61036361035e3660046140cf565b610879565b005b6103636103733660046145b7565b610a12565b6035545b604051908152602001610324565b6103636103983660046140cf565b610b74565b6103636103ab3660046143fa565b610c69565b61010080540473ffffffffffffffffffffffffffffffffffffffff165b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610324565b61034061040036600461411b565b610db3565b6101005460405160ff9091168152602001610324565b61037c610e42565b61034061043136600461432f565b610e4c565b6103636104443660046140cf565b610e95565b61036361045736600461432f565b610f8d565b61036361046a3660046143ad565b611063565b61037c61047d3660046140cf565b73ffffffffffffffffffffffffffffffffffffffff1660009081526033602052604090205490565b6103636110bf565b6103636104bb36600461432f565b61114c565b61037c6104ce3660046140cf565b6111d4565b61037c7fd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de881565b6103636105083660046140cf565b611201565b61036361051b3660046141c6565b6112f6565b61036361052e36600461432f565b611393565b60cc5473ffffffffffffffffffffffffffffffffffffffff166103cd565b610317611449565b6103406105673660046140cf565b60ff602081905260009182526040909120541681565b61036361058b36600461432f565b611476565b61036361059e366004614156565b61154c565b61037c7f7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a226781565b6103406105d836600461432f565b611559565b6103406105eb36600461432f565b611631565b6103636105fe366004614358565b61163e565b610101546103cd9073ffffffffffffffffffffffffffffffffffffffff1681565b6103636106323660046141c6565b61164e565b6103636106453660046142c6565b6116d7565b61037c7f158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a159742981565b61036361067f36600461461f565b61173d565b61037c6106923660046140e9565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260346020908152604080832093909416825291909152205490565b6103636106d8366004614249565b61181c565b6103406106eb36600461432f565b73ffffffffffffffffffffffffffffffffffffffff91909116600090815261010260209081526040808320938352929052205460ff1690565b6103636107323660046144e5565b611914565b610363610745366004614546565b61199f565b610363610758366004614249565b611c57565b61036361076b3660046140cf565b611d39565b61034061077e3660046140cf565b60fe6020526000908152604090205460ff1681565b6103cd736c96de32cea08842dcc4058c14d3aaad7fa41dee81565b606061016580546107be9061481d565b1590506108565761016580546107d39061481d565b80601f01602080910402602001604051908101604052809291908181526020018280546107ff9061481d565b801561084c5780601f106108215761010080835404028352916020019161084c565b820191906000526020600020905b81548152906001019060200180831161082f57829003601f168201915b5050505050905090565b61085e611e69565b905090565b6000610870338484611e78565b50600192915050565b60cc5473ffffffffffffffffffffffffffffffffffffffff1633146108ff576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064015b60405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8116600090815260fe602052604090205460ff1661098e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f546574686572546f6b656e3a2075736572206973206e6f7420626c6f636b656460448201526064016108f6565b73ffffffffffffffffffffffffffffffffffffffff81166000908152603360205260409020546109be828261202b565b8173ffffffffffffffffffffffffffffffffffffffff167f6a2859ae7902313752498feb80a014e6e7275fe964c79aa965db815db1c7f1e982604051610a0691815260200190565b60405180910390a25050565b600054610100900460ff1680610a2b575060005460ff16155b610ab7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff16158015610af657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b61010080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660ff8416179055610b2c612224565b610b368484612349565b610b3f84612472565b8015610b6e57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff1690555b50505050565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314610bf5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b73ffffffffffffffffffffffffffffffffffffffff8116600081815260fe602052604080822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00169055517f665918c9e02eb2fd85acca3969cb054fc84c138e60ec4af22ab6ef2fd4c93c279190a250565b828114610cf8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f546574686572546f6b656e3a206d756c74695472616e73666572206d69736d6160448201527f746368000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b60005b83811015610dac57610d99858583818110610d3f577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b9050602002016020810190610d5491906140cf565b848484818110610d8d577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b90506020020135611631565b5080610da48161486b565b915050610cfb565b5050505050565b33600090815260fe602052604081205460ff1615610e2d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f426c6f636b65643a206d73672e73656e64657220697320626c6f636b6564000060448201526064016108f6565b610e388484846125d8565b90505b9392505050565b600061085e6126be565b33600081815260346020908152604080832073ffffffffffffffffffffffffffffffffffffffff871684529091528120549091610870918590610e909086906147c2565b611e78565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314610f16576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b73ffffffffffffffffffffffffffffffffffffffff8116600081815260fe602052604080822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055517f406bbf2d8d145125adf1198d2cf8a67c66cc4bb0ab01c37dccd4f7c0aae1e7c79190a250565b61010080540473ffffffffffffffffffffffffffffffffffffffff163314611011576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f4f6e6c79204f46542063616e2063616c6c00000000000000000000000000000060448201526064016108f6565b61101b8282612738565b8173ffffffffffffffffffffffffffffffffffffffff167f0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d412139688582604051610a0691815260200190565b60408051602081018490529081018290527fff0000000000000000000000000000000000000000000000000000000000000060f885901b166060820152610dac9086908690606101604051602081830303815290604052612864565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314611140576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b61114a600061296a565b565b61010080540473ffffffffffffffffffffffffffffffffffffffff1633146111d0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f4f6e6c79204f46542063616e2063616c6c00000000000000000000000000000060448201526064016108f6565b5050565b73ffffffffffffffffffffffffffffffffffffffff81166000908152609960205260408120545b92915050565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314611282576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b61010080547fffffffffffffffffffffff0000000000000000000000000000000000000000ff1673ffffffffffffffffffffffffffffffffffffffff8316808302919091179091556040517f140c7f3c4dd16fa102e8e866bdbed4553b3cbe199ca01455115be3efc7ec6b6290600090a250565b33600090815260fe602052604090205460ff1615611370576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f426c6f636b65643a206d73672e73656e64657220697320626c6f636b6564000060448201526064016108f6565b61137f878787878787876129e1565b61138a878787612af2565b50505050505050565b61010080540473ffffffffffffffffffffffffffffffffffffffff163314611417576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f4f6e6c79204f46542063616e2063616c6c00000000000000000000000000000060448201526064016108f6565b6040517fd623472500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606061016680546114599061481d565b15905061146e5761016680546107d39061481d565b61085e612db0565b61010080540473ffffffffffffffffffffffffffffffffffffffff1633146114fa576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601160248201527f4f6e6c79204f46542063616e2063616c6c00000000000000000000000000000060448201526064016108f6565b611504828261202b565b8173ffffffffffffffffffffffffffffffffffffffff167fcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca582604051610a0691815260200190565b610dac8585858585612dbf565b33600090815260346020908152604080832073ffffffffffffffffffffffffffffffffffffffff861684529091528120548281101561161a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016108f6565b6116273385858403611e78565b5060019392505050565b6000610870338484612af2565b611649838383612864565b505050565b33600090815260fe602052604090205460ff16156116c8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f426c6f636b65643a206d73672e73656e64657220697320626c6f636b6564000060448201526064016108f6565b61137f87878787878787612f3e565b61138a8787878786868960405160200161172993929190928352602083019190915260f81b7fff0000000000000000000000000000000000000000000000000000000000000016604082015260410190565b604051602081830303815290604052612dbf565b60cc5473ffffffffffffffffffffffffffffffffffffffff1633146117be576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b6117e66117e060cc5473ffffffffffffffffffffffffffffffffffffffff1690565b8261202b565b6040518181527f702d5967f45f6513a38ffc42d6ba9bf230bd40e8f53b16363c7eb4fd2deb9a449060200160405180910390a150565b33600090815260fe602052604090205460ff1615611896576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f426c6f636b65643a206d73672e73656e64657220697320626c6f636b6564000060448201526064016108f6565b6118fe89898989898988888b6040516020016118ea93929190928352602083019190915260f81b7fff0000000000000000000000000000000000000000000000000000000000000016604082015260410190565b604051602081830303815290604052612f3e565b611909898989612af2565b505050505050505050565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314611995576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b6111d08282612fc6565b6101645460ff1615611a0d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f414c52454144595f4d494752415445440000000000000000000000000000000060448201526064016108f6565b61016480547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905573ffffffffffffffffffffffffffffffffffffffff8116611ab6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f494e56414c49445f4f46545f434f4e545241435400000000000000000000000060448201526064016108f6565b611ac08383612fc6565b61010154735288c571fd7ad117bea99bf60fe0846c4e84f93390637b3a3c8b9073ffffffffffffffffffffffffffffffffffffffff16736c96de32cea08842dcc4058c14d3aaad7fa41dee611b1460355490565b604051806020016040528060008152506040518563ffffffff1660e01b8152600401611b43949392919061469d565b600060405180830381600087803b158015611b5d57600080fd5b505af1158015611b71573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0168201604052611bb7919081019061447b565b5061010080547fffffffffffffffffffffff0000000000000000000000000000000000000000ff1673ffffffffffffffffffffffffffffffffffffffff83168083029190911790915561010180547fffffffffffffffffffffffff00000000000000000000000000000000000000001690556040517f140c7f3c4dd16fa102e8e866bdbed4553b3cbe199ca01455115be3efc7ec6b6290600090a2505050565b33600090815260fe602052604090205460ff1615611cd1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f426c6f636b65643a206d73672e73656e64657220697320626c6f636b6564000060448201526064016108f6565b6118fe89898989898988888b604051602001611d2593929190928352602083019190915260f81b7fff0000000000000000000000000000000000000000000000000000000000000016604082015260410190565b6040516020818303038152906040526129e1565b60cc5473ffffffffffffffffffffffffffffffffffffffff163314611dba576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b73ffffffffffffffffffffffffffffffffffffffff8116611e5d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016108f6565b611e668161296a565b50565b6060603680546107d39061481d565b73ffffffffffffffffffffffffffffffffffffffff8316611f1a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016108f6565b73ffffffffffffffffffffffffffffffffffffffff8216611fbd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b73ffffffffffffffffffffffffffffffffffffffff83811660008181526034602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff82166120ce576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360448201527f730000000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b6120da8260008361302d565b73ffffffffffffffffffffffffffffffffffffffff821660009081526033602052604090205481811015612190576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60448201527f636500000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b73ffffffffffffffffffffffffffffffffffffffff831660009081526033602052604081208383039055603580548492906121cc9084906147da565b909155505060405182815260009073ffffffffffffffffffffffffffffffffffffffff8516907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a3505050565b600054610100900460ff168061223d575060005460ff16155b6122c9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561230857600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b612310613185565b612318613299565b8015611e6657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff16905550565b600054610100900460ff1680612362575060005460ff16155b6123ee576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561242d57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b612435613185565b61243f8383613386565b801561164957600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055505050565b600054610100900460ff168061248b575060005460ff16155b612517576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561255657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b61255e613185565b61259d826040518060400160405280600181526020017f31000000000000000000000000000000000000000000000000000000000000008152506134c5565b6125a6826135f9565b80156111d057600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff1690555050565b60006125e5848484612af2565b73ffffffffffffffffffffffffffffffffffffffff84166000908152603460209081526040808320338452909152902054828110156126a6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602860248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206160448201527f6c6c6f77616e636500000000000000000000000000000000000000000000000060648201526084016108f6565b6126b38533858403611e78565b506001949350505050565b600061085e7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6126ec613733565b6066546040805160208101859052908101839052606081018290524660808201523060a082015260009060c0016040516020818303038152906040528051906020012090509392505050565b73ffffffffffffffffffffffffffffffffffffffff82166127b5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016108f6565b6127c16000838361302d565b80603560008282546127d391906147c2565b909155505073ffffffffffffffffffffffffffffffffffffffff82166000908152603360205260408120805483929061280d9084906147c2565b909155505060405181815273ffffffffffffffffffffffffffffffffffffffff8316906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050565b61286e8383613749565b604080517f158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429602082015273ffffffffffffffffffffffffffffffffffffffff851691810191909152606081018390526128e39084906080015b60405160208183030381529060405280519060200120836137e5565b73ffffffffffffffffffffffffffffffffffffffff831660008181526101026020908152604080832086845290915280822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055518492917f1cdd46ff242716cdaa72d159d339a485b3438398348d68f09d7c8c0a59353d8191a3505050565b60cc805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b73ffffffffffffffffffffffffffffffffffffffff86163314612a60576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f546574686572546f6b656e3a20746f20213d206d73672e73656e64657200000060448201526064016108f6565b612a6c8783868661389b565b604080517fd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8602082015273ffffffffffffffffffffffffffffffffffffffff808a169282019290925290871660608201526080810186905260a0810185905260c0810184905260e08101839052612ae8908890610100016128c7565b61138a8783613977565b73ffffffffffffffffffffffffffffffffffffffff8316612b95576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016108f6565b73ffffffffffffffffffffffffffffffffffffffff8216612c38576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b612c4383838361302d565b73ffffffffffffffffffffffffffffffffffffffff831660009081526033602052604090205481811015612cf9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016108f6565b73ffffffffffffffffffffffffffffffffffffffff808516600090815260336020526040808220858503905591851681529081208054849290612d3d9084906147c2565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051612da391815260200190565b60405180910390a3610b6e565b6060603780546107d39061481d565b81421115612e29576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f45524332305065726d69743a206578706972656420646561646c696e6500000060448201526064016108f6565b60007f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9868686612e588a6139fd565b60408051602081019690965273ffffffffffffffffffffffffffffffffffffffff94851690860152929091166060840152608083015260a082015260c0810184905260e0016040516020818303038152906040528051906020012090506000612ec082613a32565b9050612ecd878285613a9b565b612f33576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f454950323631323a20696e76616c6964207369676e617475726500000000000060448201526064016108f6565b61138a878787611e78565b612f4a8783868661389b565b604080517f7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267602082015273ffffffffffffffffffffffffffffffffffffffff808a169282019290925290871660608201526080810186905260a0810185905260c0810184905260e08101839052612ae8908890610100016128c7565b8151612fda90610165906020850190613f61565b508051612fef90610166906020840190613f61565b507f90322812e6761e312b99024e89e7408714261709c6d7f874d796927e813a6f728282604051613021929190614708565b60405180910390a15050565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260fe602052604090205460ff161580613079575060cc5473ffffffffffffffffffffffffffffffffffffffff1633145b6130df576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f546574686572546f6b656e3a2066726f6d20697320626c6f636b65640000000060448201526064016108f6565b73ffffffffffffffffffffffffffffffffffffffff8216301415611649576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602d60248201527f546574686572546f6b656e3a207472616e7366657220746f2074686520636f6e60448201527f747261637420616464726573730000000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff168061319e575060005460ff16155b61322a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561231857600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790558015611e6657600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff16905550565b600054610100900460ff16806132b2575060005460ff16155b61333e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561337d57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b6123183361296a565b600054610100900460ff168061339f575060005460ff16155b61342b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff1615801561346a57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b825161347d906036906020860190613f61565b508151613491906037906020850190613f61565b50801561164957600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055505050565b600054610100900460ff16806134de575060005460ff16155b61356a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff161580156135a957600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b8251602080850191909120835191840191909120606591909155606655801561164957600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055505050565b600054610100900460ff1680613612575060005460ff16155b61369e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084016108f6565b600054610100900460ff161580156136dd57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000166101011790555b7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9609a5580156111d057600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff1690555050565b600061373d6107ae565b80519060200120905090565b73ffffffffffffffffffffffffffffffffffffffff821660009081526101026020908152604080832084845290915290205460ff16156111d0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f546574686572546f6b656e3a206175746820696e76616c69640000000000000060448201526064016108f6565b6138358361382f6137f4610e42565b856040517f19010000000000000000000000000000000000000000000000000000000000008152600281019290925260228201526042902090565b83613a9b565b611649576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f546574686572546f6b656e3a20696e76616c6964207369676e6174757265000060448201526064016108f6565b814211613904576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f546574686572546f6b656e3a2061757468206561726c7900000000000000000060448201526064016108f6565b80421061396d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f546574686572546f6b656e3a206175746820657870697265640000000000000060448201526064016108f6565b610b6e8484613749565b73ffffffffffffffffffffffffffffffffffffffff821660008181526101026020908152604080832085845290915280822080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055518392917f98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a591a35050565b73ffffffffffffffffffffffffffffffffffffffff811660009081526099602052604090208054600181018255905b50919050565b60006111fb613a3f6126be565b836040517f19010000000000000000000000000000000000000000000000000000000000006020820152602281018390526042810182905260009060620160405160208183030381529060405280519060200120905092915050565b6000833b613ae2578373ffffffffffffffffffffffffffffffffffffffff16613ac48484613aed565b73ffffffffffffffffffffffffffffffffffffffff16149050610e3b565b610e38848484613ba8565b60008151604114613b80576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45435265636f7665723a20696e76616c6964207369676e6174757265206c656e60448201527f677468000000000000000000000000000000000000000000000000000000000060648201526084016108f6565b60208201516040830151606084015160001a613b9e86828585613d05565b9695505050505050565b60008060008573ffffffffffffffffffffffffffffffffffffffff16631626ba7e60e01b8686604051602401613bdf9291906146dc565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529181526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909416939093179092529051613c689190614681565b600060405180830381855afa9150503d8060008114613ca3576040519150601f19603f3d011682016040523d82523d6000602084013e613ca8565b606091505b5091509150818015613cbc57506020815110155b8015613b9e575080517f1626ba7e0000000000000000000000000000000000000000000000000000000090613cfa9083016020908101908401614463565b149695505050505050565b60007f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0821115613db7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45435265636f7665723a20696e76616c6964207369676e61747572652027732760448201527f2076616c7565000000000000000000000000000000000000000000000000000060648201526084016108f6565b8360ff16601b14158015613dcf57508360ff16601c14155b15613e5c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45435265636f7665723a20696e76616c6964207369676e61747572652027762760448201527f2076616c7565000000000000000000000000000000000000000000000000000060648201526084016108f6565b6040805160008082526020820180845288905260ff871692820192909252606081018590526080810184905260019060a0016020604051602081039080840390855afa158015613eb0573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116613f58576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f45435265636f7665723a20696e76616c6964207369676e61747572650000000060448201526064016108f6565b95945050505050565b828054613f6d9061481d565b90600052602060002090601f016020900481019282613f8f5760008555613fd5565b82601f10613fa857805160ff1916838001178555613fd5565b82800160010185558215613fd5579182015b82811115613fd5578251825591602001919060010190613fba565b50613fe1929150613fe5565b5090565b5b80821115613fe15760008155600101613fe6565b803573ffffffffffffffffffffffffffffffffffffffff8116811461401e57600080fd5b919050565b60008083601f840112614034578182fd5b50813567ffffffffffffffff81111561404b578182fd5b6020830191508360208260051b850101111561406657600080fd5b9250929050565b600082601f83011261407d578081fd5b813561409061408b8261477c565b61472d565b8181528460208386010111156140a4578283fd5b816020850160208301379081016020019190915292915050565b803560ff8116811461401e57600080fd5b6000602082840312156140e0578081fd5b610e3b82613ffa565b600080604083850312156140fb578081fd5b61410483613ffa565b915061411260208401613ffa565b90509250929050565b60008060006060848603121561412f578081fd5b61413884613ffa565b925061414660208501613ffa565b9150604084013590509250925092565b600080600080600060a0868803121561416d578081fd5b61417686613ffa565b945061418460208701613ffa565b93506040860135925060608601359150608086013567ffffffffffffffff8111156141ad578182fd5b6141b98882890161406d565b9150509295509295909350565b600080600080600080600060e0888a0312156141e0578182fd5b6141e988613ffa565b96506141f760208901613ffa565b955060408801359450606088013593506080880135925060a0880135915060c088013567ffffffffffffffff81111561422e578182fd5b61423a8a828b0161406d565b91505092959891949750929550565b60008060008060008060008060006101208a8c031215614267578182fd5b6142708a613ffa565b985061427e60208b01613ffa565b975060408a0135965060608a0135955060808a0135945060a08a013593506142a860c08b016140be565b925060e08a013591506101008a013590509295985092959850929598565b600080600080600080600060e0888a0312156142e0578081fd5b6142e988613ffa565b96506142f760208901613ffa565b95506040880135945060608801359350614313608089016140be565b925060a0880135915060c0880135905092959891949750929550565b60008060408385031215614341578182fd5b61434a83613ffa565b946020939093013593505050565b60008060006060848603121561436c578081fd5b61437584613ffa565b925060208401359150604084013567ffffffffffffffff811115614397578182fd5b6143a38682870161406d565b9150509250925092565b600080600080600060a086880312156143c4578283fd5b6143cd86613ffa565b9450602086013593506143e2604087016140be565b94979396509394606081013594506080013592915050565b6000806000806040858703121561440f578182fd5b843567ffffffffffffffff80821115614426578384fd5b61443288838901614023565b9096509450602087013591508082111561444a578384fd5b5061445787828801614023565b95989497509550505050565b600060208284031215614474578081fd5b5051919050565b60006020828403121561448c578081fd5b815167ffffffffffffffff8111156144a2578182fd5b8201601f810184136144b2578182fd5b80516144c061408b8261477c565b8181528560208385010111156144d4578384fd5b613f588260208301602086016147f1565b600080604083850312156144f7578182fd5b823567ffffffffffffffff8082111561450e578384fd5b61451a8683870161406d565b9350602085013591508082111561452f578283fd5b5061453c8582860161406d565b9150509250929050565b60008060006060848603121561455a578081fd5b833567ffffffffffffffff80821115614571578283fd5b61457d8783880161406d565b94506020860135915080821115614592578283fd5b5061459f8682870161406d565b9250506145ae60408501613ffa565b90509250925092565b6000806000606084860312156145cb578081fd5b833567ffffffffffffffff808211156145e2578283fd5b6145ee8783880161406d565b94506020860135915080821115614603578283fd5b506146108682870161406d565b9250506145ae604085016140be565b600060208284031215614630578081fd5b5035919050565b6000815180845261464f8160208601602086016147f1565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600082516146938184602087016147f1565b9190910192915050565b600073ffffffffffffffffffffffffffffffffffffffff808716835280861660208401525083604083015260806060830152613b9e6080830184614637565b828152604060208201526000610e386040830184614637565b602081526000610e3b6020830184614637565b60408152600061471b6040830185614637565b8281036020840152613f588185614637565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715614774576147746148d3565b604052919050565b600067ffffffffffffffff821115614796576147966148d3565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b600082198211156147d5576147d56148a4565b500190565b6000828210156147ec576147ec6148a4565b500390565b60005b8381101561480c5781810151838201526020016147f4565b83811115610b6e5750506000910152565b600181811c9082168061483157607f821691505b60208210811415613a2c577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82141561489d5761489d6148a4565b5060010190565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fdfea2646970667358221220eec2a20e56a2c75c3f4ea9b125a3660a5fe2b39bd4c8f2577cd4519680e8c23064736f6c63430008040033","name":"ArbitrumExtensionV2","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"istanbul","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    function __Ownable_init() internal initializer {\n        __Context_init_unchained();\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal initializer {\n        _setOwner(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _setOwner(newOwner);\n    }\n\n    function _setOwner(address newOwner) private {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n    uint256[49] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     */\n    bool private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Modifier to protect an initializer function from being invoked twice.\n     */\n    modifier initializer() {\n        require(_initializing || !_initialized, \"Initializable: contract is already initialized\");\n\n        bool isTopLevelCall = !_initializing;\n        if (isTopLevelCall) {\n            _initializing = true;\n            _initialized = true;\n        }\n\n        _;\n\n        if (isTopLevelCall) {\n            _initializing = false;\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * The default value of {decimals} is 18. To select a different value for\n     * {decimals} you should overload it.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\n        __Context_init_unchained();\n        __ERC20_init_unchained(name_, symbol_);\n    }\n\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n\n        uint256 currentAllowance = _allowances[sender][_msgSender()];\n        require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n        unchecked {\n            _approve(sender, _msgSender(), currentAllowance - amount);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        uint256 currentAllowance = _allowances[_msgSender()][spender];\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `sender` to `recipient`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        uint256 senderBalance = _balances[sender];\n        require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[sender] = senderBalance - amount;\n        }\n        _balances[recipient] += amount;\n\n        emit Transfer(sender, recipient, amount);\n\n        _afterTokenTransfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n        }\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n    uint256[45] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./draft-IERC20PermitUpgradeable.sol\";\nimport \"../ERC20Upgradeable.sol\";\nimport \"../../../utils/cryptography/draft-EIP712Upgradeable.sol\";\nimport \"../../../utils/cryptography/ECDSAUpgradeable.sol\";\nimport \"../../../utils/CountersUpgradeable.sol\";\nimport \"../../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * _Available since v3.4._\n */\nabstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {\n    using CountersUpgradeable for CountersUpgradeable.Counter;\n\n    mapping(address => CountersUpgradeable.Counter) private _nonces;\n\n    // solhint-disable-next-line var-name-mixedcase\n    bytes32 private _PERMIT_TYPEHASH;\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\n     */\n    function __ERC20Permit_init(string memory name) internal initializer {\n        __Context_init_unchained();\n        __EIP712_init_unchained(name, \"1\");\n        __ERC20Permit_init_unchained(name);\n    }\n\n    function __ERC20Permit_init_unchained(string memory name) internal initializer {\n        _PERMIT_TYPEHASH = keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");}\n\n    /**\n     * @dev See {IERC20Permit-permit}.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        require(block.timestamp <= deadline, \"ERC20Permit: expired deadline\");\n\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ECDSAUpgradeable.recover(hash, v, r, s);\n        require(signer == owner, \"ERC20Permit: invalid signature\");\n\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @dev See {IERC20Permit-nonces}.\n     */\n    function nonces(address owner) public view virtual override returns (uint256) {\n        return _nonces[owner].current();\n    }\n\n    /**\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n\n    /**\n     * @dev \"Consume a nonce\": return the current value and increment.\n     *\n     * _Available since v4.1._\n     */\n    function _useNonce(address owner) internal virtual returns (uint256 current) {\n        CountersUpgradeable.Counter storage nonce = _nonces[owner];\n        current = nonce.current();\n        nonce.increment();\n    }\n    uint256[49] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20PermitUpgradeable {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal initializer {\n        __Context_init_unchained();\n    }\n\n    function __Context_init_unchained() internal initializer {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n    uint256[50] private __gap;\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary CountersUpgradeable {\n    struct Counter {\n        // This variable should never be directly accessed by users of the library: interactions must be restricted to\n        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n        // this feature: see https://github.com/ethereum/solidity/issues/4637\n        uint256 _value; // default: 0\n    }\n\n    function current(Counter storage counter) internal view returns (uint256) {\n        return counter._value;\n    }\n\n    function increment(Counter storage counter) internal {\n        unchecked {\n            counter._value += 1;\n        }\n    }\n\n    function decrement(Counter storage counter) internal {\n        uint256 value = counter._value;\n        require(value > 0, \"Counter: decrement overflow\");\n        unchecked {\n            counter._value = value - 1;\n        }\n    }\n\n    function reset(Counter storage counter) internal {\n        counter._value = 0;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\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 ECDSAUpgradeable {\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 opcode 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     * 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 {toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\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 recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        // Check the signature length\n        // - case 65: r,s,v signature (standard)\n        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\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 {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return recover(hash, v, r, s);\n        } else if (signature.length == 64) {\n            bytes32 r;\n            bytes32 vs;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly {\n                r := mload(add(signature, 0x20))\n                vs := mload(add(signature, 0x40))\n            }\n            return recover(hash, r, vs);\n        } else {\n            revert(\"ECDSA: invalid signature length\");\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n     *\n     * _Available since v4.2._\n     */\n    function recover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address) {\n        bytes32 s;\n        uint8 v;\n        assembly {\n            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n            v := add(shr(255, vs), 27)\n        }\n        return recover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`, `r` and `s` signature fields separately.\n     */\n    function recover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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        require(\n            uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,\n            \"ECDSA: invalid signature 's' value\"\n        );\n        require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        require(signer != address(0), \"ECDSA: invalid signature\");\n\n        return signer;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Typed Data, created from a\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\n     * to the one signed with the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n     * JSON-RPC method as part of EIP-712.\n     *\n     * See {recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n    }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./ECDSAUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712Upgradeable is Initializable {\n    /* solhint-disable var-name-mixedcase */\n    bytes32 private _HASHED_NAME;\n    bytes32 private _HASHED_VERSION;\n    bytes32 private constant _TYPE_HASH = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    function __EIP712_init(string memory name, string memory version) internal initializer {\n        __EIP712_init_unchained(name, version);\n    }\n\n    function __EIP712_init_unchained(string memory name, string memory version) internal initializer {\n        bytes32 hashedName = keccak256(bytes(name));\n        bytes32 hashedVersion = keccak256(bytes(version));\n        _HASHED_NAME = hashedName;\n        _HASHED_VERSION = hashedVersion;\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());\n    }\n\n    function _buildDomainSeparator(\n        bytes32 typeHash,\n        bytes32 nameHash,\n        bytes32 versionHash\n    ) private view returns (bytes32) {\n        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /**\n     * @dev The hash of the name parameter for the EIP712 domain.\n     *\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\n     * are a concern.\n     */\n    function _EIP712NameHash() internal virtual view returns (bytes32) {\n        return _HASHED_NAME;\n    }\n\n    /**\n     * @dev The hash of the version parameter for the EIP712 domain.\n     *\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\n     * are a concern.\n     */\n    function _EIP712VersionHash() internal virtual view returns (bytes32) {\n        return _HASHED_VERSION;\n    }\n    uint256[50] private __gap;\n}\n"},{"file_path":"contracts/Tether/EIP3009.sol","source_code":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * \n * ---------------------------------------------------------------------\n * \n * Adapted by Tether.to 2024 for greater flexibility and reusability\n */\n\npragma solidity >=0.6.12 <0.9.0;\n\nimport { SignatureChecker } from \"./util/SignatureChecker.sol\";\nimport { MessageHashUtils } from \"./util/MessageHashUtils.sol\";\n\n/**\n * @title EIP-3009\n * @notice Provide internal implementation for gas-abstracted transfers\n * @dev Contracts that inherit from this must wrap these with publicly\n * accessible functions, optionally adding modifiers where necessary\n */\nabstract contract EIP3009 {\n    bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = keccak256(\"TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\");\n\n    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = keccak256(\"ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\");\n\n    bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH = keccak256(\"CancelAuthorization(address authorizer,bytes32 nonce)\");\n\n    /**\n     * @dev authorizer address => nonce => bool (true if nonce is used)\n     */\n    mapping(address => mapping(bytes32 => bool)) private _authorizationStates;\n\n    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);\n    event AuthorizationCanceled(\n        address indexed authorizer,\n        bytes32 indexed nonce\n    );\n\n    function domainSeparator() internal virtual view returns (bytes32);\n\n    /**\n     * @notice Returns the state of an authorization\n     * @dev Nonces are randomly generated 32-byte data unique to the\n     * authorizer's address\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @return True if the nonce is used\n     */\n    function authorizationState(address authorizer, bytes32 nonce)\n        external\n        view\n        returns (bool)\n    {\n        return _authorizationStates[authorizer][nonce];\n    }\n\n    /**\n     * @notice Execute a transfer with a signed authorization\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param signature signature in bytes\n     */\n    function _transferWithAuthorizationValidityCheck(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) internal {\n        _requireValidAuthorization(from, nonce, validAfter, validBefore);\n        _requireValidSignature(\n            from,\n            keccak256(\n                abi.encode(\n                    TRANSFER_WITH_AUTHORIZATION_TYPEHASH,\n                    from,\n                    to,\n                    value,\n                    validAfter,\n                    validBefore,\n                    nonce\n                )\n            ),\n            signature\n        );\n\n        _markAuthorizationAsUsed(from, nonce);\n    }\n\n    /**\n     * @notice Receive a transfer with a signed authorization from the payer\n     * @dev This has an additional check to ensure that the payee's address\n     * matches the caller of this function to prevent front-running attacks.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param signature signature in bytes\n     */\n    function _receiveWithAuthorizationValidityCheck(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) internal {\n        require(to == msg.sender, \"TetherToken: to != msg.sender\");\n        _requireValidAuthorization(from, nonce, validAfter, validBefore);\n        _requireValidSignature(\n            from,\n            keccak256(\n                abi.encode(\n                    RECEIVE_WITH_AUTHORIZATION_TYPEHASH,\n                    from,\n                    to,\n                    value,\n                    validAfter,\n                    validBefore,\n                    nonce\n                )\n            ),\n            signature\n        );\n\n        _markAuthorizationAsUsed(from, nonce);\n    }\n\n    function _cancelAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        bytes memory signature\n    ) internal {\n        _requireUnusedAuthorization(authorizer, nonce);\n        _requireValidSignature(\n            authorizer,\n            keccak256(\n                abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce)\n            ),\n            signature\n        );\n\n        _authorizationStates[authorizer][nonce] = true;\n        emit AuthorizationCanceled(authorizer, nonce);\n    }\n\n    /**\n     * @notice Attempt to cancel an authorization\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function cancelAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public {\n        _cancelAuthorization(authorizer, nonce, abi.encodePacked(r,s,v));\n    }\n\n    /**\n     * @notice Attempt to cancel an authorization\n     * @dev Works only if the authorization is not yet used.\n     * EOA wallet signatures should be packed in the order of r, s, v.\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param signature     Signature bytes signed by an EOA wallet or a contract wallet\n     */\n    function cancelAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        bytes memory signature\n    ) external {\n        _cancelAuthorization(authorizer, nonce, signature);\n    }\n\n    /**\n     * @notice Validates that signature against input data struct\n     * @param signer        Signer's address\n     * @param dataHash      Hash of encoded data struct\n     * @param signature signature in bytes\n     */\n    function _requireValidSignature(\n        address signer,\n        bytes32 dataHash,\n        bytes memory signature\n    ) private view {\n        require(\n            SignatureChecker.isValidSignatureNow(\n                signer,\n                MessageHashUtils.toTypedDataHash(domainSeparator(), dataHash),\n                signature\n            ),\n            \"TetherToken: invalid signature\"\n        );\n    }\n\n    /**\n     * @notice Check that an authorization is unused\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     */\n    function _requireUnusedAuthorization(address authorizer, bytes32 nonce)\n        private\n        view\n    {\n        require(\n            !_authorizationStates[authorizer][nonce],\n            \"TetherToken: auth invalid\"\n        );\n    }\n\n    /**\n     * @notice Check that authorization is valid\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     */\n    function _requireValidAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        uint256 validAfter,\n        uint256 validBefore\n    ) private view {\n        require(\n            block.timestamp > validAfter,\n            \"TetherToken: auth early\"\n        );\n        require(block.timestamp < validBefore, \"TetherToken: auth expired\");\n        _requireUnusedAuthorization(authorizer, nonce);\n    }\n\n    /**\n     * @notice Mark an authorization as used\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     */\n    function _markAuthorizationAsUsed(address authorizer, bytes32 nonce)\n        private\n    {\n        _authorizationStates[authorizer][nonce] = true;\n        emit AuthorizationUsed(authorizer, nonce);\n    }\n\n    uint256[49] private __gap;\n}"},{"file_path":"contracts/Tether/TetherToken.sol","source_code":"// SPDX-License-Identifier: Apache 2.0\n\npragma solidity 0.8.4;\n\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol\";\nimport \"./WithBlockedList.sol\";\n\n/*\n\n   Copyright Tether.to 2024\n\n   Version 2.0(a)\n\n   Licensed under the Apache License, Version 2.0\n   http://www.apache.org/licenses/LICENSE-2.0\n\n*/\n\ncontract TetherToken is\n    Initializable,\n    ERC20PermitUpgradeable,\n    OwnableUpgradeable,\n    WithBlockedList\n{\n    // Unused variable retained to preserve storage slots across upgrades\n    mapping(address => bool) public isTrusted;\n\n    uint8 private tetherDecimals;\n\n    function initialize(\n        string memory _name,\n        string memory _symbol,\n        uint8 _decimals\n    ) public initializer {\n        tetherDecimals = _decimals;\n        __Ownable_init();\n        __ERC20_init(_name, _symbol);\n        __ERC20Permit_init(_name);\n    }\n\n    function decimals() public view virtual override returns (uint8) {\n        return tetherDecimals;\n    }\n\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256\n    ) internal virtual override {\n        require(!isBlocked[from] || msg.sender == owner(), \"TetherToken: from is blocked\");\n        require( \n            to != address(this), \n            \"TetherToken: transfer to the contract address\" \n        ); \n    }\n\n    function transferFrom(\n        address _sender,\n        address _recipient,\n        uint256 _amount\n    ) public virtual override onlyNotBlocked returns (bool) {\n        return super.transferFrom(_sender, _recipient, _amount);\n    }\n\n    function multiTransfer (\n        address[] calldata _recipients,\n        uint256[] calldata _values\n    ) external {\n        require(\n            _recipients.length == _values.length,\n            \"TetherToken: multiTransfer mismatch\"\n        );\n        for (uint256 i = 0; i < _recipients.length; i++) {\n            transfer(_recipients[i], _values[i]);\n        }\n    }\n\n    function mint(address _destination, uint256 _amount) public virtual onlyOwner {\n        _mint(_destination, _amount);\n        emit Mint(_destination, _amount);\n    }\n\n    function redeem(uint256 _amount) public virtual onlyOwner {\n        _burn(owner(), _amount);\n        emit Redeem(_amount);\n    }\n\n    function destroyBlockedFunds(address _blockedUser) public onlyOwner {\n        require(isBlocked[_blockedUser], \"TetherToken: user is not blocked\");\n        uint256 blockedFunds = balanceOf(_blockedUser);\n        _burn(_blockedUser, blockedFunds);\n        emit DestroyedBlockedFunds(_blockedUser, blockedFunds);\n    }\n\n    event Mint(address indexed _destination, uint256 _amount);\n    event Redeem(uint256 _amount);\n    event DestroyedBlockedFunds(address indexed _blockedUser, uint256 _balance);\n}\n"},{"file_path":"contracts/Tether/WithBlockedList.sol","source_code":"// SPDX-License-Identifier: Apache 2.0\n\npragma solidity 0.8.4;\n\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\n\n/*\n\n   Copyright Tether.to 2020\n\n   Author Will Harborne\n\n   Licensed under the Apache License, Version 2.0\n   http://www.apache.org/licenses/LICENSE-2.0\n\n*/\n\n\ncontract WithBlockedList is OwnableUpgradeable {\n\n    /**\n     * @dev Reverts if called by a blocked account\n     */\n    modifier onlyNotBlocked() {\n      require(!isBlocked[_msgSender()], \"Blocked: msg.sender is blocked\");\n      _;\n    }\n\n    mapping (address => bool) public isBlocked;\n\n    function addToBlockedList (address _user) public onlyOwner {\n        isBlocked[_user] = true;\n        emit BlockPlaced(_user);\n    }\n\n    function removeFromBlockedList (address _user) public onlyOwner {\n        isBlocked[_user] = false;\n        emit BlockReleased(_user);\n    }\n\n    event BlockPlaced(address indexed _user);\n\n    event BlockReleased(address indexed _user);\n    \n}\n"},{"file_path":"contracts/Tether/interfaces/IERC1271.sol","source_code":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * \n * ---------------------------------------------------------------------\n * \n * Adapted by Tether.to 2024 for greater flexibility and reusability\n */\n\npragma solidity >=0.6.12 <0.9.0;\n\n/**\n * @dev Interface of the ERC1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash          Hash of the data to be signed\n     * @param signature     Signature byte array associated with the provided data hash\n     * @return magicValue   bytes4 magic value 0x1626ba7e when function passes\n     */\n    function isValidSignature(bytes32 hash, bytes memory signature)\n        external\n        view\n        returns (bytes4 magicValue);\n}"},{"file_path":"contracts/Tether/util/ECRecover.sol","source_code":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * \n * ---------------------------------------------------------------------\n * \n * Adapted by Tether.to 2024 for greater flexibility and reusability\n */\n\npragma solidity >=0.6.12 <0.9.0;\n\n/**\n * @title ECRecover\n * @notice A library that provides a safe ECDSA recovery function\n */\nlibrary ECRecover {\n    /**\n     * @notice Recover signer's address from a signed message\n     * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/65e4ffde586ec89af3b7e9140bdc9235d1254853/contracts/cryptography/ECDSA.sol\n     * Modifications: Accept v, r, and s as separate arguments\n     * @param digest    Keccak-256 hash digest of the signed message\n     * @param v         v of the signature\n     * @param r         r of the signature\n     * @param s         s of the signature\n     * @return Signer address\n     */\n    function recover(\n        bytes32 digest,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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 (\n            uint256(s) >\n            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0\n        ) {\n            revert(\"ECRecover: invalid signature 's' value\");\n        }\n\n        if (v != 27 && v != 28) {\n            revert(\"ECRecover: invalid signature 'v' value\");\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(digest, v, r, s);\n        require(signer != address(0), \"ECRecover: invalid signature\");\n\n        return signer;\n    }\n\n    /**\n     * @notice Recover signer's address from a signed message\n     * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/0053ee040a7ff1dbc39691c9e67a69f564930a88/contracts/utils/cryptography/ECDSA.sol\n     * @param digest    Keccak-256 hash digest of the signed message\n     * @param signature Signature byte array associated with hash\n     * @return Signer address\n     */\n    function recover(bytes32 digest, bytes memory signature)\n        internal\n        pure\n        returns (address)\n    {\n        require(signature.length == 65, \"ECRecover: invalid signature length\");\n\n        bytes32 r;\n        bytes32 s;\n        uint8 v;\n\n        // ecrecover takes the signature parameters, and the only way to get them\n        // currently is to use assembly.\n        /// @solidity memory-safe-assembly\n        assembly {\n            r := mload(add(signature, 0x20))\n            s := mload(add(signature, 0x40))\n            v := byte(0, mload(add(signature, 0x60)))\n        }\n        return recover(digest, v, r, s);\n    }\n}"},{"file_path":"contracts/Tether/util/MessageHashUtils.sol","source_code":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * \n * ---------------------------------------------------------------------\n * \n * Adapted by Tether.to 2024 for greater flexibility and reusability\n */\n\npragma solidity >=0.6.12 <0.9.0;\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).\n     * Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/21bb89ef5bfc789b9333eb05e3ba2b7b284ac77c/contracts/utils/cryptography/MessageHashUtils.sol\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * @param domainSeparator    Domain separator\n     * @param structHash         Hashed EIP-712 data struct\n     * @return digest            The keccak256 digest of an EIP-712 typed data\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)\n        internal\n        pure\n        returns (bytes32 digest)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let ptr := mload(0x40)\n            mstore(ptr, \"\\x19\\x01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}"},{"file_path":"contracts/Tether/util/SignatureChecker.sol","source_code":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * \n * ---------------------------------------------------------------------\n * \n * Adapted by Tether.to 2024 for greater flexibility and reusability\n */\n\npragma solidity >=0.6.12 <0.9.0;\n\nimport { ECRecover } from \"./ECRecover.sol\";\nimport { IERC1271 } from \"../interfaces/IERC1271.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECRecover.recover` to seamlessly support both ECDSA\n * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets.\n *\n * Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/21bb89ef5bfc789b9333eb05e3ba2b7b284ac77c/contracts/utils/cryptography/SignatureChecker.sol\n */\nlibrary SignatureChecker {\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\n     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECRecover.recover`.\n     * @param signer        Address of the claimed signer\n     * @param digest        Keccak-256 hash digest of the signed message\n     * @param signature signature byte array associated with hash\n     */\n    function isValidSignatureNow(\n        address signer,\n        bytes32 digest,\n        bytes memory signature\n    ) internal view returns (bool) {\n        if (!isContract(signer)) {\n            return ECRecover.recover(digest, signature) == signer;\n        }\n        return isValidERC1271SignatureNow(signer, digest, signature);\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC1271.\n     * @param signer        Address of the claimed signer\n     * @param digest        Keccak-256 hash digest of the signed message\n     * @param signature     Signature byte array associated with hash\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 digest,\n        bytes memory signature\n    ) internal view returns (bool) {\n        (bool success, bytes memory result) = signer.staticcall(\n            abi.encodeWithSelector(\n                IERC1271.isValidSignature.selector,\n                digest,\n                signature\n            )\n        );\n        return (success &&\n            result.length >= 32 &&\n            abi.decode(result, (bytes32)) ==\n            bytes32(IERC1271.isValidSignature.selector));\n    }\n\n    /**\n     * @dev Checks if the input address is a smart contract.\n     */\n    function isContract(address addr) internal view returns (bool) {\n        uint256 size;\n        assembly {\n            size := extcodesize(addr)\n        }\n        return size > 0;\n    }\n}"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[],"name":"NotImplemented","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorizer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"AuthorizationCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorizer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"AuthorizationUsed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_user","type":"address"}],"name":"BlockPlaced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_user","type":"address"}],"name":"BlockReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_blockedUser","type":"address"},{"indexed":false,"internalType":"uint256","name":"_balance","type":"uint256"}],"name":"DestroyedBlockedFunds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oftContract","type":"address"}],"name":"LogSetOFTContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"string","name":"symbol","type":"string"}],"name":"LogUpdateNameAndSymbol","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_destination","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"CANCEL_AUTHORIZATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RECEIVE_WITH_AUTHORIZATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRANSFER_WITH_AUTHORIZATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT0_L1_LOCKBOX","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"addToBlockedList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"authorizationState","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"bridgeBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"bridgeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"cancelAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"cancelAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_blockedUser","type":"address"}],"name":"destroyBlockedFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint8","name":"_decimals","type":"uint8"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isBlocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isTrusted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_oftContract","type":"address"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_destination","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"}],"name":"multiTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oftContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"receiveWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"receiveWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"removeFromBlockedList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_oftContract","type":"address"}],"name":"setOFTContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"transferWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"transferWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"name":"updateNameAndSymbol","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":true,"is_partially_verified":false,"package_name":null,"constructor_args":null}