{ "address": "0x0000000000D8e504002cC26E3Ec46D81971C1664", "abi": [ { "inputs": [ { "internalType": "uint256", "name": "coinType_", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "CoinTypeNotFound", "type": "error" }, { "inputs": [], "name": "InvalidSignature", "type": "error" }, { "inputs": [], "name": "NotOwnerOfContract", "type": "error" }, { "inputs": [], "name": "SignatureExpired", "type": "error" }, { "inputs": [], "name": "SignatureExpiryTooHigh", "type": "error" }, { "inputs": [], "name": "Unauthorised", "type": "error" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "addr", "type": "address" }, { "indexed": false, "internalType": "string", "name": "name", "type": "string" } ], "name": "NameForAddrChanged", "type": "event" }, { "inputs": [], "name": "coinType", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "addr", "type": "address" } ], "name": "nameForAddr", "outputs": [ { "internalType": "string", "name": "name", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "string", "name": "name", "type": "string" } ], "name": "setName", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "addr", "type": "address" }, { "internalType": "string", "name": "name", "type": "string" } ], "name": "setNameForAddr", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "addr", "type": "address" }, { "internalType": "uint256", "name": "signatureExpiry", "type": "uint256" }, { "internalType": "string", "name": "name", "type": "string" }, { "internalType": "uint256[]", "name": "coinTypes", "type": "uint256[]" }, { "internalType": "bytes", "name": "signature", "type": "bytes" } ], "name": "setNameForAddrWithSignature", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "contractAddr", "type": "address" }, { "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "uint256", "name": "signatureExpiry", "type": "uint256" }, { "internalType": "string", "name": "name", "type": "string" }, { "internalType": "uint256[]", "name": "coinTypes", "type": "uint256[]" }, { "internalType": "bytes", "name": "signature", "type": "bytes" } ], "name": "setNameForOwnableWithSignature", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "bytes4", "name": "interfaceID", "type": "bytes4" } ], "name": "supportsInterface", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0x86476b21a9f97c0dde853305653cfbc6c2c2bd3401eb42533e12c2d5e66d7369", "receipt": { "to": "0x353530fe74098903728ddb66ecdb70f52e568ec1", "from": "0x8e8db5ccef88cca9d624701db544989c996e3216", "transactionIndex": 0, "gasUsed": "1410833", "logsBloom": "0x00000000400000000000000200000000000000000000000000000000040000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000010000000000000000000000000000000000000000000000000000000000400000000000000000004000800000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000", "blockHash": "0x0edc6595d8704c7e95e417f0adee35458078a3e02d5520c6d2543f8c7c639792", "transactionHash": "0x86476b21a9f97c0dde853305653cfbc6c2c2bd3401eb42533e12c2d5e66d7369", "logs": [ { "blockNumber": 16604272, "blockHash": "0x0edc6595d8704c7e95e417f0adee35458078a3e02d5520c6d2543f8c7c639792", "transactionHash": "0x86476b21a9f97c0dde853305653cfbc6c2c2bd3401eb42533e12c2d5e66d7369", "transactionIndex": 0, "logIndex": 0, "removed": false, "address": "0x353530fe74098903728ddb66ecdb70f52e568ec1", "topics": [ "0x66753cd2356569ee081232e3be8909b950e0a76c1f8460c3a5e3c2be32b11bed" ], "data": "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" }, { "blockNumber": 16604272, "blockHash": "0x0edc6595d8704c7e95e417f0adee35458078a3e02d5520c6d2543f8c7c639792", "transactionHash": "0x86476b21a9f97c0dde853305653cfbc6c2c2bd3401eb42533e12c2d5e66d7369", "transactionIndex": 0, "logIndex": 1, "removed": false, "address": "0x353530fe74098903728ddb66ecdb70f52e568ec1", "topics": [ "0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e", "0xf8dbfe7cfcc2187d21cb103df27bf030ac361e15335bee749b1df39bc03f3619" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000000" } ], "blockNumber": 16604272, "cumulativeGasUsed": "1410833", "status": 1 }, "args": [ 2148018000 ], "numDeployments": 1, "solcInputHash": "53607203823ca934dc777094bb2d514e", "metadata": "{\"compiler\":{\"version\":\"0.8.26+commit.8a97fa7a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"coinType_\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CoinTypeNotFound\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotOwnerOfContract\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SignatureExpiryTooHigh\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorised\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameForAddrChanged\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"coinType\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"nameForAddr\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setNameForAddr\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"signatureExpiry\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"coinTypes\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"setNameForAddrWithSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"contractAddr\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"signatureExpiry\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"coinTypes\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"setNameForOwnableWithSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"NameForAddrChanged(address,string)\":{\"params\":{\"addr\":\"The address of the reverse record.\",\"name\":\"The name of the reverse record.\"}}},\"kind\":\"dev\",\"methods\":{\"constructor\":{\"params\":{\"coinType_\":\"The cointype converted from the chainId of the chain this contract is deployed to.\"}},\"nameForAddr(address)\":{\"params\":{\"addr\":\"The address to get the name for.\"},\"returns\":{\"name\":\"The name for the address.\"}},\"setName(string)\":{\"params\":{\"name\":\"The name to set.\"}},\"setNameForAddr(address,string)\":{\"params\":{\"addr\":\"The address to set the name for.\",\"name\":\"The name to set.\"}},\"setNameForAddrWithSignature(address,uint256,string,uint256[],bytes)\":{\"params\":{\"addr\":\"The address to set the name for.\",\"coinTypes\":\"The coin types to set. Must be inclusive of the coin type for the contract.\",\"name\":\"The name to set.\",\"signature\":\"The signature from the addr.\",\"signatureExpiry\":\"Date when the signature expires.\"}},\"setNameForOwnableWithSignature(address,address,uint256,string,uint256[],bytes)\":{\"params\":{\"coinTypes\":\"The coin types to set. Must be inclusive of the coin type for the contract.\",\"contractAddr\":\"The address of the contract to set the name for (implementing Ownable).\",\"name\":\"The name to set.\",\"owner\":\"The owner of the contract (via Ownable).\",\"signature\":\"The signature of an address that will return true on isValidSignature for the owner.\",\"signatureExpiry\":\"The expiry of the signature.\"}},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"}},\"title\":\"L2 Reverse Registrar\",\"version\":1},\"userdoc\":{\"errors\":{\"CoinTypeNotFound()\":[{\"notice\":\"Thrown when the coin type is not found in the provided array\"}],\"InvalidSignature()\":[{\"notice\":\"The signature is invalid\"}],\"NotOwnerOfContract()\":[{\"notice\":\"Thrown when the specified address is not the owner of the contract\"}],\"SignatureExpired()\":[{\"notice\":\"The signature has expired\"}],\"SignatureExpiryTooHigh()\":[{\"notice\":\"The signature expiry is too high\"}],\"Unauthorised()\":[{\"notice\":\"The caller is not authorised to perform the action\"}]},\"events\":{\"NameForAddrChanged(address,string)\":{\"notice\":\"Emitted when the name for an address is changed.\"}},\"kind\":\"user\",\"methods\":{\"coinType()\":{\"notice\":\"The coin type for the chain this contract is deployed to.\"},\"constructor\":{\"notice\":\"Initialises the contract by setting the coin type.\"},\"nameForAddr(address)\":{\"notice\":\"Returns the name for an address.\"},\"setName(string)\":{\"notice\":\"Sets the `nameForAddr()` record for the calling account.\"},\"setNameForAddr(address,string)\":{\"notice\":\"Sets the `nameForAddr()` record for the addr provided account.\"},\"setNameForAddrWithSignature(address,uint256,string,uint256[],bytes)\":{\"notice\":\"Sets the `nameForAddr()` record for the addr provided account using a signature.\"},\"setNameForOwnableWithSignature(address,address,uint256,string,uint256[],bytes)\":{\"notice\":\"Sets the `nameForAddr()` record for the contract provided that is owned with `Ownable`.\"}},\"notice\":\"An L2 Reverse Registrar. Deployed to each L2 chain.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/reverseRegistrar/L2ReverseRegistrar.sol\":\"L2ReverseRegistrar\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-v5/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Context} from \\\"../utils/Context.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 * The initial owner is set to the address provided by the deployer. This can\\n * 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 Ownable is Context {\\n address private _owner;\\n\\n /**\\n * @dev The caller account is not authorized to perform an operation.\\n */\\n error OwnableUnauthorizedAccount(address account);\\n\\n /**\\n * @dev The owner is not a valid owner account. (eg. `address(0)`)\\n */\\n error OwnableInvalidOwner(address owner);\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\\n */\\n constructor(address initialOwner) {\\n if (initialOwner == address(0)) {\\n revert OwnableInvalidOwner(address(0));\\n }\\n _transferOwnership(initialOwner);\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\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 the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n if (owner() != _msgSender()) {\\n revert OwnableUnauthorizedAccount(_msgSender());\\n }\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(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 if (newOwner == address(0)) {\\n revert OwnableInvalidOwner(address(0));\\n }\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/interfaces/IERC1271.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1271.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-1271 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 _data\\n */\\n function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\\n}\\n\",\"keccak256\":\"0x4aaaf1c0737dd16e81f0d2b9833c549747a5ede6873bf1444bc72aa572d03e98\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\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 Context {\\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\\n function _contextSuffixLength() internal view virtual returns (uint256) {\\n return 0;\\n }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n * using Panic for uint256;\\n *\\n * // Use any of the declared internal constants\\n * function foo() { Panic.GENERIC.panic(); }\\n *\\n * // Alternatively\\n * function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n /// @dev generic / unspecified error\\n uint256 internal constant GENERIC = 0x00;\\n /// @dev used by the assert() builtin\\n uint256 internal constant ASSERT = 0x01;\\n /// @dev arithmetic underflow or overflow\\n uint256 internal constant UNDER_OVERFLOW = 0x11;\\n /// @dev division or modulo by zero\\n uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n /// @dev enum conversion error\\n uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n /// @dev invalid encoding in storage\\n uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n /// @dev empty array pop\\n uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n /// @dev array out of bounds access\\n uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n /// @dev resource error (too large allocation or too large array)\\n uint256 internal constant RESOURCE_ERROR = 0x41;\\n /// @dev calling invalid internal function\\n uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n /// @dev Reverts with a panic code. Recommended to use with\\n /// the internal constants with predefined codes.\\n function panic(uint256 code) internal pure {\\n assembly (\\\"memory-safe\\\") {\\n mstore(0x00, 0x4e487b71)\\n mstore(0x20, code)\\n revert(0x1c, 0x24)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"./math/Math.sol\\\";\\nimport {SignedMath} from \\\"./math/SignedMath.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant HEX_DIGITS = \\\"0123456789abcdef\\\";\\n uint8 private constant ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev The `value` string doesn't fit in the specified `length`.\\n */\\n error StringsInsufficientHexLength(uint256 value, uint256 length);\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n assembly (\\\"memory-safe\\\") {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n assembly (\\\"memory-safe\\\") {\\n mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n */\\n function toStringSigned(int256 value) internal pure returns (string memory) {\\n return string.concat(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMath.abs(value)));\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n uint256 localValue = value;\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = HEX_DIGITS[localValue & 0xf];\\n localValue >>= 4;\\n }\\n if (localValue != 0) {\\n revert StringsInsufficientHexLength(value, length);\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\\n * representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\\n * representation, according to EIP-55.\\n */\\n function toChecksumHexString(address addr) internal pure returns (string memory) {\\n bytes memory buffer = bytes(toHexString(addr));\\n\\n // hash the hex part of buffer (skip length + 2 bytes, length 40)\\n uint256 hashValue;\\n assembly (\\\"memory-safe\\\") {\\n hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\\n }\\n\\n for (uint256 i = 41; i > 1; --i) {\\n // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\\n if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\\n // case shift by xoring with 0x20\\n buffer[i] ^= 0x20;\\n }\\n hashValue >>= 4;\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Returns true if the two strings are equal.\\n */\\n function equal(string memory a, string memory b) internal pure returns (bool) {\\n return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\\n }\\n}\\n\",\"keccak256\":\"0x725209b582291bb83058e3078624b53d15a133f7401c30295e7f3704181d2aed\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/cryptography/ECDSA.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS\\n }\\n\\n /**\\n * @dev The signature derives the `address(0)`.\\n */\\n error ECDSAInvalidSignature();\\n\\n /**\\n * @dev The signature has an invalid length.\\n */\\n error ECDSAInvalidSignatureLength(uint256 length);\\n\\n /**\\n * @dev The signature has an S value that is in the upper half order.\\n */\\n error ECDSAInvalidSignatureS(bytes32 s);\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\\n * return address(0) without also returning an error description. Errors are documented using an enum (error type)\\n * and a bytes32 providing additional information about the error.\\n *\\n * If no error is returned, then the address can be used for verification purposes.\\n *\\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n */\\n function tryRecover(\\n bytes32 hash,\\n bytes memory signature\\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\\n if (signature.length == 65) {\\n bytes32 r;\\n bytes32 s;\\n uint8 v;\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n assembly (\\\"memory-safe\\\") {\\n r := mload(add(signature, 0x20))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return tryRecover(hash, v, r, s);\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\\n _throwError(error, errorArg);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\\n */\\n function tryRecover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\\n unchecked {\\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\\n // We do not check for an overflow here since the shift operation results in 0 or 1.\\n uint8 v = uint8((uint256(vs) >> 255) + 27);\\n return tryRecover(hash, v, r, s);\\n }\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n */\\n function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\\n _throwError(error, errorArg);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function tryRecover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (302): v \\u2208 {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS, s);\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature, bytes32(0));\\n }\\n\\n return (signer, RecoverError.NoError, bytes32(0));\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\\n _throwError(error, errorArg);\\n return recovered;\\n }\\n\\n /**\\n * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\\n */\\n function _throwError(RecoverError error, bytes32 errorArg) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing\\n } else if (error == RecoverError.InvalidSignature) {\\n revert ECDSAInvalidSignature();\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert ECDSAInvalidSignatureLength(uint256(errorArg));\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert ECDSAInvalidSignatureS(errorArg);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/cryptography/MessageHashUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Strings} from \\\"../Strings.sol\\\";\\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[ERC-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 ERC-191 signed data with version\\n * `0x45` (`personal_sign` messages).\\n *\\n * The digest is calculated by prefixing a bytes32 `messageHash` with\\n * `\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\"` and hashing the result. It corresponds with the\\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\\n *\\n * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\\n * keccak256, although any bytes32 value can be safely used because the final digest will\\n * be re-hashed.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\\n assembly (\\\"memory-safe\\\") {\\n mstore(0x00, \\\"\\\\x19Ethereum Signed Message:\\\\n32\\\") // 32 is the bytes-length of messageHash\\n mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\\n digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\\n }\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an ERC-191 signed data with version\\n * `0x45` (`personal_sign` messages).\\n *\\n * The digest is calculated by prefixing an arbitrary `message` with\\n * `\\\"\\\\x19Ethereum Signed Message:\\\\n\\\" + len(message)` and hashing the result. It corresponds with the\\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\\n return\\n keccak256(bytes.concat(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", bytes(Strings.toString(message.length)), message));\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an ERC-191 signed data with version\\n * `0x00` (data with intended validator).\\n *\\n * The digest is calculated by prefixing an arbitrary `data` with `\\\"\\\\x19\\\\x00\\\"` and the intended\\n * `validator` address. Then hashing the result.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(hex\\\"19_00\\\", validator, data));\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\\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 * See {ECDSA-recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\\n assembly (\\\"memory-safe\\\") {\\n let ptr := mload(0x40)\\n mstore(ptr, hex\\\"19_01\\\")\\n mstore(add(ptr, 0x02), domainSeparator)\\n mstore(add(ptr, 0x22), structHash)\\n digest := keccak256(ptr, 0x42)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4515543bc4c78561f6bea83ecfdfc3dead55bd59858287d682045b11de1ae575\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/cryptography/SignatureChecker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/SignatureChecker.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {ECDSA} from \\\"./ECDSA.sol\\\";\\nimport {IERC1271} from \\\"../../interfaces/IERC1271.sol\\\";\\n\\n/**\\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\\n * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like\\n * Argent and Safe Wallet (previously Gnosis Safe).\\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 ERC-1271, otherwise it's validated using `ECDSA.recover`.\\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 isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\\n if (signer.code.length == 0) {\\n (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\\n return err == ECDSA.RecoverError.NoError && recovered == signer;\\n } else {\\n return isValidERC1271SignatureNow(signer, hash, signature);\\n }\\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 ERC-1271.\\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 hash,\\n bytes memory signature\\n ) internal view returns (bool) {\\n (bool success, bytes memory result) = signer.staticcall(\\n abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\\n );\\n return (success &&\\n result.length >= 32 &&\\n abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\\n }\\n}\\n\",\"keccak256\":\"0xbdc3bb48ccedb818cd75a6d74a16df55a822e9f6d3cc54c59f576f10aab67b5f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xddce8e17e3d3f9ed818b4f4c4478a8262aab8b11ed322f1bf5ed705bb4bd97fa\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Floor, // Toward negative infinity\\n Ceil, // Toward positive infinity\\n Trunc, // Toward zero\\n Expand // Away from zero\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n *\\n * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n * one branch when needed, making this function more expensive.\\n */\\n function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n unchecked {\\n // branchless ternary works because:\\n // b ^ (a ^ b) == a\\n // b ^ 0 == b\\n return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n }\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ternary(a > b, a, b);\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return ternary(a < b, a, b);\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds towards infinity instead\\n * of rounding towards zero.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n if (b == 0) {\\n // Guarantee the same behavior as in a regular Solidity division.\\n Panic.panic(Panic.DIVISION_BY_ZERO);\\n }\\n\\n // The following calculation ensures accurate ceiling division without overflow.\\n // Since a is non-zero, (a - 1) / b will not overflow.\\n // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n // but the largest value we can obtain is type(uint256).max - 1, which happens\\n // when a = type(uint256).max and b = 1.\\n unchecked {\\n return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n }\\n }\\n\\n /**\\n * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n * denominator == 0.\\n *\\n * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n * Uniswap Labs also under MIT license.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2\\u00b2\\u2075\\u2076 + prod0.\\n uint256 prod0 = x * y; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n // The surrounding unchecked block does not change this fact.\\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n if (denominator <= prod1) {\\n Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n }\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n uint256 twos = denominator & (0 - denominator);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n // works in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n }\\n\\n /**\\n * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n *\\n * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n *\\n * If the input value is not inversible, 0 is returned.\\n *\\n * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n */\\n function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n unchecked {\\n if (n == 0) return 0;\\n\\n // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n // ax + ny = 1\\n // ax = 1 + (-y)n\\n // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n // If the remainder is 0 the gcd is n right away.\\n uint256 remainder = a % n;\\n uint256 gcd = n;\\n\\n // Therefore the initial coefficients are:\\n // ax + ny = gcd(a, n) = n\\n // 0a + 1n = n\\n int256 x = 0;\\n int256 y = 1;\\n\\n while (remainder != 0) {\\n uint256 quotient = gcd / remainder;\\n\\n (gcd, remainder) = (\\n // The old remainder is the next gcd to try.\\n remainder,\\n // Compute the next remainder.\\n // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n // where gcd is at most n (capped to type(uint256).max)\\n gcd - remainder * quotient\\n );\\n\\n (x, y) = (\\n // Increment the coefficient of a.\\n y,\\n // Decrement the coefficient of n.\\n // Can overflow, but the result is casted to uint256 so that the\\n // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n x - y * int256(quotient)\\n );\\n }\\n\\n if (gcd != 1) return 0; // No inverse exists.\\n return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n }\\n }\\n\\n /**\\n * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n *\\n * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n *\\n * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n */\\n function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n unchecked {\\n return Math.modExp(a, p - 2, p);\\n }\\n }\\n\\n /**\\n * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n *\\n * Requirements:\\n * - modulus can't be zero\\n * - underlying staticcall to precompile must succeed\\n *\\n * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n * interpreted as 0.\\n */\\n function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n (bool success, uint256 result) = tryModExp(b, e, m);\\n if (!success) {\\n Panic.panic(Panic.DIVISION_BY_ZERO);\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n * to operate modulo 0 or if the underlying precompile reverted.\\n *\\n * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n * of a revert, but the result may be incorrectly interpreted as 0.\\n */\\n function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n if (m == 0) return (false, 0);\\n assembly (\\\"memory-safe\\\") {\\n let ptr := mload(0x40)\\n // | Offset | Content | Content (Hex) |\\n // |-----------|------------|--------------------------------------------------------------------|\\n // | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n // | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n // | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n mstore(ptr, 0x20)\\n mstore(add(ptr, 0x20), 0x20)\\n mstore(add(ptr, 0x40), 0x20)\\n mstore(add(ptr, 0x60), b)\\n mstore(add(ptr, 0x80), e)\\n mstore(add(ptr, 0xa0), m)\\n\\n // Given the result < m, it's guaranteed to fit in 32 bytes,\\n // so we can use the memory scratch space located at offset 0.\\n success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n result := mload(0x00)\\n }\\n }\\n\\n /**\\n * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n */\\n function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n (bool success, bytes memory result) = tryModExp(b, e, m);\\n if (!success) {\\n Panic.panic(Panic.DIVISION_BY_ZERO);\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n */\\n function tryModExp(\\n bytes memory b,\\n bytes memory e,\\n bytes memory m\\n ) internal view returns (bool success, bytes memory result) {\\n if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n uint256 mLen = m.length;\\n\\n // Encode call args in result and move the free memory pointer\\n result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n assembly (\\\"memory-safe\\\") {\\n let dataPtr := add(result, 0x20)\\n // Write result on top of args to avoid allocating extra memory.\\n success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n // Overwrite the length.\\n // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n mstore(result, mLen)\\n // Set the memory pointer after the returned data.\\n mstore(0x40, add(dataPtr, mLen))\\n }\\n }\\n\\n /**\\n * @dev Returns whether the provided byte array is zero.\\n */\\n function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n for (uint256 i = 0; i < byteArray.length; ++i) {\\n if (byteArray[i] != 0) {\\n return false;\\n }\\n }\\n return true;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n * towards zero.\\n *\\n * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n * using integer operations.\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n unchecked {\\n // Take care of easy edge cases when a == 0 or a == 1\\n if (a <= 1) {\\n return a;\\n }\\n\\n // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n //\\n // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n // bigger than any uint256.\\n //\\n // By noticing that\\n // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n // to the msb function.\\n uint256 aa = a;\\n uint256 xn = 1;\\n\\n if (aa >= (1 << 128)) {\\n aa >>= 128;\\n xn <<= 64;\\n }\\n if (aa >= (1 << 64)) {\\n aa >>= 64;\\n xn <<= 32;\\n }\\n if (aa >= (1 << 32)) {\\n aa >>= 32;\\n xn <<= 16;\\n }\\n if (aa >= (1 << 16)) {\\n aa >>= 16;\\n xn <<= 8;\\n }\\n if (aa >= (1 << 8)) {\\n aa >>= 8;\\n xn <<= 4;\\n }\\n if (aa >= (1 << 4)) {\\n aa >>= 4;\\n xn <<= 2;\\n }\\n if (aa >= (1 << 2)) {\\n xn <<= 1;\\n }\\n\\n // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n //\\n // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n // This is going to be our x_0 (and \\u03b5_0)\\n xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n // From here, Newton's method give us:\\n // x_{n+1} = (x_n + a / x_n) / 2\\n //\\n // One should note that:\\n // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n // = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n // = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n // = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n // = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n // = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n // = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n // \\u2265 0\\n // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n //\\n // This gives us the proof of quadratic convergence of the sequence:\\n // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n // = | (x_n + a / x_n) / 2 - sqrt(a) |\\n // = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n // = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n // = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n // = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n //\\n // For the first iteration, we have a special case where x_0 is known:\\n // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n // \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n // \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n // \\u2264 2**(e-3) / 3\\n // \\u2264 2**(e-3-log2(3))\\n // \\u2264 2**(e-4.5)\\n //\\n // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n // \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n // \\u2264 2**(2*e-2*k) / 2**e\\n // \\u2264 2**(e-2*k)\\n xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5) -- special case, see above\\n xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9) -- general case with k = 4.5\\n xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18) -- general case with k = 9\\n xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36) -- general case with k = 18\\n xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72) -- general case with k = 36\\n xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144) -- general case with k = 72\\n\\n // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n // sqrt(a) or sqrt(a) + 1.\\n return xn - SafeCast.toUint(xn > a / xn);\\n }\\n }\\n\\n /**\\n * @dev Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n uint256 exp;\\n unchecked {\\n exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\\n value >>= exp;\\n result += exp;\\n\\n exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\\n value >>= exp;\\n result += exp;\\n\\n result += SafeCast.toUint(value > 1);\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10 ** 64) {\\n value /= 10 ** 64;\\n result += 64;\\n }\\n if (value >= 10 ** 32) {\\n value /= 10 ** 32;\\n result += 32;\\n }\\n if (value >= 10 ** 16) {\\n value /= 10 ** 16;\\n result += 16;\\n }\\n if (value >= 10 ** 8) {\\n value /= 10 ** 8;\\n result += 8;\\n }\\n if (value >= 10 ** 4) {\\n value /= 10 ** 4;\\n result += 4;\\n }\\n if (value >= 10 ** 2) {\\n value /= 10 ** 2;\\n result += 2;\\n }\\n if (value >= 10 ** 1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n uint256 isGt;\\n unchecked {\\n isGt = SafeCast.toUint(value > (1 << 128) - 1);\\n value >>= isGt * 128;\\n result += isGt * 16;\\n\\n isGt = SafeCast.toUint(value > (1 << 64) - 1);\\n value >>= isGt * 64;\\n result += isGt * 8;\\n\\n isGt = SafeCast.toUint(value > (1 << 32) - 1);\\n value >>= isGt * 32;\\n result += isGt * 4;\\n\\n isGt = SafeCast.toUint(value > (1 << 16) - 1);\\n value >>= isGt * 16;\\n result += isGt * 2;\\n\\n result += SafeCast.toUint(value > (1 << 8) - 1);\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n }\\n }\\n\\n /**\\n * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n */\\n function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n return uint8(rounding) % 2 == 1;\\n }\\n}\\n\",\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Value doesn't fit in an uint of `bits` size.\\n */\\n error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n /**\\n * @dev An int value doesn't fit in an uint of `bits` size.\\n */\\n error SafeCastOverflowedIntToUint(int256 value);\\n\\n /**\\n * @dev Value doesn't fit in an int of `bits` size.\\n */\\n error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n /**\\n * @dev An uint value doesn't fit in an int of `bits` size.\\n */\\n error SafeCastOverflowedUintToInt(uint256 value);\\n\\n /**\\n * @dev Returns the downcasted uint248 from uint256, reverting on\\n * overflow (when the input is greater than largest uint248).\\n *\\n * Counterpart to Solidity's `uint248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n */\\n function toUint248(uint256 value) internal pure returns (uint248) {\\n if (value > type(uint248).max) {\\n revert SafeCastOverflowedUintDowncast(248, value);\\n }\\n return uint248(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint240 from uint256, reverting on\\n * overflow (when the input is greater than largest uint240).\\n *\\n * Counterpart to Solidity's `uint240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n */\\n function toUint240(uint256 value) internal pure returns (uint240) {\\n if (value > type(uint240).max) {\\n revert SafeCastOverflowedUintDowncast(240, value);\\n }\\n return uint240(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint232 from uint256, reverting on\\n * overflow (when the input is greater than largest uint232).\\n *\\n * Counterpart to Solidity's `uint232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n */\\n function toUint232(uint256 value) internal pure returns (uint232) {\\n if (value > type(uint232).max) {\\n revert SafeCastOverflowedUintDowncast(232, value);\\n }\\n return uint232(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint224 from uint256, reverting on\\n * overflow (when the input is greater than largest uint224).\\n *\\n * Counterpart to Solidity's `uint224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n */\\n function toUint224(uint256 value) internal pure returns (uint224) {\\n if (value > type(uint224).max) {\\n revert SafeCastOverflowedUintDowncast(224, value);\\n }\\n return uint224(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint216 from uint256, reverting on\\n * overflow (when the input is greater than largest uint216).\\n *\\n * Counterpart to Solidity's `uint216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n */\\n function toUint216(uint256 value) internal pure returns (uint216) {\\n if (value > type(uint216).max) {\\n revert SafeCastOverflowedUintDowncast(216, value);\\n }\\n return uint216(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint208 from uint256, reverting on\\n * overflow (when the input is greater than largest uint208).\\n *\\n * Counterpart to Solidity's `uint208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n */\\n function toUint208(uint256 value) internal pure returns (uint208) {\\n if (value > type(uint208).max) {\\n revert SafeCastOverflowedUintDowncast(208, value);\\n }\\n return uint208(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint200 from uint256, reverting on\\n * overflow (when the input is greater than largest uint200).\\n *\\n * Counterpart to Solidity's `uint200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n */\\n function toUint200(uint256 value) internal pure returns (uint200) {\\n if (value > type(uint200).max) {\\n revert SafeCastOverflowedUintDowncast(200, value);\\n }\\n return uint200(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint192 from uint256, reverting on\\n * overflow (when the input is greater than largest uint192).\\n *\\n * Counterpart to Solidity's `uint192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n */\\n function toUint192(uint256 value) internal pure returns (uint192) {\\n if (value > type(uint192).max) {\\n revert SafeCastOverflowedUintDowncast(192, value);\\n }\\n return uint192(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint184 from uint256, reverting on\\n * overflow (when the input is greater than largest uint184).\\n *\\n * Counterpart to Solidity's `uint184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n */\\n function toUint184(uint256 value) internal pure returns (uint184) {\\n if (value > type(uint184).max) {\\n revert SafeCastOverflowedUintDowncast(184, value);\\n }\\n return uint184(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint176 from uint256, reverting on\\n * overflow (when the input is greater than largest uint176).\\n *\\n * Counterpart to Solidity's `uint176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n */\\n function toUint176(uint256 value) internal pure returns (uint176) {\\n if (value > type(uint176).max) {\\n revert SafeCastOverflowedUintDowncast(176, value);\\n }\\n return uint176(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint168 from uint256, reverting on\\n * overflow (when the input is greater than largest uint168).\\n *\\n * Counterpart to Solidity's `uint168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n */\\n function toUint168(uint256 value) internal pure returns (uint168) {\\n if (value > type(uint168).max) {\\n revert SafeCastOverflowedUintDowncast(168, value);\\n }\\n return uint168(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint160 from uint256, reverting on\\n * overflow (when the input is greater than largest uint160).\\n *\\n * Counterpart to Solidity's `uint160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n */\\n function toUint160(uint256 value) internal pure returns (uint160) {\\n if (value > type(uint160).max) {\\n revert SafeCastOverflowedUintDowncast(160, value);\\n }\\n return uint160(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint152 from uint256, reverting on\\n * overflow (when the input is greater than largest uint152).\\n *\\n * Counterpart to Solidity's `uint152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n */\\n function toUint152(uint256 value) internal pure returns (uint152) {\\n if (value > type(uint152).max) {\\n revert SafeCastOverflowedUintDowncast(152, value);\\n }\\n return uint152(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint144 from uint256, reverting on\\n * overflow (when the input is greater than largest uint144).\\n *\\n * Counterpart to Solidity's `uint144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n */\\n function toUint144(uint256 value) internal pure returns (uint144) {\\n if (value > type(uint144).max) {\\n revert SafeCastOverflowedUintDowncast(144, value);\\n }\\n return uint144(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint136 from uint256, reverting on\\n * overflow (when the input is greater than largest uint136).\\n *\\n * Counterpart to Solidity's `uint136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n */\\n function toUint136(uint256 value) internal pure returns (uint136) {\\n if (value > type(uint136).max) {\\n revert SafeCastOverflowedUintDowncast(136, value);\\n }\\n return uint136(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n if (value > type(uint128).max) {\\n revert SafeCastOverflowedUintDowncast(128, value);\\n }\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint120 from uint256, reverting on\\n * overflow (when the input is greater than largest uint120).\\n *\\n * Counterpart to Solidity's `uint120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n */\\n function toUint120(uint256 value) internal pure returns (uint120) {\\n if (value > type(uint120).max) {\\n revert SafeCastOverflowedUintDowncast(120, value);\\n }\\n return uint120(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint112 from uint256, reverting on\\n * overflow (when the input is greater than largest uint112).\\n *\\n * Counterpart to Solidity's `uint112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n */\\n function toUint112(uint256 value) internal pure returns (uint112) {\\n if (value > type(uint112).max) {\\n revert SafeCastOverflowedUintDowncast(112, value);\\n }\\n return uint112(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint104 from uint256, reverting on\\n * overflow (when the input is greater than largest uint104).\\n *\\n * Counterpart to Solidity's `uint104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n */\\n function toUint104(uint256 value) internal pure returns (uint104) {\\n if (value > type(uint104).max) {\\n revert SafeCastOverflowedUintDowncast(104, value);\\n }\\n return uint104(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint96 from uint256, reverting on\\n * overflow (when the input is greater than largest uint96).\\n *\\n * Counterpart to Solidity's `uint96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n */\\n function toUint96(uint256 value) internal pure returns (uint96) {\\n if (value > type(uint96).max) {\\n revert SafeCastOverflowedUintDowncast(96, value);\\n }\\n return uint96(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint88 from uint256, reverting on\\n * overflow (when the input is greater than largest uint88).\\n *\\n * Counterpart to Solidity's `uint88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n */\\n function toUint88(uint256 value) internal pure returns (uint88) {\\n if (value > type(uint88).max) {\\n revert SafeCastOverflowedUintDowncast(88, value);\\n }\\n return uint88(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint80 from uint256, reverting on\\n * overflow (when the input is greater than largest uint80).\\n *\\n * Counterpart to Solidity's `uint80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n */\\n function toUint80(uint256 value) internal pure returns (uint80) {\\n if (value > type(uint80).max) {\\n revert SafeCastOverflowedUintDowncast(80, value);\\n }\\n return uint80(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint72 from uint256, reverting on\\n * overflow (when the input is greater than largest uint72).\\n *\\n * Counterpart to Solidity's `uint72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n */\\n function toUint72(uint256 value) internal pure returns (uint72) {\\n if (value > type(uint72).max) {\\n revert SafeCastOverflowedUintDowncast(72, value);\\n }\\n return uint72(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n if (value > type(uint64).max) {\\n revert SafeCastOverflowedUintDowncast(64, value);\\n }\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint56 from uint256, reverting on\\n * overflow (when the input is greater than largest uint56).\\n *\\n * Counterpart to Solidity's `uint56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n */\\n function toUint56(uint256 value) internal pure returns (uint56) {\\n if (value > type(uint56).max) {\\n revert SafeCastOverflowedUintDowncast(56, value);\\n }\\n return uint56(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint48 from uint256, reverting on\\n * overflow (when the input is greater than largest uint48).\\n *\\n * Counterpart to Solidity's `uint48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n */\\n function toUint48(uint256 value) internal pure returns (uint48) {\\n if (value > type(uint48).max) {\\n revert SafeCastOverflowedUintDowncast(48, value);\\n }\\n return uint48(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint40 from uint256, reverting on\\n * overflow (when the input is greater than largest uint40).\\n *\\n * Counterpart to Solidity's `uint40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n */\\n function toUint40(uint256 value) internal pure returns (uint40) {\\n if (value > type(uint40).max) {\\n revert SafeCastOverflowedUintDowncast(40, value);\\n }\\n return uint40(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n if (value > type(uint32).max) {\\n revert SafeCastOverflowedUintDowncast(32, value);\\n }\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint24 from uint256, reverting on\\n * overflow (when the input is greater than largest uint24).\\n *\\n * Counterpart to Solidity's `uint24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n */\\n function toUint24(uint256 value) internal pure returns (uint24) {\\n if (value > type(uint24).max) {\\n revert SafeCastOverflowedUintDowncast(24, value);\\n }\\n return uint24(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n if (value > type(uint16).max) {\\n revert SafeCastOverflowedUintDowncast(16, value);\\n }\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n if (value > type(uint8).max) {\\n revert SafeCastOverflowedUintDowncast(8, value);\\n }\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n if (value < 0) {\\n revert SafeCastOverflowedIntToUint(value);\\n }\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int248 from int256, reverting on\\n * overflow (when the input is less than smallest int248 or\\n * greater than largest int248).\\n *\\n * Counterpart to Solidity's `int248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n */\\n function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n downcasted = int248(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(248, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int240 from int256, reverting on\\n * overflow (when the input is less than smallest int240 or\\n * greater than largest int240).\\n *\\n * Counterpart to Solidity's `int240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n */\\n function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n downcasted = int240(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(240, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int232 from int256, reverting on\\n * overflow (when the input is less than smallest int232 or\\n * greater than largest int232).\\n *\\n * Counterpart to Solidity's `int232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n */\\n function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n downcasted = int232(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(232, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int224 from int256, reverting on\\n * overflow (when the input is less than smallest int224 or\\n * greater than largest int224).\\n *\\n * Counterpart to Solidity's `int224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n */\\n function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n downcasted = int224(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(224, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int216 from int256, reverting on\\n * overflow (when the input is less than smallest int216 or\\n * greater than largest int216).\\n *\\n * Counterpart to Solidity's `int216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n */\\n function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n downcasted = int216(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(216, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int208 from int256, reverting on\\n * overflow (when the input is less than smallest int208 or\\n * greater than largest int208).\\n *\\n * Counterpart to Solidity's `int208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n */\\n function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n downcasted = int208(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(208, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int200 from int256, reverting on\\n * overflow (when the input is less than smallest int200 or\\n * greater than largest int200).\\n *\\n * Counterpart to Solidity's `int200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n */\\n function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n downcasted = int200(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(200, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int192 from int256, reverting on\\n * overflow (when the input is less than smallest int192 or\\n * greater than largest int192).\\n *\\n * Counterpart to Solidity's `int192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n */\\n function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n downcasted = int192(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(192, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int184 from int256, reverting on\\n * overflow (when the input is less than smallest int184 or\\n * greater than largest int184).\\n *\\n * Counterpart to Solidity's `int184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n */\\n function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n downcasted = int184(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(184, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int176 from int256, reverting on\\n * overflow (when the input is less than smallest int176 or\\n * greater than largest int176).\\n *\\n * Counterpart to Solidity's `int176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n */\\n function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n downcasted = int176(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(176, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int168 from int256, reverting on\\n * overflow (when the input is less than smallest int168 or\\n * greater than largest int168).\\n *\\n * Counterpart to Solidity's `int168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n */\\n function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n downcasted = int168(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(168, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int160 from int256, reverting on\\n * overflow (when the input is less than smallest int160 or\\n * greater than largest int160).\\n *\\n * Counterpart to Solidity's `int160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n */\\n function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n downcasted = int160(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(160, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int152 from int256, reverting on\\n * overflow (when the input is less than smallest int152 or\\n * greater than largest int152).\\n *\\n * Counterpart to Solidity's `int152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n */\\n function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n downcasted = int152(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(152, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int144 from int256, reverting on\\n * overflow (when the input is less than smallest int144 or\\n * greater than largest int144).\\n *\\n * Counterpart to Solidity's `int144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n */\\n function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n downcasted = int144(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(144, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int136 from int256, reverting on\\n * overflow (when the input is less than smallest int136 or\\n * greater than largest int136).\\n *\\n * Counterpart to Solidity's `int136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n */\\n function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n downcasted = int136(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(136, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n downcasted = int128(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(128, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int120 from int256, reverting on\\n * overflow (when the input is less than smallest int120 or\\n * greater than largest int120).\\n *\\n * Counterpart to Solidity's `int120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n */\\n function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n downcasted = int120(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(120, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int112 from int256, reverting on\\n * overflow (when the input is less than smallest int112 or\\n * greater than largest int112).\\n *\\n * Counterpart to Solidity's `int112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n */\\n function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n downcasted = int112(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(112, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int104 from int256, reverting on\\n * overflow (when the input is less than smallest int104 or\\n * greater than largest int104).\\n *\\n * Counterpart to Solidity's `int104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n */\\n function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n downcasted = int104(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(104, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int96 from int256, reverting on\\n * overflow (when the input is less than smallest int96 or\\n * greater than largest int96).\\n *\\n * Counterpart to Solidity's `int96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n */\\n function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n downcasted = int96(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(96, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int88 from int256, reverting on\\n * overflow (when the input is less than smallest int88 or\\n * greater than largest int88).\\n *\\n * Counterpart to Solidity's `int88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n */\\n function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n downcasted = int88(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(88, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int80 from int256, reverting on\\n * overflow (when the input is less than smallest int80 or\\n * greater than largest int80).\\n *\\n * Counterpart to Solidity's `int80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n */\\n function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n downcasted = int80(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(80, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int72 from int256, reverting on\\n * overflow (when the input is less than smallest int72 or\\n * greater than largest int72).\\n *\\n * Counterpart to Solidity's `int72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n */\\n function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n downcasted = int72(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(72, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n downcasted = int64(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(64, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int56 from int256, reverting on\\n * overflow (when the input is less than smallest int56 or\\n * greater than largest int56).\\n *\\n * Counterpart to Solidity's `int56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n */\\n function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n downcasted = int56(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(56, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int48 from int256, reverting on\\n * overflow (when the input is less than smallest int48 or\\n * greater than largest int48).\\n *\\n * Counterpart to Solidity's `int48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n */\\n function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n downcasted = int48(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(48, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int40 from int256, reverting on\\n * overflow (when the input is less than smallest int40 or\\n * greater than largest int40).\\n *\\n * Counterpart to Solidity's `int40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n */\\n function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n downcasted = int40(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(40, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n downcasted = int32(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(32, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int24 from int256, reverting on\\n * overflow (when the input is less than smallest int24 or\\n * greater than largest int24).\\n *\\n * Counterpart to Solidity's `int24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n */\\n function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n downcasted = int24(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(24, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n downcasted = int16(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(16, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n */\\n function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n downcasted = int8(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(8, value);\\n }\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n if (value > uint256(type(int256).max)) {\\n revert SafeCastOverflowedUintToInt(value);\\n }\\n return int256(value);\\n }\\n\\n /**\\n * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n */\\n function toUint(bool b) internal pure returns (uint256 u) {\\n assembly (\\\"memory-safe\\\") {\\n u := iszero(iszero(b))\\n }\\n }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"@openzeppelin/contracts-v5/utils/math/SignedMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMath {\\n /**\\n * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n *\\n * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n * one branch when needed, making this function more expensive.\\n */\\n function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\\n unchecked {\\n // branchless ternary works because:\\n // b ^ (a ^ b) == a\\n // b ^ 0 == b\\n return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\\n }\\n }\\n\\n /**\\n * @dev Returns the largest of two signed numbers.\\n */\\n function max(int256 a, int256 b) internal pure returns (int256) {\\n return ternary(a > b, a, b);\\n }\\n\\n /**\\n * @dev Returns the smallest of two signed numbers.\\n */\\n function min(int256 a, int256 b) internal pure returns (int256) {\\n return ternary(a < b, a, b);\\n }\\n\\n /**\\n * @dev Returns the average of two signed numbers without overflow.\\n * The result is rounded towards zero.\\n */\\n function average(int256 a, int256 b) internal pure returns (int256) {\\n // Formula from the book \\\"Hacker's Delight\\\"\\n int256 x = (a & b) + ((a ^ b) >> 1);\\n return x + (int256(uint256(x) >> 255) & (a ^ b));\\n }\\n\\n /**\\n * @dev Returns the absolute unsigned value of a signed value.\\n */\\n function abs(int256 n) internal pure returns (uint256) {\\n unchecked {\\n // Formula from the \\\"Bit Twiddling Hacks\\\" by Sean Eron Anderson.\\n // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\\n // taking advantage of the most significant (or \\\"sign\\\" bit) in two's complement representation.\\n // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\\n // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\\n int256 mask = n >> 255;\\n\\n // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\\n return uint256((n + mask) ^ mask);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/IL2ReverseRegistrar.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\n/// @notice Interface for the L2 Reverse Registrar.\\ninterface IL2ReverseRegistrar {\\n /// @notice Sets the `nameForAddr()` record for the calling account.\\n ///\\n /// @param name The name to set.\\n function setName(string memory name) external;\\n\\n /// @notice Sets the `nameForAddr()` record for the addr provided account.\\n ///\\n /// @param addr The address to set the name for.\\n /// @param name The name to set.\\n function setNameForAddr(address addr, string memory name) external;\\n\\n /// @notice Sets the `nameForAddr()` record for the addr provided account using a signature.\\n ///\\n /// @param addr The address to set the name for.\\n /// @param name The name to set.\\n /// @param coinTypes The coin types to set. Must be inclusive of the coin type for the contract.\\n /// @param signatureExpiry Date when the signature expires.\\n /// @param signature The signature from the addr.\\n function setNameForAddrWithSignature(\\n address addr,\\n uint256 signatureExpiry,\\n string memory name,\\n uint256[] memory coinTypes,\\n bytes memory signature\\n ) external;\\n\\n /// @notice Sets the `nameForAddr()` record for the contract provided that is owned with `Ownable`.\\n ///\\n /// @param contractAddr The address of the contract to set the name for (implementing Ownable).\\n /// @param owner The owner of the contract (via Ownable).\\n /// @param signatureExpiry The expiry of the signature.\\n /// @param name The name to set.\\n /// @param coinTypes The coin types to set. Must be inclusive of the coin type for the contract.\\n /// @param signature The signature of an address that will return true on isValidSignature for the owner.\\n function setNameForOwnableWithSignature(\\n address contractAddr,\\n address owner,\\n uint256 signatureExpiry,\\n string memory name,\\n uint256[] memory coinTypes,\\n bytes memory signature\\n ) external;\\n}\\n\",\"keccak256\":\"0xad8b311bff30679e59afb53e4adcd2976ed822ec9123a7639b1001d62faca59e\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/IStandaloneReverseRegistrar.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\n/// @notice Interface for a standalone reverse registrar.\\ninterface IStandaloneReverseRegistrar {\\n /// @notice Emitted when the name for an address is changed.\\n ///\\n /// @param addr The address of the reverse record.\\n /// @param name The name of the reverse record.\\n event NameForAddrChanged(address indexed addr, string name);\\n\\n /// @notice Returns the name for an address.\\n ///\\n /// @param addr The address to get the name for.\\n /// @return The name for the address.\\n function nameForAddr(address addr) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x693ab3a5dcd95a80a2a4a2418ce48092d20d11da1e39d17c87ab3f1641ceaf6e\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/L2ReverseRegistrar.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport {Ownable} from \\\"@openzeppelin/contracts-v5/access/Ownable.sol\\\";\\nimport {MessageHashUtils} from \\\"@openzeppelin/contracts-v5/utils/cryptography/MessageHashUtils.sol\\\";\\nimport {ERC165} from \\\"@openzeppelin/contracts-v5/utils/introspection/ERC165.sol\\\";\\n\\nimport {IL2ReverseRegistrar} from \\\"./IL2ReverseRegistrar.sol\\\";\\nimport {StandaloneReverseRegistrar} from \\\"./StandaloneReverseRegistrar.sol\\\";\\nimport {SignatureUtils} from \\\"./SignatureUtils.sol\\\";\\n\\n/// @title L2 Reverse Registrar\\n/// @notice An L2 Reverse Registrar. Deployed to each L2 chain.\\ncontract L2ReverseRegistrar is\\n IL2ReverseRegistrar,\\n ERC165,\\n StandaloneReverseRegistrar\\n{\\n using SignatureUtils for bytes;\\n using MessageHashUtils for bytes32;\\n\\n /// @notice The coin type for the chain this contract is deployed to.\\n uint256 public immutable coinType;\\n\\n /// @notice Thrown when the specified address is not the owner of the contract\\n error NotOwnerOfContract();\\n\\n /// @notice Thrown when the coin type is not found in the provided array\\n error CoinTypeNotFound();\\n\\n /// @notice The caller is not authorised to perform the action\\n error Unauthorised();\\n\\n /// @notice Checks if the caller is authorised\\n ///\\n /// @param addr The address to check.\\n modifier authorised(address addr) {\\n if (addr != msg.sender && !_ownsContract(addr, msg.sender)) {\\n revert Unauthorised();\\n }\\n _;\\n }\\n\\n /// @notice Ensures the coin type of the contract is included in the provided array\\n ///\\n /// @param coinTypes The coin types to check.\\n modifier validCoinTypes(uint256[] calldata coinTypes) {\\n _validateCoinTypes(coinTypes);\\n _;\\n }\\n\\n /// @notice Initialises the contract by setting the coin type.\\n ///\\n /// @param coinType_ The cointype converted from the chainId of the chain this contract is deployed to.\\n constructor(uint256 coinType_) {\\n coinType = coinType_;\\n }\\n\\n /// @inheritdoc IL2ReverseRegistrar\\n function setName(string calldata name) external authorised(msg.sender) {\\n _setName(msg.sender, name);\\n }\\n\\n /// @inheritdoc IL2ReverseRegistrar\\n function setNameForAddr(\\n address addr,\\n string calldata name\\n ) external authorised(addr) {\\n _setName(addr, name);\\n }\\n\\n /// @inheritdoc IL2ReverseRegistrar\\n function setNameForAddrWithSignature(\\n address addr,\\n uint256 signatureExpiry,\\n string calldata name,\\n uint256[] calldata coinTypes,\\n bytes calldata signature\\n ) external validCoinTypes(coinTypes) {\\n // Follow ERC191 version 0 https://eips.ethereum.org/EIPS/eip-191\\n bytes32 message = keccak256(\\n abi.encodePacked(\\n address(this),\\n this.setNameForAddrWithSignature.selector,\\n addr,\\n signatureExpiry,\\n name,\\n coinTypes\\n )\\n ).toEthSignedMessageHash();\\n\\n signature.validateSignatureWithExpiry(addr, message, signatureExpiry);\\n\\n _setName(addr, name);\\n }\\n\\n /// @inheritdoc IL2ReverseRegistrar\\n function setNameForOwnableWithSignature(\\n address contractAddr,\\n address owner,\\n uint256 signatureExpiry,\\n string calldata name,\\n uint256[] calldata coinTypes,\\n bytes calldata signature\\n ) external validCoinTypes(coinTypes) {\\n // Follow ERC191 version 0 https://eips.ethereum.org/EIPS/eip-191\\n bytes32 message = keccak256(\\n abi.encodePacked(\\n address(this),\\n this.setNameForOwnableWithSignature.selector,\\n contractAddr,\\n owner,\\n signatureExpiry,\\n name,\\n coinTypes\\n )\\n ).toEthSignedMessageHash();\\n\\n if (!_ownsContract(contractAddr, owner)) revert NotOwnerOfContract();\\n\\n signature.validateSignatureWithExpiry(owner, message, signatureExpiry);\\n\\n _setName(contractAddr, name);\\n }\\n\\n /// @notice Checks if the provided contractAddr is a contract and is owned by the\\n /// provided addr.\\n ///\\n /// @param contractAddr The address of the contract to check.\\n /// @param addr The address to check ownership against.\\n function _ownsContract(\\n address contractAddr,\\n address addr\\n ) internal view returns (bool) {\\n if (contractAddr.code.length == 0) return false;\\n try Ownable(contractAddr).owner() returns (address owner) {\\n return owner == addr;\\n } catch {\\n return false;\\n }\\n }\\n\\n /// @notice Ensures the coin type for the contract is included in the provided array.\\n ///\\n /// @param coinTypes The coin types to check.\\n function _validateCoinTypes(uint256[] calldata coinTypes) internal view {\\n for (uint256 i = 0; i < coinTypes.length; i++) {\\n if (coinTypes[i] == coinType) return;\\n }\\n\\n revert CoinTypeNotFound();\\n }\\n\\n /// @inheritdoc ERC165\\n function supportsInterface(\\n bytes4 interfaceID\\n ) public view override(ERC165, StandaloneReverseRegistrar) returns (bool) {\\n return\\n interfaceID == type(IL2ReverseRegistrar).interfaceId ||\\n super.supportsInterface(interfaceID);\\n }\\n}\\n\",\"keccak256\":\"0x416a042fb505ddc6bfd655c17d7f9b76366ed674524fabfbaa898d80814319ea\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/SignatureUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\nimport {SignatureChecker} from \\\"@openzeppelin/contracts-v5/utils/cryptography/SignatureChecker.sol\\\";\\n\\ninterface IUniversalSignatureValidator {\\n function isValidSig(\\n address _signer,\\n bytes32 _hash,\\n bytes calldata _signature\\n ) external returns (bool);\\n}\\n\\n/// @notice Utility functions for validating signatures with expiry.\\nlibrary SignatureUtils {\\n /// @notice The ERC6492 detection suffix.\\n bytes32 private constant ERC6492_DETECTION_SUFFIX =\\n 0x6492649264926492649264926492649264926492649264926492649264926492;\\n\\n /// @notice The universal signature validator.\\n IUniversalSignatureValidator public constant validator =\\n IUniversalSignatureValidator(\\n 0x164af34fAF9879394370C7f09064127C043A35E9\\n );\\n\\n /// @notice The signature is invalid\\n error InvalidSignature();\\n\\n /// @notice The signature expiry is too high\\n error SignatureExpiryTooHigh();\\n\\n /// @notice The signature has expired\\n error SignatureExpired();\\n\\n /// @notice Validates a signature with expiry.\\n ///\\n /// @param signature The signature to validate.\\n /// @param addr The address that signed the message.\\n /// @param message The message that was signed.\\n /// @param signatureExpiry The expiry of the signature.\\n function validateSignatureWithExpiry(\\n bytes calldata signature,\\n address addr,\\n bytes32 message,\\n uint256 signatureExpiry\\n ) internal {\\n // ERC6492 check is done internally because UniversalSigValidator is not gas efficient.\\n // We only want to use UniversalSigValidator for ERC6492 signatures.\\n if (\\n bytes32(signature[signature.length - 32:signature.length]) ==\\n ERC6492_DETECTION_SUFFIX\\n ) {\\n if (!validator.isValidSig(addr, message, signature))\\n revert InvalidSignature();\\n } else {\\n if (!SignatureChecker.isValidSignatureNow(addr, message, signature))\\n revert InvalidSignature();\\n }\\n if (signatureExpiry < block.timestamp) revert SignatureExpired();\\n if (signatureExpiry > block.timestamp + 1 hours)\\n revert SignatureExpiryTooHigh();\\n }\\n}\\n\",\"keccak256\":\"0x766fc84bb6680eae3669dfba6db8c1ee5e54be114c7859e4991166b376684607\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/StandaloneReverseRegistrar.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.4;\\n\\nimport {ERC165} from \\\"@openzeppelin/contracts-v5/utils/introspection/ERC165.sol\\\";\\n\\nimport {IStandaloneReverseRegistrar} from \\\"./IStandaloneReverseRegistrar.sol\\\";\\n\\n/// @title Standalone Reverse Registrar\\n/// @notice A standalone reverse registrar, detached from the ENS registry.\\ncontract StandaloneReverseRegistrar is ERC165, IStandaloneReverseRegistrar {\\n /// @notice The mapping of addresses to names.\\n mapping(address => string) internal _names;\\n\\n /// @inheritdoc IStandaloneReverseRegistrar\\n function nameForAddr(\\n address addr\\n ) external view returns (string memory name) {\\n name = _names[addr];\\n }\\n\\n /// @notice Sets the name for an address.\\n ///\\n /// @dev Authorisation should be checked before calling.\\n ///\\n /// @param addr The address to set the name for.\\n /// @param name The name to set.\\n function _setName(address addr, string calldata name) internal {\\n _names[addr] = name;\\n emit NameForAddrChanged(addr, name);\\n }\\n\\n /// @inheritdoc ERC165\\n function supportsInterface(\\n bytes4 interfaceID\\n ) public view virtual override(ERC165) returns (bool) {\\n return\\n interfaceID == type(IStandaloneReverseRegistrar).interfaceId ||\\n super.supportsInterface(interfaceID);\\n }\\n}\\n\",\"keccak256\":\"0x41e84493794957abf9f16484bcd230072b0f5fb73c33b8e09c8e6962932d9c36\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "events": { "NameForAddrChanged(address,string)": { "params": { "addr": "The address of the reverse record.", "name": "The name of the reverse record." } } }, "kind": "dev", "methods": { "constructor": { "params": { "coinType_": "The cointype converted from the chainId of the chain this contract is deployed to." } }, "nameForAddr(address)": { "params": { "addr": "The address to get the name for." }, "returns": { "name": "The name for the address." } }, "setName(string)": { "params": { "name": "The name to set." } }, "setNameForAddr(address,string)": { "params": { "addr": "The address to set the name for.", "name": "The name to set." } }, "setNameForAddrWithSignature(address,uint256,string,uint256[],bytes)": { "params": { "addr": "The address to set the name for.", "coinTypes": "The coin types to set. Must be inclusive of the coin type for the contract.", "name": "The name to set.", "signature": "The signature from the addr.", "signatureExpiry": "Date when the signature expires." } }, "setNameForOwnableWithSignature(address,address,uint256,string,uint256[],bytes)": { "params": { "coinTypes": "The coin types to set. Must be inclusive of the coin type for the contract.", "contractAddr": "The address of the contract to set the name for (implementing Ownable).", "name": "The name to set.", "owner": "The owner of the contract (via Ownable).", "signature": "The signature of an address that will return true on isValidSignature for the owner.", "signatureExpiry": "The expiry of the signature." } }, "supportsInterface(bytes4)": { "details": "See {IERC165-supportsInterface}." } }, "title": "L2 Reverse Registrar", "version": 1 }, "userdoc": { "errors": { "CoinTypeNotFound()": [ { "notice": "Thrown when the coin type is not found in the provided array" } ], "InvalidSignature()": [ { "notice": "The signature is invalid" } ], "NotOwnerOfContract()": [ { "notice": "Thrown when the specified address is not the owner of the contract" } ], "SignatureExpired()": [ { "notice": "The signature has expired" } ], "SignatureExpiryTooHigh()": [ { "notice": "The signature expiry is too high" } ], "Unauthorised()": [ { "notice": "The caller is not authorised to perform the action" } ] }, "events": { "NameForAddrChanged(address,string)": { "notice": "Emitted when the name for an address is changed." } }, "kind": "user", "methods": { "coinType()": { "notice": "The coin type for the chain this contract is deployed to." }, "constructor": { "notice": "Initialises the contract by setting the coin type." }, "nameForAddr(address)": { "notice": "Returns the name for an address." }, "setName(string)": { "notice": "Sets the `nameForAddr()` record for the calling account." }, "setNameForAddr(address,string)": { "notice": "Sets the `nameForAddr()` record for the addr provided account." }, "setNameForAddrWithSignature(address,uint256,string,uint256[],bytes)": { "notice": "Sets the `nameForAddr()` record for the addr provided account using a signature." }, "setNameForOwnableWithSignature(address,address,uint256,string,uint256[],bytes)": { "notice": "Sets the `nameForAddr()` record for the contract provided that is owned with `Ownable`." } }, "notice": "An L2 Reverse Registrar. Deployed to each L2 chain.", "version": 1 }, "storageLayout": { "storage": [ { "astId": 27516, "contract": "contracts/reverseRegistrar/L2ReverseRegistrar.sol:L2ReverseRegistrar", "label": "_names", "offset": 0, "slot": "0", "type": "t_mapping(t_address,t_string_storage)" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_mapping(t_address,t_string_storage)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => string)", "numberOfBytes": "32", "value": "t_string_storage" }, "t_string_storage": { "encoding": "bytes", "label": "string", "numberOfBytes": "32" } } } }