diff --git a/deployments/sepolia/.migrations.json b/deployments/sepolia/.migrations.json index c5d5a46d..d8520a51 100644 --- a/deployments/sepolia/.migrations.json +++ b/deployments/sepolia/.migrations.json @@ -3,5 +3,6 @@ "root": 1686901730, "setupRoot": 1686901813, "legacy-resolver": 1688028337, - "legacy-controller": 1688029384 + "legacy-controller": 1688029384, + "bulk-renewal": 1689657854 } \ No newline at end of file diff --git a/deployments/sepolia/StaticBulkRenewal.json b/deployments/sepolia/StaticBulkRenewal.json new file mode 100644 index 00000000..e88244e8 --- /dev/null +++ b/deployments/sepolia/StaticBulkRenewal.json @@ -0,0 +1,130 @@ +{ + "address": "0x4EF77b90762Eddb33C8Eba5B5a19558DaE53D7a1", + "abi": [ + { + "inputs": [ + { + "internalType": "contract ETHRegistrarController", + "name": "_controller", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "string[]", + "name": "names", + "type": "string[]" + }, + { + "internalType": "uint256", + "name": "duration", + "type": "uint256" + } + ], + "name": "renewAll", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string[]", + "name": "names", + "type": "string[]" + }, + { + "internalType": "uint256", + "name": "duration", + "type": "uint256" + } + ], + "name": "rentPrice", + "outputs": [ + { + "internalType": "uint256", + "name": "total", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceID", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + } + ], + "transactionHash": "0x25fed620ee97bb93ba94b97b4670eac8ebf4347c6a3a49809a968de63fded854", + "receipt": { + "to": null, + "from": "0x4Fe4e666Be5752f1FdD210F4Ab5DE2Cc26e3E0e8", + "contractAddress": "0x4EF77b90762Eddb33C8Eba5B5a19558DaE53D7a1", + "transactionIndex": 45, + "gasUsed": "396872", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x15ca0a028e68b6f72d21a463cc6e03304c007b46e42fe4fb8bc2e92fdc85165e", + "transactionHash": "0x25fed620ee97bb93ba94b97b4670eac8ebf4347c6a3a49809a968de63fded854", + "logs": [], + "blockNumber": 3914901, + "cumulativeGasUsed": "12909136", + "status": 1, + "byzantium": true + }, + "args": [ + "0xFED6a969AaA60E4961FCD3EBF1A2e8913ac65B72" + ], + "numDeployments": 1, + "solcInputHash": "e04502f562d98d0455f6c1c453418cdd", + "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract ETHRegistrarController\",\"name\":\"_controller\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"names\",\"type\":\"string[]\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"renewAll\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"names\",\"type\":\"string[]\"},{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"rentPrice\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"total\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/ethregistrar/StaticBulkRenewal.sol\":\"StaticBulkRenewal\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../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 * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\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 require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _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 require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\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\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC1155/IERC1155.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC1155 compliant contract, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-1155[EIP].\\n *\\n * _Available since v3.1._\\n */\\ninterface IERC1155 is IERC165 {\\n /**\\n * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.\\n */\\n event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);\\n\\n /**\\n * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all\\n * transfers.\\n */\\n event TransferBatch(\\n address indexed operator,\\n address indexed from,\\n address indexed to,\\n uint256[] ids,\\n uint256[] values\\n );\\n\\n /**\\n * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to\\n * `approved`.\\n */\\n event ApprovalForAll(address indexed account, address indexed operator, bool approved);\\n\\n /**\\n * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.\\n *\\n * If an {URI} event was emitted for `id`, the standard\\n * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value\\n * returned by {IERC1155MetadataURI-uri}.\\n */\\n event URI(string value, uint256 indexed id);\\n\\n /**\\n * @dev Returns the amount of tokens of token type `id` owned by `account`.\\n *\\n * Requirements:\\n *\\n * - `account` cannot be the zero address.\\n */\\n function balanceOf(address account, uint256 id) external view returns (uint256);\\n\\n /**\\n * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.\\n *\\n * Requirements:\\n *\\n * - `accounts` and `ids` must have the same length.\\n */\\n function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)\\n external\\n view\\n returns (uint256[] memory);\\n\\n /**\\n * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,\\n *\\n * Emits an {ApprovalForAll} event.\\n *\\n * Requirements:\\n *\\n * - `operator` cannot be the caller.\\n */\\n function setApprovalForAll(address operator, bool approved) external;\\n\\n /**\\n * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.\\n *\\n * See {setApprovalForAll}.\\n */\\n function isApprovedForAll(address account, address operator) external view returns (bool);\\n\\n /**\\n * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.\\n *\\n * Emits a {TransferSingle} event.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.\\n * - `from` must have a balance of tokens of type `id` of at least `amount`.\\n * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the\\n * acceptance magic value.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 id,\\n uint256 amount,\\n bytes calldata data\\n ) external;\\n\\n /**\\n * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.\\n *\\n * Emits a {TransferBatch} event.\\n *\\n * Requirements:\\n *\\n * - `ids` and `amounts` must have the same length.\\n * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the\\n * acceptance magic value.\\n */\\n function safeBatchTransferFrom(\\n address from,\\n address to,\\n uint256[] calldata ids,\\n uint256[] calldata amounts,\\n bytes calldata data\\n ) external;\\n}\\n\",\"keccak256\":\"0x6392f2cfe3a5ee802227fe7a2dfd47096d881aec89bddd214b35c5b46d3cd941\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/ERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC721.sol\\\";\\nimport \\\"./IERC721Receiver.sol\\\";\\nimport \\\"./extensions/IERC721Metadata.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/Context.sol\\\";\\nimport \\\"../../utils/Strings.sol\\\";\\nimport \\\"../../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\\n * the Metadata extension, but not including the Enumerable extension, which is available separately as\\n * {ERC721Enumerable}.\\n */\\ncontract ERC721 is Context, ERC165, IERC721, IERC721Metadata {\\n using Address for address;\\n using Strings for uint256;\\n\\n // Token name\\n string private _name;\\n\\n // Token symbol\\n string private _symbol;\\n\\n // Mapping from token ID to owner address\\n mapping(uint256 => address) private _owners;\\n\\n // Mapping owner address to token count\\n mapping(address => uint256) private _balances;\\n\\n // Mapping from token ID to approved address\\n mapping(uint256 => address) private _tokenApprovals;\\n\\n // Mapping from owner to operator approvals\\n mapping(address => mapping(address => bool)) private _operatorApprovals;\\n\\n /**\\n * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.\\n */\\n constructor(string memory name_, string memory symbol_) {\\n _name = name_;\\n _symbol = symbol_;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\\n return\\n interfaceId == type(IERC721).interfaceId ||\\n interfaceId == type(IERC721Metadata).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IERC721-balanceOf}.\\n */\\n function balanceOf(address owner) public view virtual override returns (uint256) {\\n require(owner != address(0), \\\"ERC721: address zero is not a valid owner\\\");\\n return _balances[owner];\\n }\\n\\n /**\\n * @dev See {IERC721-ownerOf}.\\n */\\n function ownerOf(uint256 tokenId) public view virtual override returns (address) {\\n address owner = _ownerOf(tokenId);\\n require(owner != address(0), \\\"ERC721: invalid token ID\\\");\\n return owner;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-name}.\\n */\\n function name() public view virtual override returns (string memory) {\\n return _name;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-symbol}.\\n */\\n function symbol() public view virtual override returns (string memory) {\\n return _symbol;\\n }\\n\\n /**\\n * @dev See {IERC721Metadata-tokenURI}.\\n */\\n function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {\\n _requireMinted(tokenId);\\n\\n string memory baseURI = _baseURI();\\n return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : \\\"\\\";\\n }\\n\\n /**\\n * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\\n * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\\n * by default, can be overridden in child contracts.\\n */\\n function _baseURI() internal view virtual returns (string memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IERC721-approve}.\\n */\\n function approve(address to, uint256 tokenId) public virtual override {\\n address owner = ERC721.ownerOf(tokenId);\\n require(to != owner, \\\"ERC721: approval to current owner\\\");\\n\\n require(\\n _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\\n \\\"ERC721: approve caller is not token owner or approved for all\\\"\\n );\\n\\n _approve(to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-getApproved}.\\n */\\n function getApproved(uint256 tokenId) public view virtual override returns (address) {\\n _requireMinted(tokenId);\\n\\n return _tokenApprovals[tokenId];\\n }\\n\\n /**\\n * @dev See {IERC721-setApprovalForAll}.\\n */\\n function setApprovalForAll(address operator, bool approved) public virtual override {\\n _setApprovalForAll(_msgSender(), operator, approved);\\n }\\n\\n /**\\n * @dev See {IERC721-isApprovedForAll}.\\n */\\n function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {\\n return _operatorApprovals[owner][operator];\\n }\\n\\n /**\\n * @dev See {IERC721-transferFrom}.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n //solhint-disable-next-line max-line-length\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: caller is not token owner or approved\\\");\\n\\n _transfer(from, to, tokenId);\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) public virtual override {\\n safeTransferFrom(from, to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IERC721-safeTransferFrom}.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory data\\n ) public virtual override {\\n require(_isApprovedOrOwner(_msgSender(), tokenId), \\\"ERC721: caller is not token owner or approved\\\");\\n _safeTransfer(from, to, tokenId, data);\\n }\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * `data` is additional data, it has no specified format and it is sent in call to `to`.\\n *\\n * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.\\n * implement alternative mechanisms to perform token transfer, such as signature-based.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeTransfer(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory data\\n ) internal virtual {\\n _transfer(from, to, tokenId);\\n require(_checkOnERC721Received(from, to, tokenId, data), \\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n }\\n\\n /**\\n * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist\\n */\\n function _ownerOf(uint256 tokenId) internal view virtual returns (address) {\\n return _owners[tokenId];\\n }\\n\\n /**\\n * @dev Returns whether `tokenId` exists.\\n *\\n * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\\n *\\n * Tokens start existing when they are minted (`_mint`),\\n * and stop existing when they are burned (`_burn`).\\n */\\n function _exists(uint256 tokenId) internal view virtual returns (bool) {\\n return _ownerOf(tokenId) != address(0);\\n }\\n\\n /**\\n * @dev Returns whether `spender` is allowed to manage `tokenId`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {\\n address owner = ERC721.ownerOf(tokenId);\\n return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);\\n }\\n\\n /**\\n * @dev Safely mints `tokenId` and transfers it to `to`.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _safeMint(address to, uint256 tokenId) internal virtual {\\n _safeMint(to, tokenId, \\\"\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is\\n * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.\\n */\\n function _safeMint(\\n address to,\\n uint256 tokenId,\\n bytes memory data\\n ) internal virtual {\\n _mint(to, tokenId);\\n require(\\n _checkOnERC721Received(address(0), to, tokenId, data),\\n \\\"ERC721: transfer to non ERC721Receiver implementer\\\"\\n );\\n }\\n\\n /**\\n * @dev Mints `tokenId` and transfers it to `to`.\\n *\\n * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible\\n *\\n * Requirements:\\n *\\n * - `tokenId` must not exist.\\n * - `to` cannot be the zero address.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _mint(address to, uint256 tokenId) internal virtual {\\n require(to != address(0), \\\"ERC721: mint to the zero address\\\");\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n _beforeTokenTransfer(address(0), to, tokenId, 1);\\n\\n // Check that tokenId was not minted by `_beforeTokenTransfer` hook\\n require(!_exists(tokenId), \\\"ERC721: token already minted\\\");\\n\\n unchecked {\\n // Will not overflow unless all 2**256 token ids are minted to the same owner.\\n // Given that tokens are minted one by one, it is impossible in practice that\\n // this ever happens. Might change if we allow batch minting.\\n // The ERC fails to describe this case.\\n _balances[to] += 1;\\n }\\n\\n _owners[tokenId] = to;\\n\\n emit Transfer(address(0), to, tokenId);\\n\\n _afterTokenTransfer(address(0), to, tokenId, 1);\\n }\\n\\n /**\\n * @dev Destroys `tokenId`.\\n * The approval is cleared when the token is burned.\\n * This is an internal function that does not check if the sender is authorized to operate on the token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _burn(uint256 tokenId) internal virtual {\\n address owner = ERC721.ownerOf(tokenId);\\n\\n _beforeTokenTransfer(owner, address(0), tokenId, 1);\\n\\n // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook\\n owner = ERC721.ownerOf(tokenId);\\n\\n // Clear approvals\\n delete _tokenApprovals[tokenId];\\n\\n unchecked {\\n // Cannot overflow, as that would require more tokens to be burned/transferred\\n // out than the owner initially received through minting and transferring in.\\n _balances[owner] -= 1;\\n }\\n delete _owners[tokenId];\\n\\n emit Transfer(owner, address(0), tokenId);\\n\\n _afterTokenTransfer(owner, address(0), tokenId, 1);\\n }\\n\\n /**\\n * @dev Transfers `tokenId` from `from` to `to`.\\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _transfer(\\n address from,\\n address to,\\n uint256 tokenId\\n ) internal virtual {\\n require(ERC721.ownerOf(tokenId) == from, \\\"ERC721: transfer from incorrect owner\\\");\\n require(to != address(0), \\\"ERC721: transfer to the zero address\\\");\\n\\n _beforeTokenTransfer(from, to, tokenId, 1);\\n\\n // Check that tokenId was not transferred by `_beforeTokenTransfer` hook\\n require(ERC721.ownerOf(tokenId) == from, \\\"ERC721: transfer from incorrect owner\\\");\\n\\n // Clear approvals from the previous owner\\n delete _tokenApprovals[tokenId];\\n\\n unchecked {\\n // `_balances[from]` cannot overflow for the same reason as described in `_burn`:\\n // `from`'s balance is the number of token held, which is at least one before the current\\n // transfer.\\n // `_balances[to]` could overflow in the conditions described in `_mint`. That would require\\n // all 2**256 token ids to be minted, which in practice is impossible.\\n _balances[from] -= 1;\\n _balances[to] += 1;\\n }\\n _owners[tokenId] = to;\\n\\n emit Transfer(from, to, tokenId);\\n\\n _afterTokenTransfer(from, to, tokenId, 1);\\n }\\n\\n /**\\n * @dev Approve `to` to operate on `tokenId`\\n *\\n * Emits an {Approval} event.\\n */\\n function _approve(address to, uint256 tokenId) internal virtual {\\n _tokenApprovals[tokenId] = to;\\n emit Approval(ERC721.ownerOf(tokenId), to, tokenId);\\n }\\n\\n /**\\n * @dev Approve `operator` to operate on all of `owner` tokens\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function _setApprovalForAll(\\n address owner,\\n address operator,\\n bool approved\\n ) internal virtual {\\n require(owner != operator, \\\"ERC721: approve to caller\\\");\\n _operatorApprovals[owner][operator] = approved;\\n emit ApprovalForAll(owner, operator, approved);\\n }\\n\\n /**\\n * @dev Reverts if the `tokenId` has not been minted yet.\\n */\\n function _requireMinted(uint256 tokenId) internal view virtual {\\n require(_exists(tokenId), \\\"ERC721: invalid token ID\\\");\\n }\\n\\n /**\\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\\n * The call is not executed if the target address is not a contract.\\n *\\n * @param from address representing the previous owner of the given token ID\\n * @param to target address that will receive the tokens\\n * @param tokenId uint256 ID of the token to be transferred\\n * @param data bytes optional data to send along with the call\\n * @return bool whether the call correctly returned the expected magic value\\n */\\n function _checkOnERC721Received(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes memory data\\n ) private returns (bool) {\\n if (to.isContract()) {\\n try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {\\n return retval == IERC721Receiver.onERC721Received.selector;\\n } catch (bytes memory reason) {\\n if (reason.length == 0) {\\n revert(\\\"ERC721: transfer to non ERC721Receiver implementer\\\");\\n } else {\\n /// @solidity memory-safe-assembly\\n assembly {\\n revert(add(32, reason), mload(reason))\\n }\\n }\\n }\\n } else {\\n return true;\\n }\\n }\\n\\n /**\\n * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is\\n * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.\\n * - When `from` is zero, the tokens will be minted for `to`.\\n * - When `to` is zero, ``from``'s tokens will be burned.\\n * - `from` and `to` are never both zero.\\n * - `batchSize` is non-zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _beforeTokenTransfer(\\n address from,\\n address to,\\n uint256, /* firstTokenId */\\n uint256 batchSize\\n ) internal virtual {\\n if (batchSize > 1) {\\n if (from != address(0)) {\\n _balances[from] -= batchSize;\\n }\\n if (to != address(0)) {\\n _balances[to] += batchSize;\\n }\\n }\\n }\\n\\n /**\\n * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is\\n * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.\\n *\\n * Calling conditions:\\n *\\n * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.\\n * - When `from` is zero, the tokens were minted for `to`.\\n * - When `to` is zero, ``from``'s tokens were burned.\\n * - `from` and `to` are never both zero.\\n * - `batchSize` is non-zero.\\n *\\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n */\\n function _afterTokenTransfer(\\n address from,\\n address to,\\n uint256 firstTokenId,\\n uint256 batchSize\\n ) internal virtual {}\\n}\\n\",\"keccak256\":\"0xd89f3585b211fc9e3408384a4c4efdc3a93b2f877a3821046fa01c219d35be1b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Required interface of an ERC721 compliant contract.\\n */\\ninterface IERC721 is IERC165 {\\n /**\\n * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\\n */\\n event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\\n\\n /**\\n * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\\n */\\n event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\\n\\n /**\\n * @dev Returns the number of tokens in ``owner``'s account.\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @dev Returns the owner of the `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId,\\n bytes calldata data\\n ) external;\\n\\n /**\\n * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\\n * are aware of the ERC721 protocol to prevent tokens from being forever locked.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must exist and be owned by `from`.\\n * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\\n * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\\n *\\n * Emits a {Transfer} event.\\n */\\n function safeTransferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Transfers `tokenId` token from `from` to `to`.\\n *\\n * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\\n * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\\n * understand this adds an external call which potentially creates a reentrancy vulnerability.\\n *\\n * Requirements:\\n *\\n * - `from` cannot be the zero address.\\n * - `to` cannot be the zero address.\\n * - `tokenId` token must be owned by `from`.\\n * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address from,\\n address to,\\n uint256 tokenId\\n ) external;\\n\\n /**\\n * @dev Gives permission to `to` to transfer `tokenId` token to another account.\\n * The approval is cleared when the token is transferred.\\n *\\n * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\\n *\\n * Requirements:\\n *\\n * - The caller must own the token or be an approved operator.\\n * - `tokenId` must exist.\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address to, uint256 tokenId) external;\\n\\n /**\\n * @dev Approve or remove `operator` as an operator for the caller.\\n * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\\n *\\n * Requirements:\\n *\\n * - The `operator` cannot be the caller.\\n *\\n * Emits an {ApprovalForAll} event.\\n */\\n function setApprovalForAll(address operator, bool _approved) external;\\n\\n /**\\n * @dev Returns the account approved for `tokenId` token.\\n *\\n * Requirements:\\n *\\n * - `tokenId` must exist.\\n */\\n function getApproved(uint256 tokenId) external view returns (address operator);\\n\\n /**\\n * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\\n *\\n * See {setApprovalForAll}\\n */\\n function isApprovedForAll(address owner, address operator) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xab28a56179c1db258c9bf5235b382698cb650debecb51b23d12be9e241374b68\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0xa82b58eca1ee256be466e536706850163d2ec7821945abd6b4778cfb3bee37da\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC721.sol\\\";\\n\\n/**\\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\\n * @dev See https://eips.ethereum.org/EIPS/eip-721\\n */\\ninterface IERC721Metadata is IERC721 {\\n /**\\n * @dev Returns the token collection name.\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @dev Returns the token collection symbol.\\n */\\n function symbol() external view returns (string memory);\\n\\n /**\\n * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\\n */\\n function tokenURI(uint256 tokenId) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x75b829ff2f26c14355d1cba20e16fe7b29ca58eb5fef665ede48bc0f9c6c74b9\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf96f969e24029d43d0df89e59d365f277021dac62b48e1c1e3ebe0acdd7f1ca1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\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\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\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 /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\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 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] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\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 representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n }\\n}\\n\",\"keccak256\":\"0xa4d1d62251f8574deb032a35fc948386a9b4de74b812d4f545a1ac120486b48a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 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 *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\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[EIP 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\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\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 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 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 up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // 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 prod0 := mul(x, y)\\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 return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\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. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\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^256 / 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^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\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 works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\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^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, 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 * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\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 unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\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 log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xa1e8e83cd0087785df04ac79fb395d9f3684caeaf973d9e2c71caef723a3a5d6\",\"license\":\"MIT\"},\"contracts/ethregistrar/BaseRegistrarImplementation.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\nimport \\\"../registry/ENS.sol\\\";\\nimport \\\"./IBaseRegistrar.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC721/ERC721.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\ncontract BaseRegistrarImplementation is ERC721, IBaseRegistrar, Ownable {\\n // A map of expiry times\\n mapping(uint256 => uint256) expiries;\\n // The ENS registry\\n ENS public ens;\\n // The namehash of the TLD this registrar owns (eg, .eth)\\n bytes32 public baseNode;\\n // A map of addresses that are authorised to register and renew names.\\n mapping(address => bool) public controllers;\\n uint256 public constant GRACE_PERIOD = 90 days;\\n bytes4 private constant INTERFACE_META_ID =\\n bytes4(keccak256(\\\"supportsInterface(bytes4)\\\"));\\n bytes4 private constant ERC721_ID =\\n bytes4(\\n keccak256(\\\"balanceOf(address)\\\") ^\\n keccak256(\\\"ownerOf(uint256)\\\") ^\\n keccak256(\\\"approve(address,uint256)\\\") ^\\n keccak256(\\\"getApproved(uint256)\\\") ^\\n keccak256(\\\"setApprovalForAll(address,bool)\\\") ^\\n keccak256(\\\"isApprovedForAll(address,address)\\\") ^\\n keccak256(\\\"transferFrom(address,address,uint256)\\\") ^\\n keccak256(\\\"safeTransferFrom(address,address,uint256)\\\") ^\\n keccak256(\\\"safeTransferFrom(address,address,uint256,bytes)\\\")\\n );\\n bytes4 private constant RECLAIM_ID =\\n bytes4(keccak256(\\\"reclaim(uint256,address)\\\"));\\n\\n /**\\n * v2.1.3 version of _isApprovedOrOwner which calls ownerOf(tokenId) and takes grace period into consideration instead of ERC721.ownerOf(tokenId);\\n * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v2.1.3/contracts/token/ERC721/ERC721.sol#L187\\n * @dev Returns whether the given spender can transfer a given token ID\\n * @param spender address of the spender to query\\n * @param tokenId uint256 ID of the token to be transferred\\n * @return bool whether the msg.sender is approved for the given token ID,\\n * is an operator of the owner, or is the owner of the token\\n */\\n function _isApprovedOrOwner(\\n address spender,\\n uint256 tokenId\\n ) internal view override returns (bool) {\\n address owner = ownerOf(tokenId);\\n return (spender == owner ||\\n getApproved(tokenId) == spender ||\\n isApprovedForAll(owner, spender));\\n }\\n\\n constructor(ENS _ens, bytes32 _baseNode) ERC721(\\\"\\\", \\\"\\\") {\\n ens = _ens;\\n baseNode = _baseNode;\\n }\\n\\n modifier live() {\\n require(ens.owner(baseNode) == address(this));\\n _;\\n }\\n\\n modifier onlyController() {\\n require(controllers[msg.sender]);\\n _;\\n }\\n\\n /**\\n * @dev Gets the owner of the specified token ID. Names become unowned\\n * when their registration expires.\\n * @param tokenId uint256 ID of the token to query the owner of\\n * @return address currently marked as the owner of the given token ID\\n */\\n function ownerOf(\\n uint256 tokenId\\n ) public view override(IERC721, ERC721) returns (address) {\\n require(expiries[tokenId] > block.timestamp);\\n return super.ownerOf(tokenId);\\n }\\n\\n // Authorises a controller, who can register and renew domains.\\n function addController(address controller) external override onlyOwner {\\n controllers[controller] = true;\\n emit ControllerAdded(controller);\\n }\\n\\n // Revoke controller permission for an address.\\n function removeController(address controller) external override onlyOwner {\\n controllers[controller] = false;\\n emit ControllerRemoved(controller);\\n }\\n\\n // Set the resolver for the TLD this registrar manages.\\n function setResolver(address resolver) external override onlyOwner {\\n ens.setResolver(baseNode, resolver);\\n }\\n\\n // Returns the expiration timestamp of the specified id.\\n function nameExpires(uint256 id) external view override returns (uint256) {\\n return expiries[id];\\n }\\n\\n // Returns true iff the specified name is available for registration.\\n function available(uint256 id) public view override returns (bool) {\\n // Not available if it's registered here or in its grace period.\\n return expiries[id] + GRACE_PERIOD < block.timestamp;\\n }\\n\\n /**\\n * @dev Register a name.\\n * @param id The token ID (keccak256 of the label).\\n * @param owner The address that should own the registration.\\n * @param duration Duration in seconds for the registration.\\n */\\n function register(\\n uint256 id,\\n address owner,\\n uint256 duration\\n ) external override returns (uint256) {\\n return _register(id, owner, duration, true);\\n }\\n\\n /**\\n * @dev Register a name, without modifying the registry.\\n * @param id The token ID (keccak256 of the label).\\n * @param owner The address that should own the registration.\\n * @param duration Duration in seconds for the registration.\\n */\\n function registerOnly(\\n uint256 id,\\n address owner,\\n uint256 duration\\n ) external returns (uint256) {\\n return _register(id, owner, duration, false);\\n }\\n\\n function _register(\\n uint256 id,\\n address owner,\\n uint256 duration,\\n bool updateRegistry\\n ) internal live onlyController returns (uint256) {\\n require(available(id));\\n require(\\n block.timestamp + duration + GRACE_PERIOD >\\n block.timestamp + GRACE_PERIOD\\n ); // Prevent future overflow\\n\\n expiries[id] = block.timestamp + duration;\\n if (_exists(id)) {\\n // Name was previously owned, and expired\\n _burn(id);\\n }\\n _mint(owner, id);\\n if (updateRegistry) {\\n ens.setSubnodeOwner(baseNode, bytes32(id), owner);\\n }\\n\\n emit NameRegistered(id, owner, block.timestamp + duration);\\n\\n return block.timestamp + duration;\\n }\\n\\n function renew(\\n uint256 id,\\n uint256 duration\\n ) external override live onlyController returns (uint256) {\\n require(expiries[id] + GRACE_PERIOD >= block.timestamp); // Name must be registered here or in grace period\\n require(\\n expiries[id] + duration + GRACE_PERIOD > duration + GRACE_PERIOD\\n ); // Prevent future overflow\\n\\n expiries[id] += duration;\\n emit NameRenewed(id, expiries[id]);\\n return expiries[id];\\n }\\n\\n /**\\n * @dev Reclaim ownership of a name in ENS, if you own it in the registrar.\\n */\\n function reclaim(uint256 id, address owner) external override live {\\n require(_isApprovedOrOwner(msg.sender, id));\\n ens.setSubnodeOwner(baseNode, bytes32(id), owner);\\n }\\n\\n function supportsInterface(\\n bytes4 interfaceID\\n ) public view override(ERC721, IERC165) returns (bool) {\\n return\\n interfaceID == INTERFACE_META_ID ||\\n interfaceID == ERC721_ID ||\\n interfaceID == RECLAIM_ID;\\n }\\n}\\n\",\"keccak256\":\"0xaee6eb36aead449d397b86a02e9c63bc46e3ef378d0a62bfd68beaae1150c9d0\"},\"contracts/ethregistrar/ETHRegistrarController.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\nimport {BaseRegistrarImplementation} from \\\"./BaseRegistrarImplementation.sol\\\";\\nimport {StringUtils} from \\\"./StringUtils.sol\\\";\\nimport {Resolver} from \\\"../resolvers/Resolver.sol\\\";\\nimport {ENS} from \\\"../registry/ENS.sol\\\";\\nimport {ReverseRegistrar} from \\\"../reverseRegistrar/ReverseRegistrar.sol\\\";\\nimport {ReverseClaimer} from \\\"../reverseRegistrar/ReverseClaimer.sol\\\";\\nimport {IETHRegistrarController, IPriceOracle} from \\\"./IETHRegistrarController.sol\\\";\\n\\nimport {Ownable} from \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport {IERC165} from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport {Address} from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport {INameWrapper} from \\\"../wrapper/INameWrapper.sol\\\";\\nimport {ERC20Recoverable} from \\\"../utils/ERC20Recoverable.sol\\\";\\n\\nerror CommitmentTooNew(bytes32 commitment);\\nerror CommitmentTooOld(bytes32 commitment);\\nerror NameNotAvailable(string name);\\nerror DurationTooShort(uint256 duration);\\nerror ResolverRequiredWhenDataSupplied();\\nerror UnexpiredCommitmentExists(bytes32 commitment);\\nerror InsufficientValue();\\nerror Unauthorised(bytes32 node);\\nerror MaxCommitmentAgeTooLow();\\nerror MaxCommitmentAgeTooHigh();\\n\\n/**\\n * @dev A registrar controller for registering and renewing names at fixed cost.\\n */\\ncontract ETHRegistrarController is\\n Ownable,\\n IETHRegistrarController,\\n IERC165,\\n ERC20Recoverable,\\n ReverseClaimer\\n{\\n using StringUtils for *;\\n using Address for address;\\n\\n uint256 public constant MIN_REGISTRATION_DURATION = 28 days;\\n bytes32 private constant ETH_NODE =\\n 0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae;\\n uint64 private constant MAX_EXPIRY = type(uint64).max;\\n BaseRegistrarImplementation immutable base;\\n IPriceOracle public immutable prices;\\n uint256 public immutable minCommitmentAge;\\n uint256 public immutable maxCommitmentAge;\\n ReverseRegistrar public immutable reverseRegistrar;\\n INameWrapper public immutable nameWrapper;\\n\\n mapping(bytes32 => uint256) public commitments;\\n\\n event NameRegistered(\\n string name,\\n bytes32 indexed label,\\n address indexed owner,\\n uint256 baseCost,\\n uint256 premium,\\n uint256 expires\\n );\\n event NameRenewed(\\n string name,\\n bytes32 indexed label,\\n uint256 cost,\\n uint256 expires\\n );\\n\\n constructor(\\n BaseRegistrarImplementation _base,\\n IPriceOracle _prices,\\n uint256 _minCommitmentAge,\\n uint256 _maxCommitmentAge,\\n ReverseRegistrar _reverseRegistrar,\\n INameWrapper _nameWrapper,\\n ENS _ens\\n ) ReverseClaimer(_ens, msg.sender) {\\n if (_maxCommitmentAge <= _minCommitmentAge) {\\n revert MaxCommitmentAgeTooLow();\\n }\\n\\n if (_maxCommitmentAge > block.timestamp) {\\n revert MaxCommitmentAgeTooHigh();\\n }\\n\\n base = _base;\\n prices = _prices;\\n minCommitmentAge = _minCommitmentAge;\\n maxCommitmentAge = _maxCommitmentAge;\\n reverseRegistrar = _reverseRegistrar;\\n nameWrapper = _nameWrapper;\\n }\\n\\n function rentPrice(\\n string memory name,\\n uint256 duration\\n ) public view override returns (IPriceOracle.Price memory price) {\\n bytes32 label = keccak256(bytes(name));\\n price = prices.price(name, base.nameExpires(uint256(label)), duration);\\n }\\n\\n function valid(string memory name) public pure returns (bool) {\\n return name.strlen() >= 3;\\n }\\n\\n function available(string memory name) public view override returns (bool) {\\n bytes32 label = keccak256(bytes(name));\\n return valid(name) && base.available(uint256(label));\\n }\\n\\n function makeCommitment(\\n string memory name,\\n address owner,\\n uint256 duration,\\n bytes32 secret,\\n address resolver,\\n bytes[] calldata data,\\n bool reverseRecord,\\n uint16 ownerControlledFuses\\n ) public pure override returns (bytes32) {\\n bytes32 label = keccak256(bytes(name));\\n if (data.length > 0 && resolver == address(0)) {\\n revert ResolverRequiredWhenDataSupplied();\\n }\\n return\\n keccak256(\\n abi.encode(\\n label,\\n owner,\\n duration,\\n secret,\\n resolver,\\n data,\\n reverseRecord,\\n ownerControlledFuses\\n )\\n );\\n }\\n\\n function commit(bytes32 commitment) public override {\\n if (commitments[commitment] + maxCommitmentAge >= block.timestamp) {\\n revert UnexpiredCommitmentExists(commitment);\\n }\\n commitments[commitment] = block.timestamp;\\n }\\n\\n function register(\\n string calldata name,\\n address owner,\\n uint256 duration,\\n bytes32 secret,\\n address resolver,\\n bytes[] calldata data,\\n bool reverseRecord,\\n uint16 ownerControlledFuses\\n ) public payable override {\\n IPriceOracle.Price memory price = rentPrice(name, duration);\\n if (msg.value < price.base + price.premium) {\\n revert InsufficientValue();\\n }\\n\\n _consumeCommitment(\\n name,\\n duration,\\n makeCommitment(\\n name,\\n owner,\\n duration,\\n secret,\\n resolver,\\n data,\\n reverseRecord,\\n ownerControlledFuses\\n )\\n );\\n\\n uint256 expires = nameWrapper.registerAndWrapETH2LD(\\n name,\\n owner,\\n duration,\\n resolver,\\n ownerControlledFuses\\n );\\n\\n if (data.length > 0) {\\n _setRecords(resolver, keccak256(bytes(name)), data);\\n }\\n\\n if (reverseRecord) {\\n _setReverseRecord(name, resolver, msg.sender);\\n }\\n\\n emit NameRegistered(\\n name,\\n keccak256(bytes(name)),\\n owner,\\n price.base,\\n price.premium,\\n expires\\n );\\n\\n if (msg.value > (price.base + price.premium)) {\\n payable(msg.sender).transfer(\\n msg.value - (price.base + price.premium)\\n );\\n }\\n }\\n\\n function renew(\\n string calldata name,\\n uint256 duration\\n ) external payable override {\\n bytes32 labelhash = keccak256(bytes(name));\\n uint256 tokenId = uint256(labelhash);\\n IPriceOracle.Price memory price = rentPrice(name, duration);\\n if (msg.value < price.base) {\\n revert InsufficientValue();\\n }\\n uint256 expires = nameWrapper.renew(tokenId, duration);\\n\\n if (msg.value > price.base) {\\n payable(msg.sender).transfer(msg.value - price.base);\\n }\\n\\n emit NameRenewed(name, labelhash, msg.value, expires);\\n }\\n\\n function withdraw() public {\\n payable(owner()).transfer(address(this).balance);\\n }\\n\\n function supportsInterface(\\n bytes4 interfaceID\\n ) external pure returns (bool) {\\n return\\n interfaceID == type(IERC165).interfaceId ||\\n interfaceID == type(IETHRegistrarController).interfaceId;\\n }\\n\\n /* Internal functions */\\n\\n function _consumeCommitment(\\n string memory name,\\n uint256 duration,\\n bytes32 commitment\\n ) internal {\\n // Require an old enough commitment.\\n if (commitments[commitment] + minCommitmentAge > block.timestamp) {\\n revert CommitmentTooNew(commitment);\\n }\\n\\n // If the commitment is too old, or the name is registered, stop\\n if (commitments[commitment] + maxCommitmentAge <= block.timestamp) {\\n revert CommitmentTooOld(commitment);\\n }\\n if (!available(name)) {\\n revert NameNotAvailable(name);\\n }\\n\\n delete (commitments[commitment]);\\n\\n if (duration < MIN_REGISTRATION_DURATION) {\\n revert DurationTooShort(duration);\\n }\\n }\\n\\n function _setRecords(\\n address resolverAddress,\\n bytes32 label,\\n bytes[] calldata data\\n ) internal {\\n // use hardcoded .eth namehash\\n bytes32 nodehash = keccak256(abi.encodePacked(ETH_NODE, label));\\n Resolver resolver = Resolver(resolverAddress);\\n resolver.multicallWithNodeCheck(nodehash, data);\\n }\\n\\n function _setReverseRecord(\\n string memory name,\\n address resolver,\\n address owner\\n ) internal {\\n reverseRegistrar.setNameForAddr(\\n msg.sender,\\n owner,\\n resolver,\\n string.concat(name, \\\".eth\\\")\\n );\\n }\\n}\\n\",\"keccak256\":\"0x2ba2cab655f9128ae5c803540b8712be9bdfee1a28b9623a06c02c2435d0ce8b\",\"license\":\"MIT\"},\"contracts/ethregistrar/IBaseRegistrar.sol\":{\"content\":\"import \\\"../registry/ENS.sol\\\";\\nimport \\\"./IBaseRegistrar.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC721/IERC721.sol\\\";\\n\\ninterface IBaseRegistrar is IERC721 {\\n event ControllerAdded(address indexed controller);\\n event ControllerRemoved(address indexed controller);\\n event NameMigrated(\\n uint256 indexed id,\\n address indexed owner,\\n uint256 expires\\n );\\n event NameRegistered(\\n uint256 indexed id,\\n address indexed owner,\\n uint256 expires\\n );\\n event NameRenewed(uint256 indexed id, uint256 expires);\\n\\n // Authorises a controller, who can register and renew domains.\\n function addController(address controller) external;\\n\\n // Revoke controller permission for an address.\\n function removeController(address controller) external;\\n\\n // Set the resolver for the TLD this registrar manages.\\n function setResolver(address resolver) external;\\n\\n // Returns the expiration timestamp of the specified label hash.\\n function nameExpires(uint256 id) external view returns (uint256);\\n\\n // Returns true if the specified name is available for registration.\\n function available(uint256 id) external view returns (bool);\\n\\n /**\\n * @dev Register a name.\\n */\\n function register(\\n uint256 id,\\n address owner,\\n uint256 duration\\n ) external returns (uint256);\\n\\n function renew(uint256 id, uint256 duration) external returns (uint256);\\n\\n /**\\n * @dev Reclaim ownership of a name in ENS, if you own it in the registrar.\\n */\\n function reclaim(uint256 id, address owner) external;\\n}\\n\",\"keccak256\":\"0x15f7b1dfa7cd34444daf79ec9b4d40437caa9257893ce0639d706fcc2ba69e52\"},\"contracts/ethregistrar/IBulkRenewal.sol\":{\"content\":\"interface IBulkRenewal {\\n function rentPrice(\\n string[] calldata names,\\n uint256 duration\\n ) external view returns (uint256 total);\\n\\n function renewAll(\\n string[] calldata names,\\n uint256 duration\\n ) external payable;\\n}\\n\",\"keccak256\":\"0x45d72e0464af5165831210496cd293cc7ceeb7307f2bdad679f64613a6bcf029\"},\"contracts/ethregistrar/IETHRegistrarController.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\nimport \\\"./IPriceOracle.sol\\\";\\n\\ninterface IETHRegistrarController {\\n function rentPrice(\\n string memory,\\n uint256\\n ) external view returns (IPriceOracle.Price memory);\\n\\n function available(string memory) external returns (bool);\\n\\n function makeCommitment(\\n string memory,\\n address,\\n uint256,\\n bytes32,\\n address,\\n bytes[] calldata,\\n bool,\\n uint16\\n ) external pure returns (bytes32);\\n\\n function commit(bytes32) external;\\n\\n function register(\\n string calldata,\\n address,\\n uint256,\\n bytes32,\\n address,\\n bytes[] calldata,\\n bool,\\n uint16\\n ) external payable;\\n\\n function renew(string calldata, uint256) external payable;\\n}\\n\",\"keccak256\":\"0x54575cc2e4245c0ba79e42a58086335ec0522f4cbeb8c92d71b886593c97060e\",\"license\":\"MIT\"},\"contracts/ethregistrar/IPriceOracle.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.17 <0.9.0;\\n\\ninterface IPriceOracle {\\n struct Price {\\n uint256 base;\\n uint256 premium;\\n }\\n\\n /**\\n * @dev Returns the price to register or renew a name.\\n * @param name The name being registered or renewed.\\n * @param expires When the name presently expires (0 if this is a new registration).\\n * @param duration How long the name is being registered or extended for, in seconds.\\n * @return base premium tuple of base price + premium price\\n */\\n function price(\\n string calldata name,\\n uint256 expires,\\n uint256 duration\\n ) external view returns (Price calldata);\\n}\\n\",\"keccak256\":\"0x1ec537b4c7f9cc40363b39dcc7ade8c29bf94662e6b01d38e681487637bd577e\",\"license\":\"MIT\"},\"contracts/ethregistrar/StaticBulkRenewal.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\nimport \\\"./ETHRegistrarController.sol\\\";\\nimport \\\"./IBulkRenewal.sol\\\";\\nimport \\\"./IPriceOracle.sol\\\";\\n\\nimport \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\n\\ncontract StaticBulkRenewal is IBulkRenewal {\\n ETHRegistrarController controller;\\n\\n constructor(ETHRegistrarController _controller) {\\n controller = _controller;\\n }\\n\\n function rentPrice(\\n string[] calldata names,\\n uint256 duration\\n ) external view override returns (uint256 total) {\\n uint256 length = names.length;\\n for (uint256 i = 0; i < length; ) {\\n IPriceOracle.Price memory price = controller.rentPrice(\\n names[i],\\n duration\\n );\\n unchecked {\\n ++i;\\n total += (price.base + price.premium);\\n }\\n }\\n }\\n\\n function renewAll(\\n string[] calldata names,\\n uint256 duration\\n ) external payable override {\\n uint256 length = names.length;\\n uint256 total;\\n for (uint256 i = 0; i < length; ) {\\n IPriceOracle.Price memory price = controller.rentPrice(\\n names[i],\\n duration\\n );\\n uint256 totalPrice = price.base + price.premium;\\n controller.renew{value: totalPrice}(names[i], duration);\\n unchecked {\\n ++i;\\n total += totalPrice;\\n }\\n }\\n // Send any excess funds back\\n payable(msg.sender).transfer(address(this).balance);\\n }\\n\\n function supportsInterface(\\n bytes4 interfaceID\\n ) external pure returns (bool) {\\n return\\n interfaceID == type(IERC165).interfaceId ||\\n interfaceID == type(IBulkRenewal).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xa4c30f4d395dec3d252e8b9e46710fe38038cfdc3e33a3bdd0ea54e046e91f48\",\"license\":\"MIT\"},\"contracts/ethregistrar/StringUtils.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\nlibrary StringUtils {\\n /**\\n * @dev Returns the length of a given string\\n *\\n * @param s The string to measure the length of\\n * @return The length of the input string\\n */\\n function strlen(string memory s) internal pure returns (uint256) {\\n uint256 len;\\n uint256 i = 0;\\n uint256 bytelength = bytes(s).length;\\n for (len = 0; i < bytelength; len++) {\\n bytes1 b = bytes(s)[i];\\n if (b < 0x80) {\\n i += 1;\\n } else if (b < 0xE0) {\\n i += 2;\\n } else if (b < 0xF0) {\\n i += 3;\\n } else if (b < 0xF8) {\\n i += 4;\\n } else if (b < 0xFC) {\\n i += 5;\\n } else {\\n i += 6;\\n }\\n }\\n return len;\\n }\\n}\\n\",\"keccak256\":\"0x4cc8363a850dc9130c433ee50e7c97e29a45ae5d9bd0808205ac7134b34f24e4\"},\"contracts/registry/ENS.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\ninterface ENS {\\n // Logged when the owner of a node assigns a new owner to a subnode.\\n event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);\\n\\n // Logged when the owner of a node transfers ownership to a new account.\\n event Transfer(bytes32 indexed node, address owner);\\n\\n // Logged when the resolver for a node changes.\\n event NewResolver(bytes32 indexed node, address resolver);\\n\\n // Logged when the TTL of a node changes\\n event NewTTL(bytes32 indexed node, uint64 ttl);\\n\\n // Logged when an operator is added or removed.\\n event ApprovalForAll(\\n address indexed owner,\\n address indexed operator,\\n bool approved\\n );\\n\\n function setRecord(\\n bytes32 node,\\n address owner,\\n address resolver,\\n uint64 ttl\\n ) external;\\n\\n function setSubnodeRecord(\\n bytes32 node,\\n bytes32 label,\\n address owner,\\n address resolver,\\n uint64 ttl\\n ) external;\\n\\n function setSubnodeOwner(\\n bytes32 node,\\n bytes32 label,\\n address owner\\n ) external returns (bytes32);\\n\\n function setResolver(bytes32 node, address resolver) external;\\n\\n function setOwner(bytes32 node, address owner) external;\\n\\n function setTTL(bytes32 node, uint64 ttl) external;\\n\\n function setApprovalForAll(address operator, bool approved) external;\\n\\n function owner(bytes32 node) external view returns (address);\\n\\n function resolver(bytes32 node) external view returns (address);\\n\\n function ttl(bytes32 node) external view returns (uint64);\\n\\n function recordExists(bytes32 node) external view returns (bool);\\n\\n function isApprovedForAll(\\n address owner,\\n address operator\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x7cb1158c7d268b63de1468e28e2711b28d686e2628ddb22da2149cd93ddeafda\"},\"contracts/resolvers/Resolver.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport \\\"./profiles/IABIResolver.sol\\\";\\nimport \\\"./profiles/IAddressResolver.sol\\\";\\nimport \\\"./profiles/IAddrResolver.sol\\\";\\nimport \\\"./profiles/IContentHashResolver.sol\\\";\\nimport \\\"./profiles/IDNSRecordResolver.sol\\\";\\nimport \\\"./profiles/IDNSZoneResolver.sol\\\";\\nimport \\\"./profiles/IInterfaceResolver.sol\\\";\\nimport \\\"./profiles/INameResolver.sol\\\";\\nimport \\\"./profiles/IPubkeyResolver.sol\\\";\\nimport \\\"./profiles/ITextResolver.sol\\\";\\nimport \\\"./profiles/IExtendedResolver.sol\\\";\\n\\n/**\\n * A generic resolver interface which includes all the functions including the ones deprecated\\n */\\ninterface Resolver is\\n IERC165,\\n IABIResolver,\\n IAddressResolver,\\n IAddrResolver,\\n IContentHashResolver,\\n IDNSRecordResolver,\\n IDNSZoneResolver,\\n IInterfaceResolver,\\n INameResolver,\\n IPubkeyResolver,\\n ITextResolver,\\n IExtendedResolver\\n{\\n /* Deprecated events */\\n event ContentChanged(bytes32 indexed node, bytes32 hash);\\n\\n function setApprovalForAll(address, bool) external;\\n\\n function approve(bytes32 node, address delegate, bool approved) external;\\n\\n function isApprovedForAll(address account, address operator) external;\\n\\n function isApprovedFor(\\n address owner,\\n bytes32 node,\\n address delegate\\n ) external;\\n\\n function setABI(\\n bytes32 node,\\n uint256 contentType,\\n bytes calldata data\\n ) external;\\n\\n function setAddr(bytes32 node, address addr) external;\\n\\n function setAddr(bytes32 node, uint256 coinType, bytes calldata a) external;\\n\\n function setContenthash(bytes32 node, bytes calldata hash) external;\\n\\n function setDnsrr(bytes32 node, bytes calldata data) external;\\n\\n function setName(bytes32 node, string calldata _name) external;\\n\\n function setPubkey(bytes32 node, bytes32 x, bytes32 y) external;\\n\\n function setText(\\n bytes32 node,\\n string calldata key,\\n string calldata value\\n ) external;\\n\\n function setInterface(\\n bytes32 node,\\n bytes4 interfaceID,\\n address implementer\\n ) external;\\n\\n function multicall(\\n bytes[] calldata data\\n ) external returns (bytes[] memory results);\\n\\n function multicallWithNodeCheck(\\n bytes32 nodehash,\\n bytes[] calldata data\\n ) external returns (bytes[] memory results);\\n\\n /* Deprecated functions */\\n function content(bytes32 node) external view returns (bytes32);\\n\\n function multihash(bytes32 node) external view returns (bytes memory);\\n\\n function setContent(bytes32 node, bytes32 hash) external;\\n\\n function setMultihash(bytes32 node, bytes calldata hash) external;\\n}\\n\",\"keccak256\":\"0xfc77ab6b7c59c3ebfe1c720bdebf9b08c2488ff7ac9501a9aa056c5d6d5b50c5\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IABIResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IABIResolver {\\n event ABIChanged(bytes32 indexed node, uint256 indexed contentType);\\n\\n /**\\n * Returns the ABI associated with an ENS node.\\n * Defined in EIP205.\\n * @param node The ENS node to query\\n * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.\\n * @return contentType The content type of the return value\\n * @return data The ABI data\\n */\\n function ABI(\\n bytes32 node,\\n uint256 contentTypes\\n ) external view returns (uint256, bytes memory);\\n}\\n\",\"keccak256\":\"0x85b373d02d19374fe570af407f459768285704bf7f30ab17c30eabfb5a10e4c3\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IAddrResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\n/**\\n * Interface for the legacy (ETH-only) addr function.\\n */\\ninterface IAddrResolver {\\n event AddrChanged(bytes32 indexed node, address a);\\n\\n /**\\n * Returns the address associated with an ENS node.\\n * @param node The ENS node to query.\\n * @return The associated address.\\n */\\n function addr(bytes32 node) external view returns (address payable);\\n}\\n\",\"keccak256\":\"0x2ad7f2fc60ebe0f93745fe70247f6a854f66af732483fda2a3c5e055614445e8\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IAddressResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\n/**\\n * Interface for the new (multicoin) addr function.\\n */\\ninterface IAddressResolver {\\n event AddressChanged(\\n bytes32 indexed node,\\n uint256 coinType,\\n bytes newAddress\\n );\\n\\n function addr(\\n bytes32 node,\\n uint256 coinType\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0x411447c1e90c51e09702815a85ec725ffbbe37cf96e8cc4d2a8bd4ad8a59d73e\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IContentHashResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IContentHashResolver {\\n event ContenthashChanged(bytes32 indexed node, bytes hash);\\n\\n /**\\n * Returns the contenthash associated with an ENS node.\\n * @param node The ENS node to query.\\n * @return The associated contenthash.\\n */\\n function contenthash(bytes32 node) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xd95cd77684ba5752c428d7dceb4ecc6506ac94f4fbb910489637eb68dcd8e366\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IDNSRecordResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IDNSRecordResolver {\\n // DNSRecordChanged is emitted whenever a given node/name/resource's RRSET is updated.\\n event DNSRecordChanged(\\n bytes32 indexed node,\\n bytes name,\\n uint16 resource,\\n bytes record\\n );\\n // DNSRecordDeleted is emitted whenever a given node/name/resource's RRSET is deleted.\\n event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource);\\n\\n /**\\n * Obtain a DNS record.\\n * @param node the namehash of the node for which to fetch the record\\n * @param name the keccak-256 hash of the fully-qualified name for which to fetch the record\\n * @param resource the ID of the resource as per https://en.wikipedia.org/wiki/List_of_DNS_record_types\\n * @return the DNS record in wire format if present, otherwise empty\\n */\\n function dnsRecord(\\n bytes32 node,\\n bytes32 name,\\n uint16 resource\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xcfa52200edd337f2c6c5bf402352600584da033b21323603e53de33051a3e25d\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IDNSZoneResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IDNSZoneResolver {\\n // DNSZonehashChanged is emitted whenever a given node's zone hash is updated.\\n event DNSZonehashChanged(\\n bytes32 indexed node,\\n bytes lastzonehash,\\n bytes zonehash\\n );\\n\\n /**\\n * zonehash obtains the hash for the zone.\\n * @param node The ENS node to query.\\n * @return The associated contenthash.\\n */\\n function zonehash(bytes32 node) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xca1b3a16e7005533f2800a3e66fcdccf7c574deac7913d8c810f40aec1d58dc0\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IExtendedResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\ninterface IExtendedResolver {\\n function resolve(\\n bytes memory name,\\n bytes memory data\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0x5d81521cfae7d9a4475d27533cd8ed0d3475d369eb0674fd90ffbdbdf292faa3\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IInterfaceResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IInterfaceResolver {\\n event InterfaceChanged(\\n bytes32 indexed node,\\n bytes4 indexed interfaceID,\\n address implementer\\n );\\n\\n /**\\n * Returns the address of a contract that implements the specified interface for this name.\\n * If an implementer has not been set for this interfaceID and name, the resolver will query\\n * the contract at `addr()`. If `addr()` is set, a contract exists at that address, and that\\n * contract implements EIP165 and returns `true` for the specified interfaceID, its address\\n * will be returned.\\n * @param node The ENS node to query.\\n * @param interfaceID The EIP 165 interface ID to check for.\\n * @return The address that implements this interface, or 0 if the interface is unsupported.\\n */\\n function interfaceImplementer(\\n bytes32 node,\\n bytes4 interfaceID\\n ) external view returns (address);\\n}\\n\",\"keccak256\":\"0x390321fb58f7b927df9562450981e74b4be3907e7c09df321fd3b7409b63ae28\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/INameResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface INameResolver {\\n event NameChanged(bytes32 indexed node, string name);\\n\\n /**\\n * Returns the name associated with an ENS node, for reverse records.\\n * Defined in EIP181.\\n * @param node The ENS node to query.\\n * @return The associated name.\\n */\\n function name(bytes32 node) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x9ec392b612447b1acbdc01114f2da2837a658d3f3157f60a99c5269f0b623346\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IPubkeyResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IPubkeyResolver {\\n event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);\\n\\n /**\\n * Returns the SECP256k1 public key associated with an ENS node.\\n * Defined in EIP 619.\\n * @param node The ENS node to query\\n * @return x The X coordinate of the curve point for the public key.\\n * @return y The Y coordinate of the curve point for the public key.\\n */\\n function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y);\\n}\\n\",\"keccak256\":\"0x69748947093dd2fda9ddcebd0adf19a6d1e7600df1d4b1462a0417156caddca7\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/ITextResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface ITextResolver {\\n event TextChanged(\\n bytes32 indexed node,\\n string indexed indexedKey,\\n string key,\\n string value\\n );\\n\\n /**\\n * Returns the text data associated with an ENS node and key.\\n * @param node The ENS node to query.\\n * @param key The text data key to query.\\n * @return The associated text data.\\n */\\n function text(\\n bytes32 node,\\n string calldata key\\n ) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x7c5debb3c42cd9f5de2274ea7aa053f238608314b62db441c40e31cea2543fd5\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/IReverseRegistrar.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\ninterface IReverseRegistrar {\\n function setDefaultResolver(address resolver) external;\\n\\n function claim(address owner) external returns (bytes32);\\n\\n function claimForAddr(\\n address addr,\\n address owner,\\n address resolver\\n ) external returns (bytes32);\\n\\n function claimWithResolver(\\n address owner,\\n address resolver\\n ) external returns (bytes32);\\n\\n function setName(string memory name) external returns (bytes32);\\n\\n function setNameForAddr(\\n address addr,\\n address owner,\\n address resolver,\\n string memory name\\n ) external returns (bytes32);\\n\\n function node(address addr) external pure returns (bytes32);\\n}\\n\",\"keccak256\":\"0x83adfcf6da72b1bcd1e3ac387afe5fc7fdf7f2ac28b7601544d2ca4b9d45d159\"},\"contracts/reverseRegistrar/ReverseClaimer.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.17 <0.9.0;\\n\\nimport {ENS} from \\\"../registry/ENS.sol\\\";\\nimport {IReverseRegistrar} from \\\"../reverseRegistrar/IReverseRegistrar.sol\\\";\\n\\ncontract ReverseClaimer {\\n bytes32 constant ADDR_REVERSE_NODE =\\n 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;\\n\\n constructor(ENS ens, address claimant) {\\n IReverseRegistrar reverseRegistrar = IReverseRegistrar(\\n ens.owner(ADDR_REVERSE_NODE)\\n );\\n reverseRegistrar.claim(claimant);\\n }\\n}\\n\",\"keccak256\":\"0x78a28627241535b595f6fff476a1fa7acc90c80684fe7784734920fc8af6fc22\",\"license\":\"MIT\"},\"contracts/reverseRegistrar/ReverseRegistrar.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\nimport \\\"../registry/ENS.sol\\\";\\nimport \\\"./IReverseRegistrar.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"../root/Controllable.sol\\\";\\n\\nabstract contract NameResolver {\\n function setName(bytes32 node, string memory name) public virtual;\\n}\\n\\nbytes32 constant lookup = 0x3031323334353637383961626364656600000000000000000000000000000000;\\n\\nbytes32 constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;\\n\\n// namehash('addr.reverse')\\n\\ncontract ReverseRegistrar is Ownable, Controllable, IReverseRegistrar {\\n ENS public immutable ens;\\n NameResolver public defaultResolver;\\n\\n event ReverseClaimed(address indexed addr, bytes32 indexed node);\\n event DefaultResolverChanged(NameResolver indexed resolver);\\n\\n /**\\n * @dev Constructor\\n * @param ensAddr The address of the ENS registry.\\n */\\n constructor(ENS ensAddr) {\\n ens = ensAddr;\\n\\n // Assign ownership of the reverse record to our deployer\\n ReverseRegistrar oldRegistrar = ReverseRegistrar(\\n ensAddr.owner(ADDR_REVERSE_NODE)\\n );\\n if (address(oldRegistrar) != address(0x0)) {\\n oldRegistrar.claim(msg.sender);\\n }\\n }\\n\\n modifier authorised(address addr) {\\n require(\\n addr == msg.sender ||\\n controllers[msg.sender] ||\\n ens.isApprovedForAll(addr, msg.sender) ||\\n ownsContract(addr),\\n \\\"ReverseRegistrar: Caller is not a controller or authorised by address or the address itself\\\"\\n );\\n _;\\n }\\n\\n function setDefaultResolver(address resolver) public override onlyOwner {\\n require(\\n address(resolver) != address(0),\\n \\\"ReverseRegistrar: Resolver address must not be 0\\\"\\n );\\n defaultResolver = NameResolver(resolver);\\n emit DefaultResolverChanged(NameResolver(resolver));\\n }\\n\\n /**\\n * @dev Transfers ownership of the reverse ENS record associated with the\\n * calling account.\\n * @param owner The address to set as the owner of the reverse record in ENS.\\n * @return The ENS node hash of the reverse record.\\n */\\n function claim(address owner) public override returns (bytes32) {\\n return claimForAddr(msg.sender, owner, address(defaultResolver));\\n }\\n\\n /**\\n * @dev Transfers ownership of the reverse ENS record associated with the\\n * calling account.\\n * @param addr The reverse record to set\\n * @param owner The address to set as the owner of the reverse record in ENS.\\n * @param resolver The resolver of the reverse node\\n * @return The ENS node hash of the reverse record.\\n */\\n function claimForAddr(\\n address addr,\\n address owner,\\n address resolver\\n ) public override authorised(addr) returns (bytes32) {\\n bytes32 labelHash = sha3HexAddress(addr);\\n bytes32 reverseNode = keccak256(\\n abi.encodePacked(ADDR_REVERSE_NODE, labelHash)\\n );\\n emit ReverseClaimed(addr, reverseNode);\\n ens.setSubnodeRecord(ADDR_REVERSE_NODE, labelHash, owner, resolver, 0);\\n return reverseNode;\\n }\\n\\n /**\\n * @dev Transfers ownership of the reverse ENS record associated with the\\n * calling account.\\n * @param owner The address to set as the owner of the reverse record in ENS.\\n * @param resolver The address of the resolver to set; 0 to leave unchanged.\\n * @return The ENS node hash of the reverse record.\\n */\\n function claimWithResolver(\\n address owner,\\n address resolver\\n ) public override returns (bytes32) {\\n return claimForAddr(msg.sender, owner, resolver);\\n }\\n\\n /**\\n * @dev Sets the `name()` record for the reverse ENS record associated with\\n * the calling account. First updates the resolver to the default reverse\\n * resolver if necessary.\\n * @param name The name to set for this address.\\n * @return The ENS node hash of the reverse record.\\n */\\n function setName(string memory name) public override returns (bytes32) {\\n return\\n setNameForAddr(\\n msg.sender,\\n msg.sender,\\n address(defaultResolver),\\n name\\n );\\n }\\n\\n /**\\n * @dev Sets the `name()` record for the reverse ENS record associated with\\n * the account provided. Updates the resolver to a designated resolver\\n * Only callable by controllers and authorised users\\n * @param addr The reverse record to set\\n * @param owner The owner of the reverse node\\n * @param resolver The resolver of the reverse node\\n * @param name The name to set for this address.\\n * @return The ENS node hash of the reverse record.\\n */\\n function setNameForAddr(\\n address addr,\\n address owner,\\n address resolver,\\n string memory name\\n ) public override returns (bytes32) {\\n bytes32 node = claimForAddr(addr, owner, resolver);\\n NameResolver(resolver).setName(node, name);\\n return node;\\n }\\n\\n /**\\n * @dev Returns the node hash for a given account's reverse records.\\n * @param addr The address to hash\\n * @return The ENS node hash.\\n */\\n function node(address addr) public pure override returns (bytes32) {\\n return\\n keccak256(\\n abi.encodePacked(ADDR_REVERSE_NODE, sha3HexAddress(addr))\\n );\\n }\\n\\n /**\\n * @dev An optimised function to compute the sha3 of the lower-case\\n * hexadecimal representation of an Ethereum address.\\n * @param addr The address to hash\\n * @return ret The SHA3 hash of the lower-case hexadecimal encoding of the\\n * input address.\\n */\\n function sha3HexAddress(address addr) private pure returns (bytes32 ret) {\\n assembly {\\n for {\\n let i := 40\\n } gt(i, 0) {\\n\\n } {\\n i := sub(i, 1)\\n mstore8(i, byte(and(addr, 0xf), lookup))\\n addr := div(addr, 0x10)\\n i := sub(i, 1)\\n mstore8(i, byte(and(addr, 0xf), lookup))\\n addr := div(addr, 0x10)\\n }\\n\\n ret := keccak256(0, 40)\\n }\\n }\\n\\n function ownsContract(address addr) internal view returns (bool) {\\n try Ownable(addr).owner() returns (address owner) {\\n return owner == msg.sender;\\n } catch {\\n return false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xd57d28e5791b4b44650a00f5ef6c725af53698ec33faeeaa3591f0dbd939559a\"},\"contracts/root/Controllable.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\n\\ncontract Controllable is Ownable {\\n mapping(address => bool) public controllers;\\n\\n event ControllerChanged(address indexed controller, bool enabled);\\n\\n modifier onlyController() {\\n require(\\n controllers[msg.sender],\\n \\\"Controllable: Caller is not a controller\\\"\\n );\\n _;\\n }\\n\\n function setController(address controller, bool enabled) public onlyOwner {\\n controllers[controller] = enabled;\\n emit ControllerChanged(controller, enabled);\\n }\\n}\\n\",\"keccak256\":\"0xb19b8c0fafe9ca2b4bf8aaafee486fa31437672e1e1977bdf84bfe03464969db\"},\"contracts/utils/ERC20Recoverable.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.17 <0.9.0;\\n\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n @notice Contract is used to recover ERC20 tokens sent to the contract by mistake.\\n */\\n\\ncontract ERC20Recoverable is Ownable {\\n /**\\n @notice Recover ERC20 tokens sent to the contract by mistake.\\n @dev The contract is Ownable and only the owner can call the recover function.\\n @param _to The address to send the tokens to.\\n@param _token The address of the ERC20 token to recover\\n @param _amount The amount of tokens to recover.\\n */\\n function recoverFunds(\\n address _token,\\n address _to,\\n uint256 _amount\\n ) external onlyOwner {\\n IERC20(_token).transfer(_to, _amount);\\n }\\n}\\n\",\"keccak256\":\"0x793a38091e1f81499a29ddba82c2b2f3cdd07071b81a832886e8e02a45ff352a\",\"license\":\"MIT\"},\"contracts/wrapper/IMetadataService.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\ninterface IMetadataService {\\n function uri(uint256) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xb3f1cf6df01ed7b15e5f2318f6823afbdb586ca38c2124c67955c645647ae9a2\",\"license\":\"MIT\"},\"contracts/wrapper/INameWrapper.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\nimport \\\"../registry/ENS.sol\\\";\\nimport \\\"../ethregistrar/IBaseRegistrar.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC1155/IERC1155.sol\\\";\\nimport \\\"./IMetadataService.sol\\\";\\nimport \\\"./INameWrapperUpgrade.sol\\\";\\n\\nuint32 constant CANNOT_UNWRAP = 1;\\nuint32 constant CANNOT_BURN_FUSES = 2;\\nuint32 constant CANNOT_TRANSFER = 4;\\nuint32 constant CANNOT_SET_RESOLVER = 8;\\nuint32 constant CANNOT_SET_TTL = 16;\\nuint32 constant CANNOT_CREATE_SUBDOMAIN = 32;\\nuint32 constant CANNOT_APPROVE = 64;\\n//uint16 reserved for parent controlled fuses from bit 17 to bit 32\\nuint32 constant PARENT_CANNOT_CONTROL = 1 << 16;\\nuint32 constant IS_DOT_ETH = 1 << 17;\\nuint32 constant CAN_EXTEND_EXPIRY = 1 << 18;\\nuint32 constant CAN_DO_EVERYTHING = 0;\\nuint32 constant PARENT_CONTROLLED_FUSES = 0xFFFF0000;\\n// all fuses apart from IS_DOT_ETH\\nuint32 constant USER_SETTABLE_FUSES = 0xFFFDFFFF;\\n\\ninterface INameWrapper is IERC1155 {\\n event NameWrapped(\\n bytes32 indexed node,\\n bytes name,\\n address owner,\\n uint32 fuses,\\n uint64 expiry\\n );\\n\\n event NameUnwrapped(bytes32 indexed node, address owner);\\n\\n event FusesSet(bytes32 indexed node, uint32 fuses);\\n event ExpiryExtended(bytes32 indexed node, uint64 expiry);\\n\\n function ens() external view returns (ENS);\\n\\n function registrar() external view returns (IBaseRegistrar);\\n\\n function metadataService() external view returns (IMetadataService);\\n\\n function names(bytes32) external view returns (bytes memory);\\n\\n function name() external view returns (string memory);\\n\\n function upgradeContract() external view returns (INameWrapperUpgrade);\\n\\n function supportsInterface(bytes4 interfaceID) external view returns (bool);\\n\\n function wrap(\\n bytes calldata name,\\n address wrappedOwner,\\n address resolver\\n ) external;\\n\\n function wrapETH2LD(\\n string calldata label,\\n address wrappedOwner,\\n uint16 ownerControlledFuses,\\n address resolver\\n ) external returns (uint64 expires);\\n\\n function registerAndWrapETH2LD(\\n string calldata label,\\n address wrappedOwner,\\n uint256 duration,\\n address resolver,\\n uint16 ownerControlledFuses\\n ) external returns (uint256 registrarExpiry);\\n\\n function renew(\\n uint256 labelHash,\\n uint256 duration\\n ) external returns (uint256 expires);\\n\\n function unwrap(bytes32 node, bytes32 label, address owner) external;\\n\\n function unwrapETH2LD(\\n bytes32 label,\\n address newRegistrant,\\n address newController\\n ) external;\\n\\n function upgrade(bytes calldata name, bytes calldata extraData) external;\\n\\n function setFuses(\\n bytes32 node,\\n uint16 ownerControlledFuses\\n ) external returns (uint32 newFuses);\\n\\n function setChildFuses(\\n bytes32 parentNode,\\n bytes32 labelhash,\\n uint32 fuses,\\n uint64 expiry\\n ) external;\\n\\n function setSubnodeRecord(\\n bytes32 node,\\n string calldata label,\\n address owner,\\n address resolver,\\n uint64 ttl,\\n uint32 fuses,\\n uint64 expiry\\n ) external returns (bytes32);\\n\\n function setRecord(\\n bytes32 node,\\n address owner,\\n address resolver,\\n uint64 ttl\\n ) external;\\n\\n function setSubnodeOwner(\\n bytes32 node,\\n string calldata label,\\n address newOwner,\\n uint32 fuses,\\n uint64 expiry\\n ) external returns (bytes32);\\n\\n function extendExpiry(\\n bytes32 node,\\n bytes32 labelhash,\\n uint64 expiry\\n ) external returns (uint64);\\n\\n function canModifyName(\\n bytes32 node,\\n address addr\\n ) external view returns (bool);\\n\\n function setResolver(bytes32 node, address resolver) external;\\n\\n function setTTL(bytes32 node, uint64 ttl) external;\\n\\n function ownerOf(uint256 id) external view returns (address owner);\\n\\n function approve(address to, uint256 tokenId) external;\\n\\n function getApproved(uint256 tokenId) external view returns (address);\\n\\n function getData(\\n uint256 id\\n ) external view returns (address, uint32, uint64);\\n\\n function setMetadataService(IMetadataService _metadataService) external;\\n\\n function uri(uint256 tokenId) external view returns (string memory);\\n\\n function setUpgradeContract(INameWrapperUpgrade _upgradeAddress) external;\\n\\n function allFusesBurned(\\n bytes32 node,\\n uint32 fuseMask\\n ) external view returns (bool);\\n\\n function isWrapped(bytes32) external view returns (bool);\\n\\n function isWrapped(bytes32, bytes32) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x70310eb67146d7290731c31841399640ac3b6a949eadc6598bc150123d185c57\",\"license\":\"MIT\"},\"contracts/wrapper/INameWrapperUpgrade.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\ninterface INameWrapperUpgrade {\\n function wrapFromUpgrade(\\n bytes calldata name,\\n address wrappedOwner,\\n uint32 fuses,\\n uint64 expiry,\\n address approved,\\n bytes calldata extraData\\n ) external;\\n}\\n\",\"keccak256\":\"0x42e0cec6cd9d1a62d51d45b678f69d3e4ad5555e659b197e41257b308346bb8a\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": {}, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 13604, + "contract": "contracts/ethregistrar/StaticBulkRenewal.sol:StaticBulkRenewal", + "label": "controller", + "offset": 0, + "slot": "0", + "type": "t_contract(ETHRegistrarController)12258" + } + ], + "types": { + "t_contract(ETHRegistrarController)12258": { + "encoding": "inplace", + "label": "contract ETHRegistrarController", + "numberOfBytes": "20" + } + } + } +} \ No newline at end of file diff --git a/deployments/sepolia/UniversalResolver.json b/deployments/sepolia/UniversalResolver.json new file mode 100644 index 00000000..d9896544 --- /dev/null +++ b/deployments/sepolia/UniversalResolver.json @@ -0,0 +1,671 @@ +{ + "address": "0x21B000Fd62a880b2125A61e36a284BB757b76025", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "_registry", + "type": "address" + }, + { + "internalType": "string[]", + "name": "_urls", + "type": "string[]" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "internalType": "string[]", + "name": "urls", + "type": "string[]" + }, + { + "internalType": "bytes", + "name": "callData", + "type": "bytes" + }, + { + "internalType": "bytes4", + "name": "callbackFunction", + "type": "bytes4" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "name": "OffchainLookup", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "string[]", + "name": "gateways", + "type": "string[]" + }, + { + "internalType": "bytes4", + "name": "callbackFunction", + "type": "bytes4" + }, + { + "internalType": "bytes", + "name": "metaData", + "type": "bytes" + } + ], + "name": "_resolveSingle", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "batchGatewayURLs", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + } + ], + "name": "findResolver", + "outputs": [ + { + "internalType": "contract Resolver", + "name": "", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "registry", + "outputs": [ + { + "internalType": "contract ENS", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + }, + { + "internalType": "string[]", + "name": "gateways", + "type": "string[]" + } + ], + "name": "resolve", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + }, + { + "internalType": "bytes[]", + "name": "data", + "type": "bytes[]" + } + ], + "name": "resolve", + "outputs": [ + { + "internalType": "bytes[]", + "name": "", + "type": "bytes[]" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + }, + { + "internalType": "bytes[]", + "name": "data", + "type": "bytes[]" + }, + { + "internalType": "string[]", + "name": "gateways", + "type": "string[]" + } + ], + "name": "resolve", + "outputs": [ + { + "internalType": "bytes[]", + "name": "", + "type": "bytes[]" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "name", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "resolve", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "response", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "name": "resolveCallback", + "outputs": [ + { + "internalType": "bytes[]", + "name": "", + "type": "bytes[]" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "response", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "name": "resolveSingleCallback", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "reverseName", + "type": "bytes" + }, + { + "internalType": "string[]", + "name": "gateways", + "type": "string[]" + } + ], + "name": "reverse", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "reverseName", + "type": "bytes" + } + ], + "name": "reverse", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "response", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "name": "reverseCallback", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string[]", + "name": "_urls", + "type": "string[]" + } + ], + "name": "setGatewayURLs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "transactionHash": "0x5a92cb82bbccd88be96a14858d3b4d957ac7bf3b32e19f4825d8d8e35a1e8839", + "receipt": { + "to": null, + "from": "0x4Fe4e666Be5752f1FdD210F4Ab5DE2Cc26e3E0e8", + "contractAddress": "0x21B000Fd62a880b2125A61e36a284BB757b76025", + "transactionIndex": 47, + "gasUsed": "3039128", + "logsBloom": "0x00000000000000002000000000000000000000000000200000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000020000000000000000000840000000000000000000000000000000400000000000000000000000000000000000000400000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x3bb3be3e3e815561cf21b3d8a6785aff1bad9120c0dba1b7253334a484f84acb", + "transactionHash": "0x5a92cb82bbccd88be96a14858d3b4d957ac7bf3b32e19f4825d8d8e35a1e8839", + "logs": [ + { + "transactionIndex": 47, + "blockNumber": 3914906, + "transactionHash": "0x5a92cb82bbccd88be96a14858d3b4d957ac7bf3b32e19f4825d8d8e35a1e8839", + "address": "0x21B000Fd62a880b2125A61e36a284BB757b76025", + "topics": [ + "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000004fe4e666be5752f1fdd210f4ab5de2cc26e3e0e8" + ], + "data": "0x", + "logIndex": 62, + "blockHash": "0x3bb3be3e3e815561cf21b3d8a6785aff1bad9120c0dba1b7253334a484f84acb" + } + ], + "blockNumber": 3914906, + "cumulativeGasUsed": "21618601", + "status": 1, + "byzantium": true + }, + "args": [ + "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", + [ + "https://universal-offchain-unwrapper.ens-cf.workers.dev/" + ] + ], + "numDeployments": 1, + "solcInputHash": "e04502f562d98d0455f6c1c453418cdd", + "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_registry\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"_urls\",\"type\":\"string[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"urls\",\"type\":\"string[]\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"bytes4\",\"name\":\"callbackFunction\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"OffchainLookup\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"string[]\",\"name\":\"gateways\",\"type\":\"string[]\"},{\"internalType\":\"bytes4\",\"name\":\"callbackFunction\",\"type\":\"bytes4\"},{\"internalType\":\"bytes\",\"name\":\"metaData\",\"type\":\"bytes\"}],\"name\":\"_resolveSingle\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"batchGatewayURLs\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"}],\"name\":\"findResolver\",\"outputs\":[{\"internalType\":\"contract Resolver\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"contract ENS\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"string[]\",\"name\":\"gateways\",\"type\":\"string[]\"}],\"name\":\"resolve\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"resolve\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"},{\"internalType\":\"string[]\",\"name\":\"gateways\",\"type\":\"string[]\"}],\"name\":\"resolve\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"name\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"resolve\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"response\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"resolveCallback\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"response\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"resolveSingleCallback\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"reverseName\",\"type\":\"bytes\"},{\"internalType\":\"string[]\",\"name\":\"gateways\",\"type\":\"string[]\"}],\"name\":\"reverse\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"reverseName\",\"type\":\"bytes\"}],\"name\":\"reverse\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"response\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"reverseCallback\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"_urls\",\"type\":\"string[]\"}],\"name\":\"setGatewayURLs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"findResolver(bytes)\":{\"details\":\"Finds a resolver by recursively querying the registry, starting at the longest name and progressively removing labels until it finds a result.\",\"params\":{\"name\":\"The name to resolve, in DNS-encoded and normalised form.\"},\"returns\":{\"_0\":\"resolver The Resolver responsible for this name.\",\"_1\":\"namehash The namehash of the full name.\",\"_2\":\"finalOffset The offset of the first label with a resolver.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"resolve(bytes,bytes)\":{\"details\":\"Performs ENS name resolution for the supplied name and resolution data.\",\"params\":{\"data\":\"The resolution data, as specified in ENSIP-10.\",\"name\":\"The name to resolve, in normalised and DNS-encoded form.\"},\"returns\":{\"_0\":\"The result of resolving the name.\"}},\"reverse(bytes,string[])\":{\"details\":\"Performs ENS name reverse resolution for the supplied reverse name.\",\"params\":{\"reverseName\":\"The reverse name to resolve, in normalised and DNS-encoded form. e.g. b6E040C9ECAaE172a89bD561c5F73e1C48d28cd9.addr.reverse\"},\"returns\":{\"_0\":\"The resolved name, the resolved address, the reverse resolver address, and the resolver address.\"}},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"The Universal Resolver is a contract that handles the work of resolving a name entirely onchain, making it possible to make a single smart contract call to resolve an ENS name.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/utils/UniversalResolver.sol\":\"UniversalResolver\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../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 * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\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 require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _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 require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\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\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf96f969e24029d43d0df89e59d365f277021dac62b48e1c1e3ebe0acdd7f1ca1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\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\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 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 *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\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[EIP 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\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/registry/ENS.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\ninterface ENS {\\n // Logged when the owner of a node assigns a new owner to a subnode.\\n event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);\\n\\n // Logged when the owner of a node transfers ownership to a new account.\\n event Transfer(bytes32 indexed node, address owner);\\n\\n // Logged when the resolver for a node changes.\\n event NewResolver(bytes32 indexed node, address resolver);\\n\\n // Logged when the TTL of a node changes\\n event NewTTL(bytes32 indexed node, uint64 ttl);\\n\\n // Logged when an operator is added or removed.\\n event ApprovalForAll(\\n address indexed owner,\\n address indexed operator,\\n bool approved\\n );\\n\\n function setRecord(\\n bytes32 node,\\n address owner,\\n address resolver,\\n uint64 ttl\\n ) external;\\n\\n function setSubnodeRecord(\\n bytes32 node,\\n bytes32 label,\\n address owner,\\n address resolver,\\n uint64 ttl\\n ) external;\\n\\n function setSubnodeOwner(\\n bytes32 node,\\n bytes32 label,\\n address owner\\n ) external returns (bytes32);\\n\\n function setResolver(bytes32 node, address resolver) external;\\n\\n function setOwner(bytes32 node, address owner) external;\\n\\n function setTTL(bytes32 node, uint64 ttl) external;\\n\\n function setApprovalForAll(address operator, bool approved) external;\\n\\n function owner(bytes32 node) external view returns (address);\\n\\n function resolver(bytes32 node) external view returns (address);\\n\\n function ttl(bytes32 node) external view returns (uint64);\\n\\n function recordExists(bytes32 node) external view returns (bool);\\n\\n function isApprovedForAll(\\n address owner,\\n address operator\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x7cb1158c7d268b63de1468e28e2711b28d686e2628ddb22da2149cd93ddeafda\"},\"contracts/resolvers/Resolver.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\nimport \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport \\\"./profiles/IABIResolver.sol\\\";\\nimport \\\"./profiles/IAddressResolver.sol\\\";\\nimport \\\"./profiles/IAddrResolver.sol\\\";\\nimport \\\"./profiles/IContentHashResolver.sol\\\";\\nimport \\\"./profiles/IDNSRecordResolver.sol\\\";\\nimport \\\"./profiles/IDNSZoneResolver.sol\\\";\\nimport \\\"./profiles/IInterfaceResolver.sol\\\";\\nimport \\\"./profiles/INameResolver.sol\\\";\\nimport \\\"./profiles/IPubkeyResolver.sol\\\";\\nimport \\\"./profiles/ITextResolver.sol\\\";\\nimport \\\"./profiles/IExtendedResolver.sol\\\";\\n\\n/**\\n * A generic resolver interface which includes all the functions including the ones deprecated\\n */\\ninterface Resolver is\\n IERC165,\\n IABIResolver,\\n IAddressResolver,\\n IAddrResolver,\\n IContentHashResolver,\\n IDNSRecordResolver,\\n IDNSZoneResolver,\\n IInterfaceResolver,\\n INameResolver,\\n IPubkeyResolver,\\n ITextResolver,\\n IExtendedResolver\\n{\\n /* Deprecated events */\\n event ContentChanged(bytes32 indexed node, bytes32 hash);\\n\\n function setApprovalForAll(address, bool) external;\\n\\n function approve(bytes32 node, address delegate, bool approved) external;\\n\\n function isApprovedForAll(address account, address operator) external;\\n\\n function isApprovedFor(\\n address owner,\\n bytes32 node,\\n address delegate\\n ) external;\\n\\n function setABI(\\n bytes32 node,\\n uint256 contentType,\\n bytes calldata data\\n ) external;\\n\\n function setAddr(bytes32 node, address addr) external;\\n\\n function setAddr(bytes32 node, uint256 coinType, bytes calldata a) external;\\n\\n function setContenthash(bytes32 node, bytes calldata hash) external;\\n\\n function setDnsrr(bytes32 node, bytes calldata data) external;\\n\\n function setName(bytes32 node, string calldata _name) external;\\n\\n function setPubkey(bytes32 node, bytes32 x, bytes32 y) external;\\n\\n function setText(\\n bytes32 node,\\n string calldata key,\\n string calldata value\\n ) external;\\n\\n function setInterface(\\n bytes32 node,\\n bytes4 interfaceID,\\n address implementer\\n ) external;\\n\\n function multicall(\\n bytes[] calldata data\\n ) external returns (bytes[] memory results);\\n\\n function multicallWithNodeCheck(\\n bytes32 nodehash,\\n bytes[] calldata data\\n ) external returns (bytes[] memory results);\\n\\n /* Deprecated functions */\\n function content(bytes32 node) external view returns (bytes32);\\n\\n function multihash(bytes32 node) external view returns (bytes memory);\\n\\n function setContent(bytes32 node, bytes32 hash) external;\\n\\n function setMultihash(bytes32 node, bytes calldata hash) external;\\n}\\n\",\"keccak256\":\"0xfc77ab6b7c59c3ebfe1c720bdebf9b08c2488ff7ac9501a9aa056c5d6d5b50c5\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IABIResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IABIResolver {\\n event ABIChanged(bytes32 indexed node, uint256 indexed contentType);\\n\\n /**\\n * Returns the ABI associated with an ENS node.\\n * Defined in EIP205.\\n * @param node The ENS node to query\\n * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.\\n * @return contentType The content type of the return value\\n * @return data The ABI data\\n */\\n function ABI(\\n bytes32 node,\\n uint256 contentTypes\\n ) external view returns (uint256, bytes memory);\\n}\\n\",\"keccak256\":\"0x85b373d02d19374fe570af407f459768285704bf7f30ab17c30eabfb5a10e4c3\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IAddrResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\n/**\\n * Interface for the legacy (ETH-only) addr function.\\n */\\ninterface IAddrResolver {\\n event AddrChanged(bytes32 indexed node, address a);\\n\\n /**\\n * Returns the address associated with an ENS node.\\n * @param node The ENS node to query.\\n * @return The associated address.\\n */\\n function addr(bytes32 node) external view returns (address payable);\\n}\\n\",\"keccak256\":\"0x2ad7f2fc60ebe0f93745fe70247f6a854f66af732483fda2a3c5e055614445e8\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IAddressResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\n/**\\n * Interface for the new (multicoin) addr function.\\n */\\ninterface IAddressResolver {\\n event AddressChanged(\\n bytes32 indexed node,\\n uint256 coinType,\\n bytes newAddress\\n );\\n\\n function addr(\\n bytes32 node,\\n uint256 coinType\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0x411447c1e90c51e09702815a85ec725ffbbe37cf96e8cc4d2a8bd4ad8a59d73e\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IContentHashResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IContentHashResolver {\\n event ContenthashChanged(bytes32 indexed node, bytes hash);\\n\\n /**\\n * Returns the contenthash associated with an ENS node.\\n * @param node The ENS node to query.\\n * @return The associated contenthash.\\n */\\n function contenthash(bytes32 node) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xd95cd77684ba5752c428d7dceb4ecc6506ac94f4fbb910489637eb68dcd8e366\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IDNSRecordResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IDNSRecordResolver {\\n // DNSRecordChanged is emitted whenever a given node/name/resource's RRSET is updated.\\n event DNSRecordChanged(\\n bytes32 indexed node,\\n bytes name,\\n uint16 resource,\\n bytes record\\n );\\n // DNSRecordDeleted is emitted whenever a given node/name/resource's RRSET is deleted.\\n event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource);\\n\\n /**\\n * Obtain a DNS record.\\n * @param node the namehash of the node for which to fetch the record\\n * @param name the keccak-256 hash of the fully-qualified name for which to fetch the record\\n * @param resource the ID of the resource as per https://en.wikipedia.org/wiki/List_of_DNS_record_types\\n * @return the DNS record in wire format if present, otherwise empty\\n */\\n function dnsRecord(\\n bytes32 node,\\n bytes32 name,\\n uint16 resource\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xcfa52200edd337f2c6c5bf402352600584da033b21323603e53de33051a3e25d\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IDNSZoneResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IDNSZoneResolver {\\n // DNSZonehashChanged is emitted whenever a given node's zone hash is updated.\\n event DNSZonehashChanged(\\n bytes32 indexed node,\\n bytes lastzonehash,\\n bytes zonehash\\n );\\n\\n /**\\n * zonehash obtains the hash for the zone.\\n * @param node The ENS node to query.\\n * @return The associated contenthash.\\n */\\n function zonehash(bytes32 node) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0xca1b3a16e7005533f2800a3e66fcdccf7c574deac7913d8c810f40aec1d58dc0\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IExtendedResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\ninterface IExtendedResolver {\\n function resolve(\\n bytes memory name,\\n bytes memory data\\n ) external view returns (bytes memory);\\n}\\n\",\"keccak256\":\"0x5d81521cfae7d9a4475d27533cd8ed0d3475d369eb0674fd90ffbdbdf292faa3\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IInterfaceResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IInterfaceResolver {\\n event InterfaceChanged(\\n bytes32 indexed node,\\n bytes4 indexed interfaceID,\\n address implementer\\n );\\n\\n /**\\n * Returns the address of a contract that implements the specified interface for this name.\\n * If an implementer has not been set for this interfaceID and name, the resolver will query\\n * the contract at `addr()`. If `addr()` is set, a contract exists at that address, and that\\n * contract implements EIP165 and returns `true` for the specified interfaceID, its address\\n * will be returned.\\n * @param node The ENS node to query.\\n * @param interfaceID The EIP 165 interface ID to check for.\\n * @return The address that implements this interface, or 0 if the interface is unsupported.\\n */\\n function interfaceImplementer(\\n bytes32 node,\\n bytes4 interfaceID\\n ) external view returns (address);\\n}\\n\",\"keccak256\":\"0x390321fb58f7b927df9562450981e74b4be3907e7c09df321fd3b7409b63ae28\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/INameResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface INameResolver {\\n event NameChanged(bytes32 indexed node, string name);\\n\\n /**\\n * Returns the name associated with an ENS node, for reverse records.\\n * Defined in EIP181.\\n * @param node The ENS node to query.\\n * @return The associated name.\\n */\\n function name(bytes32 node) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x9ec392b612447b1acbdc01114f2da2837a658d3f3157f60a99c5269f0b623346\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/IPubkeyResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface IPubkeyResolver {\\n event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);\\n\\n /**\\n * Returns the SECP256k1 public key associated with an ENS node.\\n * Defined in EIP 619.\\n * @param node The ENS node to query\\n * @return x The X coordinate of the curve point for the public key.\\n * @return y The Y coordinate of the curve point for the public key.\\n */\\n function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y);\\n}\\n\",\"keccak256\":\"0x69748947093dd2fda9ddcebd0adf19a6d1e7600df1d4b1462a0417156caddca7\",\"license\":\"MIT\"},\"contracts/resolvers/profiles/ITextResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.4;\\n\\ninterface ITextResolver {\\n event TextChanged(\\n bytes32 indexed node,\\n string indexed indexedKey,\\n string key,\\n string value\\n );\\n\\n /**\\n * Returns the text data associated with an ENS node and key.\\n * @param node The ENS node to query.\\n * @param key The text data key to query.\\n * @return The associated text data.\\n */\\n function text(\\n bytes32 node,\\n string calldata key\\n ) external view returns (string memory);\\n}\\n\",\"keccak256\":\"0x7c5debb3c42cd9f5de2274ea7aa053f238608314b62db441c40e31cea2543fd5\",\"license\":\"MIT\"},\"contracts/utils/HexUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\nlibrary HexUtils {\\n /**\\n * @dev Attempts to parse bytes32 from a hex string\\n * @param str The string to parse\\n * @param idx The offset to start parsing at\\n * @param lastIdx The (exclusive) last index in `str` to consider. Use `str.length` to scan the whole string.\\n */\\n function hexStringToBytes32(\\n bytes memory str,\\n uint256 idx,\\n uint256 lastIdx\\n ) internal pure returns (bytes32 r, bool valid) {\\n valid = true;\\n assembly {\\n // check that the index to read to is not past the end of the string\\n if gt(lastIdx, mload(str)) {\\n revert(0, 0)\\n }\\n\\n function getHex(c) -> ascii {\\n // chars 48-57: 0-9\\n if and(gt(c, 47), lt(c, 58)) {\\n ascii := sub(c, 48)\\n leave\\n }\\n // chars 65-70: A-F\\n if and(gt(c, 64), lt(c, 71)) {\\n ascii := add(sub(c, 65), 10)\\n leave\\n }\\n // chars 97-102: a-f\\n if and(gt(c, 96), lt(c, 103)) {\\n ascii := add(sub(c, 97), 10)\\n leave\\n }\\n // invalid char\\n ascii := 0xff\\n }\\n\\n let ptr := add(str, 32)\\n for {\\n let i := idx\\n } lt(i, lastIdx) {\\n i := add(i, 2)\\n } {\\n let byte1 := getHex(byte(0, mload(add(ptr, i))))\\n let byte2 := getHex(byte(0, mload(add(ptr, add(i, 1)))))\\n // if either byte is invalid, set invalid and break loop\\n if or(eq(byte1, 0xff), eq(byte2, 0xff)) {\\n valid := false\\n break\\n }\\n let combined := or(shl(4, byte1), byte2)\\n r := or(shl(8, r), combined)\\n }\\n }\\n }\\n\\n /**\\n * @dev Attempts to parse an address from a hex string\\n * @param str The string to parse\\n * @param idx The offset to start parsing at\\n * @param lastIdx The (exclusive) last index in `str` to consider. Use `str.length` to scan the whole string.\\n */\\n function hexToAddress(\\n bytes memory str,\\n uint256 idx,\\n uint256 lastIdx\\n ) internal pure returns (address, bool) {\\n if (lastIdx - idx < 40) return (address(0x0), false);\\n (bytes32 r, bool valid) = hexStringToBytes32(str, idx, lastIdx);\\n return (address(uint160(uint256(r))), valid);\\n }\\n}\\n\",\"keccak256\":\"0xcae20ad72181f47dfe7fba7d88e8d902a01576b16e93362878e726989d6cfb4d\",\"license\":\"MIT\"},\"contracts/utils/LowLevelCallUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.13;\\n\\nimport {Address} from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\n\\nlibrary LowLevelCallUtils {\\n using Address for address;\\n\\n /**\\n * @dev Makes a static call to the specified `target` with `data`. Return data can be fetched with\\n * `returnDataSize` and `readReturnData`.\\n * @param target The address to staticcall.\\n * @param data The data to pass to the call.\\n * @return success True if the call succeeded, or false if it reverts.\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data\\n ) internal view returns (bool success) {\\n require(\\n target.isContract(),\\n \\\"LowLevelCallUtils: static call to non-contract\\\"\\n );\\n assembly {\\n success := staticcall(\\n gas(),\\n target,\\n add(data, 32),\\n mload(data),\\n 0,\\n 0\\n )\\n }\\n }\\n\\n /**\\n * @dev Returns the size of the return data of the most recent external call.\\n */\\n function returnDataSize() internal pure returns (uint256 len) {\\n assembly {\\n len := returndatasize()\\n }\\n }\\n\\n /**\\n * @dev Reads return data from the most recent external call.\\n * @param offset Offset into the return data.\\n * @param length Number of bytes to return.\\n */\\n function readReturnData(\\n uint256 offset,\\n uint256 length\\n ) internal pure returns (bytes memory data) {\\n data = new bytes(length);\\n assembly {\\n returndatacopy(add(data, 32), offset, length)\\n }\\n }\\n\\n /**\\n * @dev Reverts with the return data from the most recent external call.\\n */\\n function propagateRevert() internal pure {\\n assembly {\\n returndatacopy(0, 0, returndatasize())\\n revert(0, returndatasize())\\n }\\n }\\n}\\n\",\"keccak256\":\"0x20d3d0d14fab6fc079f90d630a51bb8e274431ca929591ec8d62383ce946cb3a\",\"license\":\"MIT\"},\"contracts/utils/NameEncoder.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.13;\\n\\nimport {BytesUtils} from \\\"../wrapper/BytesUtils.sol\\\";\\n\\nlibrary NameEncoder {\\n using BytesUtils for bytes;\\n\\n function dnsEncodeName(\\n string memory name\\n ) internal pure returns (bytes memory dnsName, bytes32 node) {\\n uint8 labelLength = 0;\\n bytes memory bytesName = bytes(name);\\n uint256 length = bytesName.length;\\n dnsName = new bytes(length + 2);\\n node = 0;\\n if (length == 0) {\\n dnsName[0] = 0;\\n return (dnsName, node);\\n }\\n\\n // use unchecked to save gas since we check for an underflow\\n // and we check for the length before the loop\\n unchecked {\\n for (uint256 i = length - 1; i >= 0; i--) {\\n if (bytesName[i] == \\\".\\\") {\\n dnsName[i + 1] = bytes1(labelLength);\\n node = keccak256(\\n abi.encodePacked(\\n node,\\n bytesName.keccak(i + 1, labelLength)\\n )\\n );\\n labelLength = 0;\\n } else {\\n labelLength += 1;\\n dnsName[i + 1] = bytesName[i];\\n }\\n if (i == 0) {\\n break;\\n }\\n }\\n }\\n\\n node = keccak256(\\n abi.encodePacked(node, bytesName.keccak(0, labelLength))\\n );\\n\\n dnsName[0] = bytes1(labelLength);\\n return (dnsName, node);\\n }\\n}\\n\",\"keccak256\":\"0x63fd5f360cef8c9b8b8cfdff20d3f0e955b4c8ac7dfac758788223c61678aad1\",\"license\":\"MIT\"},\"contracts/utils/UniversalResolver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.17 <0.9.0;\\n\\nimport {ERC165} from \\\"@openzeppelin/contracts/utils/introspection/ERC165.sol\\\";\\nimport {Ownable} from \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport {Address} from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport {LowLevelCallUtils} from \\\"./LowLevelCallUtils.sol\\\";\\nimport {ENS} from \\\"../registry/ENS.sol\\\";\\nimport {IExtendedResolver} from \\\"../resolvers/profiles/IExtendedResolver.sol\\\";\\nimport {Resolver, INameResolver, IAddrResolver} from \\\"../resolvers/Resolver.sol\\\";\\nimport {NameEncoder} from \\\"./NameEncoder.sol\\\";\\nimport {BytesUtils} from \\\"../wrapper/BytesUtils.sol\\\";\\nimport {HexUtils} from \\\"./HexUtils.sol\\\";\\n\\nerror OffchainLookup(\\n address sender,\\n string[] urls,\\n bytes callData,\\n bytes4 callbackFunction,\\n bytes extraData\\n);\\n\\nstruct MulticallData {\\n bytes name;\\n bytes[] data;\\n string[] gateways;\\n bytes4 callbackFunction;\\n bool isWildcard;\\n address resolver;\\n bytes metaData;\\n bool[] failures;\\n}\\n\\nstruct OffchainLookupCallData {\\n address sender;\\n string[] urls;\\n bytes callData;\\n}\\n\\nstruct OffchainLookupExtraData {\\n bytes4 callbackFunction;\\n bytes data;\\n}\\n\\ninterface BatchGateway {\\n function query(\\n OffchainLookupCallData[] memory data\\n ) external returns (bool[] memory failures, bytes[] memory responses);\\n}\\n\\n/**\\n * The Universal Resolver is a contract that handles the work of resolving a name entirely onchain,\\n * making it possible to make a single smart contract call to resolve an ENS name.\\n */\\ncontract UniversalResolver is ERC165, Ownable {\\n using Address for address;\\n using NameEncoder for string;\\n using BytesUtils for bytes;\\n using HexUtils for bytes;\\n\\n string[] public batchGatewayURLs;\\n ENS public immutable registry;\\n\\n constructor(address _registry, string[] memory _urls) {\\n registry = ENS(_registry);\\n batchGatewayURLs = _urls;\\n }\\n\\n function setGatewayURLs(string[] memory _urls) public onlyOwner {\\n batchGatewayURLs = _urls;\\n }\\n\\n /**\\n * @dev Performs ENS name resolution for the supplied name and resolution data.\\n * @param name The name to resolve, in normalised and DNS-encoded form.\\n * @param data The resolution data, as specified in ENSIP-10.\\n * @return The result of resolving the name.\\n */\\n function resolve(\\n bytes calldata name,\\n bytes memory data\\n ) external view returns (bytes memory, address) {\\n return\\n _resolveSingle(\\n name,\\n data,\\n batchGatewayURLs,\\n this.resolveSingleCallback.selector,\\n \\\"\\\"\\n );\\n }\\n\\n function resolve(\\n bytes calldata name,\\n bytes[] memory data\\n ) external view returns (bytes[] memory, address) {\\n return resolve(name, data, batchGatewayURLs);\\n }\\n\\n function resolve(\\n bytes calldata name,\\n bytes memory data,\\n string[] memory gateways\\n ) external view returns (bytes memory, address) {\\n return\\n _resolveSingle(\\n name,\\n data,\\n gateways,\\n this.resolveSingleCallback.selector,\\n \\\"\\\"\\n );\\n }\\n\\n function resolve(\\n bytes calldata name,\\n bytes[] memory data,\\n string[] memory gateways\\n ) public view returns (bytes[] memory, address) {\\n return\\n _resolve(name, data, gateways, this.resolveCallback.selector, \\\"\\\");\\n }\\n\\n function _resolveSingle(\\n bytes calldata name,\\n bytes memory data,\\n string[] memory gateways,\\n bytes4 callbackFunction,\\n bytes memory metaData\\n ) public view returns (bytes memory, address) {\\n bytes[] memory dataArr = new bytes[](1);\\n dataArr[0] = data;\\n (bytes[] memory results, address resolver) = _resolve(\\n name,\\n dataArr,\\n gateways,\\n callbackFunction,\\n metaData\\n );\\n return (results[0], resolver);\\n }\\n\\n function _resolve(\\n bytes calldata name,\\n bytes[] memory data,\\n string[] memory gateways,\\n bytes4 callbackFunction,\\n bytes memory metaData\\n ) internal view returns (bytes[] memory results, address resolverAddress) {\\n (Resolver resolver, , uint256 finalOffset) = findResolver(name);\\n resolverAddress = address(resolver);\\n if (resolverAddress == address(0)) {\\n return (results, address(0));\\n }\\n\\n bool isWildcard = finalOffset != 0;\\n\\n results = _multicall(\\n MulticallData(\\n name,\\n data,\\n gateways,\\n callbackFunction,\\n isWildcard,\\n resolverAddress,\\n metaData,\\n new bool[](data.length)\\n )\\n );\\n }\\n\\n function reverse(\\n bytes calldata reverseName\\n ) external view returns (string memory, address, address, address) {\\n return reverse(reverseName, batchGatewayURLs);\\n }\\n\\n /**\\n * @dev Performs ENS name reverse resolution for the supplied reverse name.\\n * @param reverseName The reverse name to resolve, in normalised and DNS-encoded form. e.g. b6E040C9ECAaE172a89bD561c5F73e1C48d28cd9.addr.reverse\\n * @return The resolved name, the resolved address, the reverse resolver address, and the resolver address.\\n */\\n function reverse(\\n bytes calldata reverseName,\\n string[] memory gateways\\n ) public view returns (string memory, address, address, address) {\\n bytes memory encodedCall = abi.encodeCall(\\n INameResolver.name,\\n reverseName.namehash(0)\\n );\\n (\\n bytes memory resolvedReverseData,\\n address reverseResolverAddress\\n ) = _resolveSingle(\\n reverseName,\\n encodedCall,\\n gateways,\\n this.reverseCallback.selector,\\n \\\"\\\"\\n );\\n\\n return\\n getForwardDataFromReverse(\\n resolvedReverseData,\\n reverseResolverAddress,\\n gateways\\n );\\n }\\n\\n function getForwardDataFromReverse(\\n bytes memory resolvedReverseData,\\n address reverseResolverAddress,\\n string[] memory gateways\\n ) internal view returns (string memory, address, address, address) {\\n string memory resolvedName = abi.decode(resolvedReverseData, (string));\\n\\n (bytes memory encodedName, bytes32 namehash) = resolvedName\\n .dnsEncodeName();\\n\\n bytes memory encodedCall = abi.encodeCall(IAddrResolver.addr, namehash);\\n bytes memory metaData = abi.encode(\\n resolvedName,\\n reverseResolverAddress\\n );\\n (bytes memory resolvedData, address resolverAddress) = this\\n ._resolveSingle(\\n encodedName,\\n encodedCall,\\n gateways,\\n this.reverseCallback.selector,\\n metaData\\n );\\n\\n address resolvedAddress = abi.decode(resolvedData, (address));\\n\\n return (\\n resolvedName,\\n resolvedAddress,\\n reverseResolverAddress,\\n resolverAddress\\n );\\n }\\n\\n function resolveSingleCallback(\\n bytes calldata response,\\n bytes calldata extraData\\n ) external view returns (bytes memory, address) {\\n (bytes[] memory results, address resolver, , ) = _resolveCallback(\\n response,\\n extraData,\\n this.resolveSingleCallback.selector\\n );\\n return (results[0], resolver);\\n }\\n\\n function resolveCallback(\\n bytes calldata response,\\n bytes calldata extraData\\n ) external view returns (bytes[] memory, address) {\\n (bytes[] memory results, address resolver, , ) = _resolveCallback(\\n response,\\n extraData,\\n this.resolveCallback.selector\\n );\\n return (results, resolver);\\n }\\n\\n function reverseCallback(\\n bytes calldata response,\\n bytes calldata extraData\\n ) external view returns (string memory, address, address, address) {\\n (\\n bytes[] memory resolvedData,\\n address resolverAddress,\\n string[] memory gateways,\\n bytes memory metaData\\n ) = _resolveCallback(\\n response,\\n extraData,\\n this.reverseCallback.selector\\n );\\n\\n if (metaData.length > 0) {\\n (string memory resolvedName, address reverseResolverAddress) = abi\\n .decode(metaData, (string, address));\\n address resolvedAddress = abi.decode(resolvedData[0], (address));\\n return (\\n resolvedName,\\n resolvedAddress,\\n reverseResolverAddress,\\n resolverAddress\\n );\\n }\\n\\n return\\n getForwardDataFromReverse(\\n resolvedData[0],\\n resolverAddress,\\n gateways\\n );\\n }\\n\\n function supportsInterface(\\n bytes4 interfaceId\\n ) public view virtual override returns (bool) {\\n return\\n interfaceId == type(IExtendedResolver).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n function _resolveCallback(\\n bytes calldata response,\\n bytes calldata extraData,\\n bytes4 callbackFunction\\n )\\n internal\\n view\\n returns (bytes[] memory, address, string[] memory, bytes memory)\\n {\\n MulticallData memory multicallData;\\n multicallData.callbackFunction = callbackFunction;\\n (bool[] memory failures, bytes[] memory responses) = abi.decode(\\n response,\\n (bool[], bytes[])\\n );\\n OffchainLookupExtraData[] memory extraDatas;\\n (\\n multicallData.isWildcard,\\n multicallData.resolver,\\n multicallData.gateways,\\n multicallData.metaData,\\n extraDatas\\n ) = abi.decode(\\n extraData,\\n (bool, address, string[], bytes, OffchainLookupExtraData[])\\n );\\n require(responses.length <= extraDatas.length);\\n multicallData.data = new bytes[](extraDatas.length);\\n multicallData.failures = new bool[](extraDatas.length);\\n uint256 offchainCount = 0;\\n for (uint256 i = 0; i < extraDatas.length; i++) {\\n if (extraDatas[i].callbackFunction == bytes4(0)) {\\n // This call did not require an offchain lookup; use the previous input data.\\n multicallData.data[i] = extraDatas[i].data;\\n } else {\\n if (failures[offchainCount]) {\\n multicallData.failures[i] = true;\\n multicallData.data[i] = responses[offchainCount];\\n } else {\\n multicallData.data[i] = abi.encodeWithSelector(\\n extraDatas[i].callbackFunction,\\n responses[offchainCount],\\n extraDatas[i].data\\n );\\n }\\n offchainCount = offchainCount + 1;\\n }\\n }\\n\\n return (\\n _multicall(multicallData),\\n multicallData.resolver,\\n multicallData.gateways,\\n multicallData.metaData\\n );\\n }\\n\\n /**\\n * @dev Makes a call to `target` with `data`. If the call reverts with an `OffchainLookup` error, wraps\\n * the error with the data necessary to continue the request where it left off.\\n * @param target The address to call.\\n * @param data The data to call `target` with.\\n * @return offchain Whether the call reverted with an `OffchainLookup` error.\\n * @return returnData If `target` did not revert, contains the return data from the call to `target`. Otherwise, contains a `OffchainLookupCallData` struct.\\n * @return extraData If `target` did not revert, is empty. Otherwise, contains a `OffchainLookupExtraData` struct.\\n * @return result Whether the call succeeded.\\n */\\n function callWithOffchainLookupPropagation(\\n address target,\\n bytes memory data\\n )\\n internal\\n view\\n returns (\\n bool offchain,\\n bytes memory returnData,\\n OffchainLookupExtraData memory extraData,\\n bool result\\n )\\n {\\n result = LowLevelCallUtils.functionStaticCall(address(target), data);\\n uint256 size = LowLevelCallUtils.returnDataSize();\\n\\n if (result) {\\n return (\\n false,\\n LowLevelCallUtils.readReturnData(0, size),\\n extraData,\\n true\\n );\\n }\\n\\n // Failure\\n if (size >= 4) {\\n bytes memory errorId = LowLevelCallUtils.readReturnData(0, 4);\\n // Offchain lookup. Decode the revert message and create our own that nests it.\\n bytes memory revertData = LowLevelCallUtils.readReturnData(\\n 4,\\n size - 4\\n );\\n if (bytes4(errorId) == OffchainLookup.selector) {\\n (\\n address wrappedSender,\\n string[] memory wrappedUrls,\\n bytes memory wrappedCallData,\\n bytes4 wrappedCallbackFunction,\\n bytes memory wrappedExtraData\\n ) = abi.decode(\\n revertData,\\n (address, string[], bytes, bytes4, bytes)\\n );\\n if (wrappedSender == target) {\\n returnData = abi.encode(\\n OffchainLookupCallData(\\n wrappedSender,\\n wrappedUrls,\\n wrappedCallData\\n )\\n );\\n extraData = OffchainLookupExtraData(\\n wrappedCallbackFunction,\\n wrappedExtraData\\n );\\n return (true, returnData, extraData, false);\\n }\\n } else {\\n returnData = revertData;\\n return (false, returnData, extraData, false);\\n }\\n }\\n }\\n\\n /**\\n * @dev Finds a resolver by recursively querying the registry, starting at the longest name and progressively\\n * removing labels until it finds a result.\\n * @param name The name to resolve, in DNS-encoded and normalised form.\\n * @return resolver The Resolver responsible for this name.\\n * @return namehash The namehash of the full name.\\n * @return finalOffset The offset of the first label with a resolver.\\n */\\n function findResolver(\\n bytes calldata name\\n ) public view returns (Resolver, bytes32, uint256) {\\n (\\n address resolver,\\n bytes32 namehash,\\n uint256 finalOffset\\n ) = findResolver(name, 0);\\n return (Resolver(resolver), namehash, finalOffset);\\n }\\n\\n function findResolver(\\n bytes calldata name,\\n uint256 offset\\n ) internal view returns (address, bytes32, uint256) {\\n uint256 labelLength = uint256(uint8(name[offset]));\\n if (labelLength == 0) {\\n return (address(0), bytes32(0), offset);\\n }\\n uint256 nextLabel = offset + labelLength + 1;\\n bytes32 labelHash;\\n if (\\n labelLength == 66 &&\\n // 0x5b == '['\\n name[offset + 1] == 0x5b &&\\n // 0x5d == ']'\\n name[nextLabel - 1] == 0x5d\\n ) {\\n // Encrypted label\\n (labelHash, ) = bytes(name[offset + 2:nextLabel - 1])\\n .hexStringToBytes32(0, 64);\\n } else {\\n labelHash = keccak256(name[offset + 1:nextLabel]);\\n }\\n (\\n address parentresolver,\\n bytes32 parentnode,\\n uint256 parentoffset\\n ) = findResolver(name, nextLabel);\\n bytes32 node = keccak256(abi.encodePacked(parentnode, labelHash));\\n address resolver = registry.resolver(node);\\n if (resolver != address(0)) {\\n return (resolver, node, offset);\\n }\\n return (parentresolver, node, parentoffset);\\n }\\n\\n function _hasExtendedResolver(\\n address resolver\\n ) internal view returns (bool) {\\n try\\n Resolver(resolver).supportsInterface{gas: 50000}(\\n type(IExtendedResolver).interfaceId\\n )\\n returns (bool supported) {\\n return supported;\\n } catch {\\n return false;\\n }\\n }\\n\\n function _multicall(\\n MulticallData memory multicallData\\n ) internal view returns (bytes[] memory results) {\\n uint256 length = multicallData.data.length;\\n uint256 offchainCount = 0;\\n OffchainLookupCallData[]\\n memory callDatas = new OffchainLookupCallData[](length);\\n OffchainLookupExtraData[]\\n memory extraDatas = new OffchainLookupExtraData[](length);\\n results = new bytes[](length);\\n bool isCallback = multicallData.name.length == 0;\\n bool hasExtendedResolver = _hasExtendedResolver(multicallData.resolver);\\n\\n require(\\n !multicallData.isWildcard || hasExtendedResolver,\\n \\\"UniversalResolver: Wildcard on non-extended resolvers is not supported\\\"\\n );\\n\\n for (uint256 i = 0; i < length; i++) {\\n bytes memory item = multicallData.data[i];\\n bool failure = multicallData.failures[i];\\n if (failure) {\\n results[i] = item;\\n continue;\\n }\\n if (!isCallback && hasExtendedResolver) {\\n item = abi.encodeCall(\\n IExtendedResolver.resolve,\\n (multicallData.name, item)\\n );\\n }\\n (\\n bool offchain,\\n bytes memory returnData,\\n OffchainLookupExtraData memory extraData,\\n bool success\\n ) = callWithOffchainLookupPropagation(multicallData.resolver, item);\\n\\n if (offchain) {\\n callDatas[offchainCount] = abi.decode(\\n returnData,\\n (OffchainLookupCallData)\\n );\\n extraDatas[i] = extraData;\\n offchainCount += 1;\\n continue;\\n }\\n\\n if (success && hasExtendedResolver) {\\n // if this is a successful resolve() call, unwrap the result\\n returnData = abi.decode(returnData, (bytes));\\n }\\n results[i] = returnData;\\n extraDatas[i].data = multicallData.data[i];\\n }\\n\\n if (offchainCount == 0) {\\n return results;\\n }\\n\\n // Trim callDatas if offchain data exists\\n assembly {\\n mstore(callDatas, offchainCount)\\n }\\n\\n revert OffchainLookup(\\n address(this),\\n multicallData.gateways,\\n abi.encodeWithSelector(BatchGateway.query.selector, callDatas),\\n multicallData.callbackFunction,\\n abi.encode(\\n multicallData.isWildcard,\\n multicallData.resolver,\\n multicallData.gateways,\\n multicallData.metaData,\\n extraDatas\\n )\\n );\\n }\\n}\\n\",\"keccak256\":\"0x737ecb5a0ef64c6da8eab2f466382e9aeee045020343be0cd77c9309cd9597b1\",\"license\":\"MIT\"},\"contracts/wrapper/BytesUtils.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity ~0.8.17;\\n\\nlibrary BytesUtils {\\n /*\\n * @dev Returns the keccak-256 hash of a byte range.\\n * @param self The byte string to hash.\\n * @param offset The position to start hashing at.\\n * @param len The number of bytes to hash.\\n * @return The hash of the byte range.\\n */\\n function keccak(\\n bytes memory self,\\n uint256 offset,\\n uint256 len\\n ) internal pure returns (bytes32 ret) {\\n require(offset + len <= self.length);\\n assembly {\\n ret := keccak256(add(add(self, 32), offset), len)\\n }\\n }\\n\\n /**\\n * @dev Returns the ENS namehash of a DNS-encoded name.\\n * @param self The DNS-encoded name to hash.\\n * @param offset The offset at which to start hashing.\\n * @return The namehash of the name.\\n */\\n function namehash(\\n bytes memory self,\\n uint256 offset\\n ) internal pure returns (bytes32) {\\n (bytes32 labelhash, uint256 newOffset) = readLabel(self, offset);\\n if (labelhash == bytes32(0)) {\\n require(offset == self.length - 1, \\\"namehash: Junk at end of name\\\");\\n return bytes32(0);\\n }\\n return\\n keccak256(abi.encodePacked(namehash(self, newOffset), labelhash));\\n }\\n\\n /**\\n * @dev Returns the keccak-256 hash of a DNS-encoded label, and the offset to the start of the next label.\\n * @param self The byte string to read a label from.\\n * @param idx The index to read a label at.\\n * @return labelhash The hash of the label at the specified index, or 0 if it is the last label.\\n * @return newIdx The index of the start of the next label.\\n */\\n function readLabel(\\n bytes memory self,\\n uint256 idx\\n ) internal pure returns (bytes32 labelhash, uint256 newIdx) {\\n require(idx < self.length, \\\"readLabel: Index out of bounds\\\");\\n uint256 len = uint256(uint8(self[idx]));\\n if (len > 0) {\\n labelhash = keccak(self, idx + 1, len);\\n } else {\\n labelhash = bytes32(0);\\n }\\n newIdx = idx + len + 1;\\n }\\n}\\n\",\"keccak256\":\"0xf862cd86d749158a554e3cb517efa9097331ec0cf7225117f21e96fb50c67edb\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "kind": "dev", + "methods": { + "findResolver(bytes)": { + "details": "Finds a resolver by recursively querying the registry, starting at the longest name and progressively removing labels until it finds a result.", + "params": { + "name": "The name to resolve, in DNS-encoded and normalised form." + }, + "returns": { + "_0": "resolver The Resolver responsible for this name.", + "_1": "namehash The namehash of the full name.", + "_2": "finalOffset The offset of the first label with a resolver." + } + }, + "owner()": { + "details": "Returns the address of the current owner." + }, + "renounceOwnership()": { + "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." + }, + "resolve(bytes,bytes)": { + "details": "Performs ENS name resolution for the supplied name and resolution data.", + "params": { + "data": "The resolution data, as specified in ENSIP-10.", + "name": "The name to resolve, in normalised and DNS-encoded form." + }, + "returns": { + "_0": "The result of resolving the name." + } + }, + "reverse(bytes,string[])": { + "details": "Performs ENS name reverse resolution for the supplied reverse name.", + "params": { + "reverseName": "The reverse name to resolve, in normalised and DNS-encoded form. e.g. b6E040C9ECAaE172a89bD561c5F73e1C48d28cd9.addr.reverse" + }, + "returns": { + "_0": "The resolved name, the resolved address, the reverse resolver address, and the resolver address." + } + }, + "supportsInterface(bytes4)": { + "details": "See {IERC165-supportsInterface}." + }, + "transferOwnership(address)": { + "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." + } + }, + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": {}, + "notice": "The Universal Resolver is a contract that handles the work of resolving a name entirely onchain, making it possible to make a single smart contract call to resolve an ENS name.", + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 444, + "contract": "contracts/utils/UniversalResolver.sol:UniversalResolver", + "label": "_owner", + "offset": 0, + "slot": "0", + "type": "t_address" + }, + { + "astId": 18487, + "contract": "contracts/utils/UniversalResolver.sol:UniversalResolver", + "label": "batchGatewayURLs", + "offset": 0, + "slot": "1", + "type": "t_array(t_string_storage)dyn_storage" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_string_storage)dyn_storage": { + "base": "t_string_storage", + "encoding": "dynamic_array", + "label": "string[]", + "numberOfBytes": "32" + }, + "t_string_storage": { + "encoding": "bytes", + "label": "string", + "numberOfBytes": "32" + } + } + } +} \ No newline at end of file