Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";

import {BNS} from "src/registry/interfaces/BNS.sol";

import {GRACE_PERIOD, RECLAIM_ID} from "src/utils/Constants.sol";

/// @title Base Registrar
contract BaseRegistrar is ERC721, Ownable {
    using Strings for uint256;

    /// Errors -----------------------------------------------------------

    /// @notice Thrown when the name has expired.
    ///
    /// @param tokenId The id of the token that expired.
    error Expired(uint256 tokenId);

    /// @notice Thrown when called by an unauthorized owner.
    ///
    /// @param tokenId The id that was being called against.
    /// @param sender The unauthorized sender.
    error NotApprovedOwner(uint256 tokenId, address sender);

    /// @notice Thrown when the name is not available for registration.
    ///
    /// @param tokenId The id of the name that is not available.
    error NotAvailable(uint256 tokenId);

    /// @notice Thrown when the queried tokenId does not exist.
    ///
    /// @param tokenId The id of the name that does not exist.
    error NonexistentToken(uint256 tokenId);

    /// @notice Thrown when the name is not registered or in its Grace Period.
    ///
    /// @param tokenId The id of the token that is not registered or in Grace Period.
    error NotRegisteredOrInGrace(uint256 tokenId);

    /// @notice Thrown when msg.sender is not an approved Controller.
    error OnlyController();

    /// @notice Thrown when this contract does not own the `baseNode`.
    error RegistrarNotLive();

    /// Events -----------------------------------------------------------

    /// @notice Emitted when a Controller is added to the approved `controllers` mapping.
    ///
    /// @param controller The address of the approved controller.
    event ControllerAdded(address indexed controller);

    /// @notice Emitted when a Controller is removed from the approved `controllers` mapping.
    ///
    /// @param controller The address of the removed controller.
    event ControllerRemoved(address indexed controller);

    /// @notice Emitted when a name is registered.
    ///
    /// @param id The id of the registered name.
    /// @param owner The owner of the registered name.
    /// @param expires The expiry of the new ownership record.
    event NameRegistered(uint256 indexed id, address indexed owner, uint256 expires);

    /// @notice Emitted when a name is renewed.
    ///
    /// @param id The id of the renewed name.
    /// @param expires The new expiry for the name.
    event NameRenewed(uint256 indexed id, uint256 expires);

    /// @notice Emitted when a name is registered with BNS Records.
    ///
    /// @param id The id of the newly registered name.
    /// @param owner The owner of the registered name.
    /// @param expires The expiry of the new ownership record.
    /// @param resolver The address of the resolver for the name.
    /// @param ttl The time-to-live for the name.
    event NameRegisteredWithRecord(
        uint256 indexed id, address indexed owner, uint256 expires, address resolver, uint64 ttl
    );

    /// @notice Emitted when metadata for a token range is updated.
    ///
    /// @dev Useful for third-party platforms such as NFT marketplaces who can update
    ///     the images and related attributes of the NFTs in a timely fashion.
    ///     To refresh a whole collection, emit `_toTokenId` with `type(uint256).max`
    ///     ERC-4906: https://eip.tools/eip/4906
    ///
    /// @param _fromTokenId The starting range of `tokenId` for which metadata has been updated.
    /// @param _toTokenId The ending range of `tokenId` for which metadata has been updated.
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);

    /// @notice Emitted when the metadata for the contract collection is updated.
    ///
    /// @dev ERC-7572: https://eips.ethereum.org/EIPS/eip-7572
    event ContractURIUpdated();

    /// Storage ----------------------------------------------------------

    /// @notice The Registry contract.
    BNS public immutable registry;

    /// @notice A map of expiry times to node.
    mapping(bytes32 node => uint256 expiry) public nameExpires;

    /// @notice The namehash of the TLD this registrar owns (eg, .bera).
    bytes32 public immutable baseNode;

    /// @notice The base URI for token metadata.
    string private _tokenURI;

    /// @notice The URI for collection metadata.
    string private _collectionURI;

    /// @notice A map of addresses that are authorised to register and renew names.
    mapping(address controller => bool isApproved) public controllers;

    /// Modifiers --------------------------------------------------------

    /// @notice Decorator for determining if the contract is actively managing registrations for its `baseNode`.
    modifier live() {
        if (registry.owner(baseNode) != address(this)) {
            revert RegistrarNotLive();
        }
        _;
    }

    /// @notice Decorator for restricting methods to only approved Controller callers.
    modifier onlyController() {
        if (!controllers[msg.sender]) revert OnlyController();
        _;
    }

    /// @notice Decorator for determining if a name is available.
    ///
    /// @param id The id being checked for availability.
    modifier onlyAvailable(uint256 id) {
        if (!isAvailable(id)) revert NotAvailable(id);
        _;
    }

    /// @notice Decorator for determining if a name has expired.
    ///
    /// @param id The id being checked for expiry.
    modifier onlyNonExpired(uint256 id) {
        if (nameExpires[bytes32(id)] <= block.timestamp) revert Expired(id);
        _;
    }

    /// Constructor ------------------------------------------------------

    /// @notice BaseRegistrar constructor used to initialize the configuration of the implementation.
    ///
    /// @param registry_ The Registry contract.
    /// @param owner_ The permissioned address initialized as the `owner` in the `Ownable` context.
    /// @param baseNode_ The node that this contract manages registrations for.
    /// @param tokenURI_ The base token URI for NFT metadata.
    /// @param collectionURI_ The URI for the collection's metadata.
    constructor(BNS registry_, address owner_, bytes32 baseNode_, string memory tokenURI_, string memory collectionURI_)
        ERC721("Beranames", unicode"🐻🪪")
        Ownable(owner_)
    {
        _transferOwnership(owner_);
        registry = registry_;
        baseNode = baseNode_;
        _tokenURI = tokenURI_;
        _collectionURI = collectionURI_;
    }

    /// Admin Functions --------------------------------------------------

    /// @notice Authorises a controller, who can register and renew domains.
    /// @dev Emits `ControllerAdded(controller)` after adding the `controller` to the `controllers` mapping.
    /// @param controller The address of the new controller.
    function addController(address controller) external onlyOwner {
        controllers[controller] = true;
        emit ControllerAdded(controller);
    }

    /// @notice Revoke controller permission for an address.
    /// @dev Emits `ControllerRemoved(controller)` after removing the `controller` from the `controllers` mapping.
    /// @param controller The address of the controller to remove.
    function removeController(address controller) external onlyOwner {
        controllers[controller] = false;
        emit ControllerRemoved(controller);
    }

    /// @notice Set the resolver for the node this registrar manages.
    /// @param resolver The address of the new resolver contract.
    function setResolver(address resolver) external onlyOwner {
        registry.setResolver(baseNode, resolver);
    }

    /// @notice Register a name and add details to the record in the Registry.
    /// @param id The token id determined by keccak256(label).
    /// @param owner The address that should own the registration.
    /// @param duration Duration in seconds for the registration.
    /// @param resolver Address of the resolver for the name.
    /// @param ttl Time-to-live for the name.
    function registerWithRecord(uint256 id, address owner, uint256 duration, address resolver, uint64 ttl)
        external
        live
        onlyController
        onlyAvailable(id)
        returns (uint256)
    {
        uint256 expiry = _localRegister(id, owner, duration);
        registry.setSubnodeRecord(baseNode, bytes32(id), owner, resolver, ttl);
        emit NameRegisteredWithRecord(id, owner, expiry, resolver, ttl);
        return expiry;
    }

    /// @notice Gets the owner of the specified token ID.
    /// @dev Names become unowned when their registration expires.
    /// @param tokenId The id of the name to query the owner of.
    /// @return address The address currently marked as the owner of the given token ID.
    function ownerOf(uint256 tokenId) public view override onlyNonExpired(tokenId) returns (address) {
        return super.ownerOf(tokenId);
    }

    /// @notice Returns true if the specified name is available for registration.
    /// @param id The id of the name to check availability of.
    /// @return `true` if the name is available, else `false`.
    function isAvailable(uint256 id) public view returns (bool) {
        // Not available if it's registered here or in its grace period.
        return nameExpires[bytes32(id)] + GRACE_PERIOD < block.timestamp;
    }

    /// @notice Allows holders of names to renew their ownerhsip and extend their expiry.
    /// @param id The id of the name to renew.
    /// @param duration The time that will be added to this name's expiry.
    /// @return The new expiry date.
    function renew(uint256 id, uint256 duration) external live onlyController returns (uint256) {
        uint256 expires = nameExpires[bytes32(id)];
        if (expires + GRACE_PERIOD < block.timestamp) {
            revert NotRegisteredOrInGrace(id);
        }

        expires += duration;
        nameExpires[bytes32(id)] = expires;
        emit NameRenewed(id, expires);
        return expires;
    }

    /// @notice ERC165 compliant signal for interface support.
    /// @param interfaceID the ERC165 iface id being checked for compliance
    /// @return bool Whether this contract supports the provided interfaceID
    function supportsInterface(bytes4 interfaceID) public pure override(ERC721) returns (bool) {
        return interfaceID == type(IERC165).interfaceId || interfaceID == type(IERC721).interfaceId
            || interfaceID == RECLAIM_ID;
    }

    /// ERC721 Implementation --------------------------------------------

    /// @notice Returns the Uniform Resource Identifier (URI) for token `id`.
    /// @dev Reverts if the `tokenId` has not be registered.
    /// @param tokenId The token for which to return the metadata uri.
    /// @return The URI for the specified `tokenId`.
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (_ownerOf(tokenId) == address(0)) revert NonexistentToken(tokenId);

        return bytes(_tokenURI).length > 0 ? string.concat(_tokenURI, tokenId.toString()) : "";
    }

    /// @notice Returns the Uniform Resource Identifier (URI) for the contract.
    /// @dev ERC-7572: https://eips.ethereum.org/EIPS/eip-7572
    function contractURI() public view returns (string memory) {
        return _collectionURI;
    }

    /// @dev Allows the owner to set the the base Uniform Resource Identifier (URI)`.
    ///     Emits the `BatchMetadataUpdate` event for the full range of valid `tokenIds`.
    function setTokenURI(string memory baseURI_) public onlyOwner {
        _tokenURI = baseURI_;
        /// @dev minimum valid tokenId is `1` because uint256(nodehash) will never be called against `nodehash == 0x0`.
        emit BatchMetadataUpdate(1, type(uint256).max);
    }

    /// @dev Allows the owner to set the the contract Uniform Resource Identifier (URI)`.
    ///     Emits the `ContractURIUpdated` event.
    function setContractURI(string memory collectionURI_) public onlyOwner {
        _collectionURI = collectionURI_;
        emit ContractURIUpdated();
    }

    /// @notice transferFrom is overridden to handle the registry update.
    function transferFrom(address from, address to, uint256 tokenId) public override {
        super.transferFrom(from, to, tokenId);
        registry.setSubnodeOwner(baseNode, bytes32(tokenId), to);
    }

    /// Internal Methods -------------------------------------------------

    /// @notice Register a name and possibly update the Registry.
    /// @param id The token id determined by keccak256(label).
    /// @param owner The address that should own the registration.
    /// @param duration Duration in seconds for the registration.
    /// @param updateRegistry Whether to update the Regstiry with the ownership change
    ///
    /// @return The expiry date of the registered name.
    function _register(uint256 id, address owner, uint256 duration, bool updateRegistry)
        internal
        live
        onlyController
        onlyAvailable(id)
        returns (uint256)
    {
        uint256 expiry = _localRegister(id, owner, duration);
        if (updateRegistry) {
            registry.setSubnodeOwner(baseNode, bytes32(id), owner);
        }
        emit NameRegistered(id, owner, expiry);
        return expiry;
    }

    /// @notice Internal handler for local state changes during registrations.
    /// @dev Sets the token's expiry time and then `burn`s and `mint`s a new token.
    /// @param id The token id determined by keccak256(label).
    /// @param owner The address that should own the registration.
    /// @param duration Duration in seconds for the registration.
    ///
    /// @return expiry The expiry date of the registered name.
    function _localRegister(uint256 id, address owner, uint256 duration) internal returns (uint256 expiry) {
        expiry = block.timestamp + duration;
        nameExpires[bytes32(id)] = expiry;
        if (_ownerOf(id) != address(0)) {
            // Name was previously owned, and expired
            _burn(id);
        }
        _mint(owner, id);
    }

    /// @notice Returns whether the given spender can transfer a given token ID.
    /// @param spender address of the spender to query
    /// @param tokenId uint256 ID of the token to be transferred
    /// @return `true` if msg.sender is approved for the given token ID, is an operator of the owner,
    ///         or is the owner of the token, else `false`.
    function _isApprovedOrOwner(address spender, uint256 tokenId)
        internal
        view
        onlyNonExpired(tokenId)
        returns (bool)
    {
        address owner_ = _ownerOf(tokenId);
        return owner_ == spender || _isAuthorized(owner_, spender, tokenId);
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.20;

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

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

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

interface BNS {
    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;

    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;

    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns (bytes32);

    function setResolver(bytes32 node, address resolver) external;

    function setOwner(bytes32 node, address owner) external;

    function setTTL(bytes32 node, uint64 ttl) external;

    function setApprovalForAll(address operator, bool approved) external;

    function owner(bytes32 node) external view returns (address);

    function resolver(bytes32 node) external view returns (address);

    function ttl(bytes32 node) external view returns (uint64);

    function recordExists(bytes32 node) external view returns (bool);

    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

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

// @param BERA_NODE The node hash of "bera"
bytes32 constant BERA_NODE = 0xcac7291742cc038df280cfdc67517aa5d83fe6f4716c336481273a83a877997b;

// @param REVERSE_NODE The node hash of "reverse"
bytes32 constant REVERSE_NODE = 0xa097f6721ce401e757d1223a763fef49b8b5f90bb18567ddb86fd205dff71d34;

// @param ADDR_REVERSE_NODE The node hash of "addr.reverse"
bytes32 constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;

// @param GRACE_PERIOD the grace period for expired names
uint256 constant GRACE_PERIOD = 30 days;

// @param RECLAIM_ID InterfaceId for the Reclaim interface
bytes4 constant RECLAIM_ID = bytes4(keccak256("reclaim(uint256,address)"));

uint64 constant DEFAULT_TTL = 3600;

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

pragma solidity ^0.8.20;

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

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

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

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

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

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

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

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

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

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

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

{
  "remappings": [
    "@pythnetwork/pyth-sdk-solidity/=node_modules/@pythnetwork/pyth-sdk-solidity/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "forge-std/=lib/forge-std/src/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract BNS","name":"registry_","type":"address"},{"internalType":"address","name":"owner_","type":"address"},{"internalType":"bytes32","name":"baseNode_","type":"bytes32"},{"internalType":"string","name":"tokenURI_","type":"string"},{"internalType":"string","name":"collectionURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Expired","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NonexistentToken","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"sender","type":"address"}],"name":"NotApprovedOwner","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NotAvailable","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NotRegisteredOrInGrace","type":"error"},{"inputs":[],"name":"OnlyController","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"RegistrarNotLive","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_toTokenId","type":"uint256"}],"name":"BatchMetadataUpdate","type":"event"},{"anonymous":false,"inputs":[],"name":"ContractURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"}],"name":"ControllerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"controller","type":"address"}],"name":"ControllerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"expires","type":"uint256"}],"name":"NameRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"expires","type":"uint256"},{"indexed":false,"internalType":"address","name":"resolver","type":"address"},{"indexed":false,"internalType":"uint64","name":"ttl","type":"uint64"}],"name":"NameRegisteredWithRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"expires","type":"uint256"}],"name":"NameRenewed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"addController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseNode","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"controllers","outputs":[{"internalType":"bool","name":"isApproved","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"isAvailable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"node","type":"bytes32"}],"name":"nameExpires","outputs":[{"internalType":"uint256","name":"expiry","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"address","name":"resolver","type":"address"},{"internalType":"uint64","name":"ttl","type":"uint64"}],"name":"registerWithRecord","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"contract BNS","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"removeController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"renew","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"collectionURI_","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"resolver","type":"address"}],"name":"setResolver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005b22280886a2f5e09a49bea7e320eab0e5320e2800000000000000000000000043aedb439f497b1d51d1b263d64abf026b2aed5ccac7291742cc038df280cfdc67517aa5d83fe6f4716c336481273a83a877997b00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000003168747470733a2f2f7777772e626572616e616d65732e636f6d2f6170692f6d657461646174612f62657261636861696e2f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003b68747470733a2f2f7777772e626572616e616d65732e636f6d2f6170692f6d657461646174612f62657261636861696e2f636f6c6c656374696f6e0000000000

-----Decoded View---------------
Arg [0] : registry_ (address): 0x5B22280886a2F5e09A49bEa7E320eAB0e5320e28
Arg [1] : owner_ (address): 0x43aedB439F497b1d51D1b263D64Abf026B2Aed5c
Arg [2] : baseNode_ (bytes32): 0xcac7291742cc038df280cfdc67517aa5d83fe6f4716c336481273a83a877997b
Arg [3] : tokenURI_ (string): https://www.beranames.com/api/metadata/berachain/
Arg [4] : collectionURI_ (string): https://www.beranames.com/api/metadata/berachain/collection

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000005b22280886a2f5e09a49bea7e320eab0e5320e28
Arg [1] : 00000000000000000000000043aedb439f497b1d51d1b263d64abf026b2aed5c
Arg [2] : cac7291742cc038df280cfdc67517aa5d83fe6f4716c336481273a83a877997b
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000031
Arg [6] : 68747470733a2f2f7777772e626572616e616d65732e636f6d2f6170692f6d65
Arg [7] : 7461646174612f62657261636861696e2f000000000000000000000000000000
Arg [8] : 000000000000000000000000000000000000000000000000000000000000003b
Arg [9] : 68747470733a2f2f7777772e626572616e616d65732e636f6d2f6170692f6d65
Arg [10] : 7461646174612f62657261636861696e2f636f6c6c656374696f6e0000000000

567:14611:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10670:240;;;;;;:::i;:::-;;:::i;:::-;;;565:14:15;;558:22;540:41;;528:2;513:18;10670:240:12;;;;;;;;2365:89:2;;;:::i;:::-;;;;;;;:::i;3497:154::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1506:32:15;;;1488:51;;1476:2;1461:18;3497:154:2;1342:203:15;3323:113:2;;;;;;:::i;:::-;;:::i;:::-;;12601:201:12;;;;;;:::i;:::-;;:::i;9578:214::-;;;;;;:::i;:::-;;:::i;4787:132:2:-;;;;;;:::i;:::-;;:::i;7975:115:12:-;;;;;;:::i;:::-;;:::i;9221:143::-;;;;;;:::i;:::-;;:::i;1920:208:2:-;;;;;;:::i;:::-;;:::i;:::-;;;2969:25:15;;;2957:2;2942:18;1920:208:2;2823:177:15;2293:101:0;;;:::i;4495:58:12:-;;;;;;:::i;:::-;;;;;;;;;;;;;;4412:29;;;;;1638:85:0;1710:6;;-1:-1:-1;;;;;1710:6:0;1638:85;;12367:154:12;;;;;;:::i;:::-;;:::i;2518:93:2:-;;;:::i;3718:144::-;;;;;;:::i;:::-;;:::i;7276:151:12:-;;;;;;:::i;:::-;;:::i;4985:208:2:-;;;;;;:::i;:::-;;:::i;10047:401:12:-;;;;;;:::i;:::-;;:::i;11255:263::-;;;;;;:::i;:::-;;:::i;4922:65::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;4633:33;;;;;11946:275;;;;;;:::i;:::-;;:::i;11667:97::-;;;:::i;3928:153:2:-;;;;;;:::i;:::-;;:::i;8479:457:12:-;;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;:::i;:::-;;:::i;7676:157:12:-;;;;;;:::i;:::-;;:::i;10670:240::-;10755:4;-1:-1:-1;;;;;;10778:40:12;;-1:-1:-1;;;10778:40:12;;:84;;-1:-1:-1;;;;;;;10822:40:12;;-1:-1:-1;;;10822:40:12;10778:84;:125;;;-1:-1:-1;;;;;;;10878:25:12;;-1:-1:-1;;;10878:25:12;10778:125;10771:132;10670:240;-1:-1:-1;;10670:240:12:o;2365:89:2:-;2410:13;2442:5;2435:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2365:89;:::o;3497:154::-;3564:7;3583:22;3597:7;3583:13;:22::i;:::-;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6034:24:2;3623:21;5938:127;3323:113;3394:35;3403:2;3407:7;735:10:6;3394:8:2;:35::i;:::-;3323:113;;:::o;12601:201:12:-;12692:37;12711:4;12717:2;12721:7;12692:18;:37::i;:::-;12739:56;;-1:-1:-1;;;12739:56:12;;12764:8;12739:56;;;8320:25:15;8361:18;;;8354:34;;;-1:-1:-1;;;;;8424:32:15;;;8404:18;;;8397:60;12739:8:12;:24;;;;8293:18:15;;12739:56:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;12601:201;;;:::o;9578:214::-;9632:4;9728:24;;;:11;:24;;;;;;9770:15;;9728:39;;607:7:14;;9728:39:12;:::i;:::-;:57;;9578:214;-1:-1:-1;;9578:214:12:o;4787:132:2:-;4873:39;4890:4;4896:2;4900:7;4873:39;;;;;;;;;;;;:16;:39::i;:::-;4787:132;;;:::o;7975:115:12:-;1531:13:0;:11;:13::i;:::-;8043:40:12::1;::::0;-1:-1:-1;;;8043:40:12;;8064:8:::1;8043:40;::::0;::::1;9058:25:15::0;-1:-1:-1;;;;;9119:32:15;;;9099:18;;;9092:60;8043:8:12::1;:20;::::0;::::1;::::0;9031:18:15;;8043:40:12::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7975:115:::0;:::o;9221:143::-;9309:7;5948:24;;;:11;:24;;;;;;9291:7;;5976:15;-1:-1:-1;5944:67:12;;6000:11;;-1:-1:-1;;;6000:11:12;;;;;2969:25:15;;;2942:18;;6000:11:12;;;;;;;;5944:67;9335:22:::1;9349:7;9335:13;:22::i;:::-;9328:29;;6021:1;9221:143:::0;;;;:::o;1920:208:2:-;1983:7;-1:-1:-1;;;;;2006:19:2;;2002:87;;2048:30;;-1:-1:-1;;;2048:30:2;;2075:1;2048:30;;;1488:51:15;1461:18;;2048:30:2;1342:203:15;2002:87:2;-1:-1:-1;;;;;;2105:16:2;;;;;:9;:16;;;;;;;1920:208::o;2293:101:0:-;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;12367:154:12:-;1531:13:0;:11;:13::i;:::-;12448:14:12::1;:31;12465:14:::0;12448;:31:::1;:::i;:::-;-1:-1:-1::0;12494:20:12::1;::::0;::::1;::::0;;;::::1;12367:154:::0;:::o;2518:93:2:-;2565:13;2597:7;2590:14;;;;;:::i;3718:144::-;3803:52;735:10:6;3836:8:2;3846;3803:18;:52::i;7276:151:12:-;1531:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;7348:23:12;::::1;;::::0;;;:11:::1;:23;::::0;;;;;:30;;-1:-1:-1;;7348:30:12::1;7374:4;7348:30;::::0;;7393:27;::::1;::::0;7348:23;7393:27:::1;7276:151:::0;:::o;4985:208:2:-;5098:31;5111:4;5117:2;5121:7;5098:12;:31::i;:::-;5139:47;5162:4;5168:2;5172:7;5181:4;5139:22;:47::i;10047:401:12:-;5213:24;;-1:-1:-1;;;5213:24:12;;5228:8;5213:24;;;2969:25:15;10130:7:12;;5249:4;;-1:-1:-1;;;;;5213:8:12;:14;;;;2942:18:15;;5213:24:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;5213:41:12;;5209:97;;5277:18;;-1:-1:-1;;;5277:18:12;;;;;;;;;;;5209:97;5469:10:::1;5457:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;5452:53;;5489:16;;-1:-1:-1::0;;;5489:16:12::1;;;;;;;;;;;5452:53;10149:15:::2;10167:24:::0;;;:11:::2;:24;::::0;;;;;10230:15:::2;10205:22;607:7:14;10167:24:12::0;10205:22:::2;:::i;:::-;:40;10201:104;;;10268:26;::::0;-1:-1:-1;;;10268:26:12;;::::2;::::0;::::2;2969:25:15::0;;;2942:18;;10268:26:12::2;2823:177:15::0;10201:104:12::2;10315:19;10326:8:::0;10315:19;::::2;:::i;:::-;10344:24;::::0;;;:11:::2;:24;::::0;;;;;;:34;;;10393:24;10315:19;;-1:-1:-1;10364:2:12;;10393:24:::2;::::0;::::2;::::0;10315:19;2969:25:15;;2957:2;2942:18;;2823:177;10393:24:12::2;;;;;;;;10434:7:::0;10047:401;-1:-1:-1;;;10047:401:12:o;11255:263::-;11378:1;5799:16:2;;;:7;:16;;;;;;11320:13:12;;-1:-1:-1;;;;;5799:16:2;11345:69:12;;11389:25;;-1:-1:-1;;;11389:25:12;;;;;2969::15;;;2942:18;;11389:25:12;2823:177:15;11345:69:12;11458:1;11438:9;11432:23;;;;;:::i;:::-;;;:27;:79;;;;;;;;;;;;;;;;;11476:9;11487:18;:7;:16;:18::i;:::-;11462:44;;;;;;;;;:::i;:::-;;;;;;;;;;;;;11425:86;11255:263;-1:-1:-1;;11255:263:12:o;11946:275::-;1531:13:0;:11;:13::i;:::-;12018:9:12::1;:20;12030:8:::0;12018:9;:20:::1;:::i;:::-;-1:-1:-1::0;12173:41:12::1;::::0;;12193:1:::1;12719:25:15::0;;-1:-1:-1;;12775:2:15;12760:18;;12753:34;12173:41:12::1;::::0;12692:18:15;12173:41:12::1;;;;;;;11946:275:::0;:::o;11667:97::-;11711:13;11743:14;11736:21;;;;;:::i;3928:153:2:-;-1:-1:-1;;;;;4039:25:2;;;4016:4;4039:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;3928:153::o;8479:457:12:-;5213:24;;-1:-1:-1;;;5213:24:12;;5228:8;5213:24;;;2969:25:15;8678:7:12;;5249:4;;-1:-1:-1;;;;;5213:8:12;:14;;;;2942:18:15;;5213:24:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;5213:41:12;;5209:97;;5277:18;;-1:-1:-1;;;5277:18:12;;;;;;;;;;;5209:97;5469:10:::1;5457:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;5452:53;;5489:16;;-1:-1:-1::0;;;5489:16:12::1;;;;;;;;;;;5452:53;8657:2:::2;5710:15;5722:2;5710:11;:15::i;:::-;5705:45;;5734:16;::::0;-1:-1:-1;;;5734:16:12;;::::2;::::0;::::2;2969:25:15::0;;;2942:18;;5734:16:12::2;2823:177:15::0;5705:45:12::2;8701:14:::3;8718:35;8733:2;8737:5;8744:8;8718:14;:35::i;:::-;8763:70;::::0;-1:-1:-1;;;8763:70:12;;8789:8:::3;8763:70;::::0;::::3;13055:25:15::0;13096:18;;;13089:34;;;-1:-1:-1;;;;;13159:32:15;;;13139:18;;;13132:60;13228:32;;;13208:18;;;13201:60;13310:18;13298:31;;13277:19;;;13270:60;8701:52:12;;-1:-1:-1;8763:8:12::3;:25:::0;;::::3;::::0;::::3;::::0;13027:19:15;;8763:70:12::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;8848:58:12::3;::::0;;13541:25:15;;;-1:-1:-1;;;;;13602:32:15;;;13597:2;13582:18;;13575:60;13683:18;13671:31;;13651:18;;;13644:59;8848:58:12;;;;::::3;::::0;-1:-1:-1;8873:2:12;;-1:-1:-1;8848:58:12::3;::::0;;;;;13529:2:15;8848:58:12;;::::3;8923:6:::0;8479:457;-1:-1:-1;;;;;;;8479:457:12:o;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;1488:51:15::0;1461:18;;2672:31:0::1;1342:203:15::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;:::-;2543:215:::0;:::o;7676:157:12:-;1531:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;7751:23:12;::::1;7777:5;7751:23:::0;;;:11:::1;:23;::::0;;;;;:31;;-1:-1:-1;;7751:31:12::1;::::0;;7797:29;::::1;::::0;7777:5;7797:29:::1;7676:157:::0;:::o;16138:241:2:-;16201:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;16263:88;;16309:31;;-1:-1:-1;;;16309:31:2;;;;;2969:25:15;;;2942:18;;16309:31:2;2823:177:15;14418:120:2;14498:33;14507:2;14511:7;14520:4;14526;14498:8;:33::i;4143:578::-;-1:-1:-1;;;;;4237:16:2;;4233:87;;4276:33;;-1:-1:-1;;;4276:33:2;;4306:1;4276:33;;;1488:51:15;1461:18;;4276:33:2;1342:203:15;4233:87:2;4538:21;4562:34;4570:2;4574:7;735:10:6;4562:7:2;:34::i;:::-;4538:58;;4627:4;-1:-1:-1;;;;;4610:21:2;:13;-1:-1:-1;;;;;4610:21:2;;4606:109;;4654:50;;-1:-1:-1;;;4654:50:2;;-1:-1:-1;;;;;13934:32:15;;;4654:50:2;;;13916:51:15;13983:18;;;13976:34;;;14046:32;;14026:18;;;14019:60;13889:18;;4654:50:2;13714:371:15;1796:162:0;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:6;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:6;1901:40:0;;;1488:51:15;1461:18;;1901:40:0;1342:203:15;2185:118:2;2248:7;2274:22;2288:7;2274:13;:22::i;2912:187:0:-;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;;;;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;15591:312:2:-;-1:-1:-1;;;;;15698:22:2;;15694:91;;15743:31;;-1:-1:-1;;;15743:31:2;;-1:-1:-1;;;;;1506:32:15;;15743:31:2;;;1488:51:15;1461:18;;15743:31:2;1342:203:15;15694:91:2;-1:-1:-1;;;;;15794:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;15794:46:2;;;;;;;;;;15855:41;;540::15;;;15855::2;;513:18:15;15855:41:2;;;;;;;15591:312;;;:::o;16918:782::-;-1:-1:-1;;;;;17034:14:2;;;:18;17030:664;;17072:71;;-1:-1:-1;;;17072:71:2;;-1:-1:-1;;;;;17072:36:2;;;;;:71;;735:10:6;;17123:4:2;;17129:7;;17138:4;;17072:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17072:71:2;;;;;;;;-1:-1:-1;;17072:71:2;;;;;;;;;;;;:::i;:::-;;;17068:616;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17381:6;:13;17398:1;17381:18;17377:293;;17430:25;;-1:-1:-1;;;17430:25:2;;-1:-1:-1;;;;;1506:32:15;;17430:25:2;;;1488:51:15;1461:18;;17430:25:2;1342:203:15;17377:293:2;17622:6;17616:13;17607:6;17603:2;17599:15;17592:38;17068:616;-1:-1:-1;;;;;;17190:51:2;;-1:-1:-1;;;17190:51:2;17186:130;;17272:25;;-1:-1:-1;;;17272:25:2;;-1:-1:-1;;;;;1506:32:15;;17272:25:2;;;1488:51:15;1461:18;;17272:25:2;1342:203:15;637:698:7;693:13;742:14;759:17;770:5;759:10;:17::i;:::-;779:1;759:21;742:38;;794:20;828:6;817:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;817:18:7;-1:-1:-1;794:41:7;-1:-1:-1;955:28:7;;;971:2;955:28;1010:282;-1:-1:-1;;1041:5:7;-1:-1:-1;;;1175:2:7;1164:14;;1159:32;1041:5;1146:46;1236:2;1227:11;;;-1:-1:-1;1256:21:7;1010:282;1256:21;-1:-1:-1;1312:6:7;637:698;-1:-1:-1;;;637:698:7:o;14175:353:12:-;14262:14;14297:26;14315:8;14297:15;:26;:::i;:::-;14333:24;;;;:11;:24;;;;;;;;:33;;;5799:7:2;:16;;;;;;14333:33:12;;-1:-1:-1;;;;;;5799:16:2;14380:26:12;14376:120;;14476:9;14482:2;14476:5;:9::i;:::-;14505:16;14511:5;14518:2;14505:5;:16::i;:::-;14175:353;;;;;:::o;14720:662:2:-;14880:9;:31;;;-1:-1:-1;;;;;;14893:18:2;;;;14880:31;14876:460;;;14927:13;14943:22;14957:7;14943:13;:22::i;:::-;14927:38;-1:-1:-1;;;;;;15093:18:2;;;;;;:35;;;15124:4;-1:-1:-1;;;;;15115:13:2;:5;-1:-1:-1;;;;;15115:13:2;;;15093:35;:69;;;;;15133:29;15150:5;15157:4;15133:16;:29::i;:::-;15132:30;15093:69;15089:142;;;15189:27;;-1:-1:-1;;;15189:27:2;;-1:-1:-1;;;;;1506:32:15;;15189:27:2;;;1488:51:15;1461:18;;15189:27:2;1342:203:15;15089:142:2;15249:9;15245:81;;;15303:7;15299:2;-1:-1:-1;;;;;15283:28:2;15292:5;-1:-1:-1;;;;;15283:28:2;;;;;;;;;;;15245:81;14913:423;14876:460;-1:-1:-1;;15346:24:2;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;15346:29:2;-1:-1:-1;;;;;15346:29:2;;;;;;;;;;14720:662::o;8838:795::-;8924:7;5799:16;;;:7;:16;;;;;;-1:-1:-1;;;;;5799:16:2;;;;9035:18;;;9031:86;;9069:37;9086:4;9092;9098:7;9069:16;:37::i;:::-;-1:-1:-1;;;;;9161:18:2;;;9157:256;;9277:48;9294:1;9298:7;9315:1;9319:5;9277:8;:48::i;:::-;-1:-1:-1;;;;;9368:15:2;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;9368:20:2;;;9157:256;-1:-1:-1;;;;;9427:16:2;;;9423:107;;-1:-1:-1;;;;;9487:13:2;;;;;;:9;:13;;;;;:18;;9504:1;9487:18;;;9423:107;9540:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9540:21:2;-1:-1:-1;;;;;9540:21:2;;;;;;;;;9577:27;;9540:16;;9577:27;;;;;;;9622:4;8838:795;-1:-1:-1;;;;8838:795:2:o;12214:916:10:-;12267:7;;-1:-1:-1;;;12342:17:10;;12338:103;;-1:-1:-1;;;12379:17:10;;;-1:-1:-1;12424:2:10;12414:12;12338:103;12467:8;12458:5;:17;12454:103;;12504:8;12495:17;;;-1:-1:-1;12540:2:10;12530:12;12454:103;12583:8;12574:5;:17;12570:103;;12620:8;12611:17;;;-1:-1:-1;12656:2:10;12646:12;12570:103;12699:7;12690:5;:16;12686:100;;12735:7;12726:16;;;-1:-1:-1;12770:1:10;12760:11;12686:100;12812:7;12803:5;:16;12799:100;;12848:7;12839:16;;;-1:-1:-1;12883:1:10;12873:11;12799:100;12925:7;12916:5;:16;12912:100;;12961:7;12952:16;;;-1:-1:-1;12996:1:10;12986:11;12912:100;13038:7;13029:5;:16;13025:66;;13075:1;13065:11;13117:6;12214:916;-1:-1:-1;;12214:916:10:o;11462:227:2:-;11513:21;11537:40;11553:1;11557:7;11574:1;11537:7;:40::i;:::-;11513:64;-1:-1:-1;;;;;;11591:27:2;;11587:96;;11641:31;;-1:-1:-1;;;11641:31:2;;;;;2969:25:15;;;2942:18;;11641:31:2;2823:177:15;9955:327:2;-1:-1:-1;;;;;10022:16:2;;10018:87;;10061:33;;-1:-1:-1;;;10061:33:2;;10091:1;10061:33;;;1488:51:15;1461:18;;10061:33:2;1342:203:15;10018:87:2;10114:21;10138:32;10146:2;10150:7;10167:1;10138:7;:32::i;:::-;10114:56;-1:-1:-1;;;;;;10184:27:2;;;10180:96;;10234:31;;-1:-1:-1;;;10234:31:2;;10262:1;10234:31;;;1488:51:15;1461:18;;10234:31:2;1342:203:15;7082:368:2;7194:38;7208:5;7215:7;7224;7194:13;:38::i;:::-;7189:255;;-1:-1:-1;;;;;7252:19:2;;7248:186;;7298:31;;-1:-1:-1;;;7298:31:2;;;;;2969:25:15;;;2942:18;;7298:31:2;2823:177:15;7248:186:2;7375:44;;-1:-1:-1;;;7375:44:2;;-1:-1:-1;;;;;15158:32:15;;7375:44:2;;;15140:51:15;15207:18;;;15200:34;;;15113:18;;7375:44:2;14966:274:15;6376:272:2;6479:4;-1:-1:-1;;;;;6514:21:2;;;;;;:127;;;6561:7;-1:-1:-1;;;;;6552:16:2;:5;-1:-1:-1;;;;;6552:16:2;;:52;;;;6572:32;6589:5;6596:7;6572:16;:32::i;:::-;6552:88;;;-1:-1:-1;6008:7:2;6034:24;;;:15;:24;;;;;;-1:-1:-1;;;;;6608:32:2;;;6034:24;;6608:32;6552:88;6495:146;6376:272;-1:-1:-1;;;;6376:272:2:o;14:131:15:-;-1:-1:-1;;;;;;88:32:15;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:289::-;634:3;672:5;666:12;699:6;694:3;687:19;755:6;748:4;741:5;737:16;730:4;725:3;721:14;715:47;807:1;800:4;791:6;786:3;782:16;778:27;771:38;870:4;863:2;859:7;854:2;846:6;842:15;838:29;833:3;829:39;825:50;818:57;;;592:289;;;;:::o;886:220::-;1035:2;1024:9;1017:21;998:4;1055:45;1096:2;1085:9;1081:18;1073:6;1055:45;:::i;1111:226::-;1170:6;1223:2;1211:9;1202:7;1198:23;1194:32;1191:52;;;1239:1;1236;1229:12;1191:52;-1:-1:-1;1284:23:15;;1111:226;-1:-1:-1;1111:226:15:o;1550:131::-;-1:-1:-1;;;;;1625:31:15;;1615:42;;1605:70;;1671:1;1668;1661:12;1686:367;1754:6;1762;1815:2;1803:9;1794:7;1790:23;1786:32;1783:52;;;1831:1;1828;1821:12;1783:52;1870:9;1857:23;1889:31;1914:5;1889:31;:::i;:::-;1939:5;2017:2;2002:18;;;;1989:32;;-1:-1:-1;;;1686:367:15:o;2058:508::-;2135:6;2143;2151;2204:2;2192:9;2183:7;2179:23;2175:32;2172:52;;;2220:1;2217;2210:12;2172:52;2259:9;2246:23;2278:31;2303:5;2278:31;:::i;:::-;2328:5;-1:-1:-1;2385:2:15;2370:18;;2357:32;2398:33;2357:32;2398:33;:::i;:::-;2058:508;;2450:7;;-1:-1:-1;;;2530:2:15;2515:18;;;;2502:32;;2058:508::o;2571:247::-;2630:6;2683:2;2671:9;2662:7;2658:23;2654:32;2651:52;;;2699:1;2696;2689:12;2651:52;2738:9;2725:23;2757:31;2782:5;2757:31;:::i;3410:127::-;3471:10;3466:3;3462:20;3459:1;3452:31;3502:4;3499:1;3492:15;3526:4;3523:1;3516:15;3542:716;3607:5;3639:1;3663:18;3655:6;3652:30;3649:56;;;3685:18;;:::i;:::-;-1:-1:-1;3840:2:15;3834:9;-1:-1:-1;;3753:2:15;3732:15;;3728:29;;3898:2;3886:15;3882:29;3870:42;;3963:22;;;3942:18;3927:34;;3924:62;3921:88;;;3989:18;;:::i;:::-;4025:2;4018:22;4073;;;4058:6;-1:-1:-1;4058:6:15;4110:16;;;4107:25;-1:-1:-1;4104:45:15;;;4145:1;4142;4135:12;4104:45;4195:6;4190:3;4183:4;4175:6;4171:17;4158:44;4250:1;4243:4;4234:6;4226;4222:19;4218:30;4211:41;;3542:716;;;;;:::o;4263:451::-;4332:6;4385:2;4373:9;4364:7;4360:23;4356:32;4353:52;;;4401:1;4398;4391:12;4353:52;4441:9;4428:23;4474:18;4466:6;4463:30;4460:50;;;4506:1;4503;4496:12;4460:50;4529:22;;4582:4;4574:13;;4570:27;-1:-1:-1;4560:55:15;;4611:1;4608;4601:12;4560:55;4634:74;4700:7;4695:2;4682:16;4677:2;4673;4669:11;4634:74;:::i;4719:416::-;4784:6;4792;4845:2;4833:9;4824:7;4820:23;4816:32;4813:52;;;4861:1;4858;4851:12;4813:52;4900:9;4887:23;4919:31;4944:5;4919:31;:::i;:::-;4969:5;-1:-1:-1;5026:2:15;5011:18;;4998:32;5068:15;;5061:23;5049:36;;5039:64;;5099:1;5096;5089:12;5039:64;5122:7;5112:17;;;4719:416;;;;;:::o;5140:847::-;5235:6;5243;5251;5259;5312:3;5300:9;5291:7;5287:23;5283:33;5280:53;;;5329:1;5326;5319:12;5280:53;5368:9;5355:23;5387:31;5412:5;5387:31;:::i;:::-;5437:5;-1:-1:-1;5494:2:15;5479:18;;5466:32;5507:33;5466:32;5507:33;:::i;:::-;5559:7;-1:-1:-1;5639:2:15;5624:18;;5611:32;;-1:-1:-1;5720:2:15;5705:18;;5692:32;5747:18;5736:30;;5733:50;;;5779:1;5776;5769:12;5733:50;5802:22;;5855:4;5847:13;;5843:27;-1:-1:-1;5833:55:15;;5884:1;5881;5874:12;5833:55;5907:74;5973:7;5968:2;5955:16;5950:2;5946;5942:11;5907:74;:::i;:::-;5897:84;;;5140:847;;;;;;;:::o;5992:346::-;6060:6;6068;6121:2;6109:9;6100:7;6096:23;6092:32;6089:52;;;6137:1;6134;6127:12;6089:52;-1:-1:-1;;6182:23:15;;;6302:2;6287:18;;;6274:32;;-1:-1:-1;5992:346:15:o;6525:388::-;6593:6;6601;6654:2;6642:9;6633:7;6629:23;6625:32;6622:52;;;6670:1;6667;6660:12;6622:52;6709:9;6696:23;6728:31;6753:5;6728:31;:::i;:::-;6778:5;-1:-1:-1;6835:2:15;6820:18;;6807:32;6848:33;6807:32;6848:33;:::i;6918:810::-;7012:6;7020;7028;7036;7044;7097:3;7085:9;7076:7;7072:23;7068:33;7065:53;;;7114:1;7111;7104:12;7065:53;7159:23;;;-1:-1:-1;7258:2:15;7243:18;;7230:32;7271:33;7230:32;7271:33;:::i;:::-;7323:7;-1:-1:-1;7403:2:15;7388:18;;7375:32;;-1:-1:-1;7485:2:15;7470:18;;7457:32;7498:33;7457:32;7498:33;:::i;:::-;7550:7;-1:-1:-1;7609:3:15;7594:19;;7581:33;7658:18;7645:32;;7633:45;;7623:73;;7692:1;7689;7682:12;7623:73;7715:7;7705:17;;;6918:810;;;;;;;;:::o;7733:380::-;7812:1;7808:12;;;;7855;;;7876:61;;7930:4;7922:6;7918:17;7908:27;;7876:61;7983:2;7975:6;7972:14;7952:18;7949:38;7946:161;;8029:10;8024:3;8020:20;8017:1;8010:31;8064:4;8061:1;8054:15;8092:4;8089:1;8082:15;8468:184;8538:6;8591:2;8579:9;8570:7;8566:23;8562:32;8559:52;;;8607:1;8604;8597:12;8559:52;-1:-1:-1;8630:16:15;;8468:184;-1:-1:-1;8468:184:15:o;8657:222::-;8722:9;;;8743:10;;;8740:133;;;8795:10;8790:3;8786:20;8783:1;8776:31;8830:4;8827:1;8820:15;8858:4;8855:1;8848:15;9289:518;9391:2;9386:3;9383:11;9380:421;;;9427:5;9424:1;9417:16;9471:4;9468:1;9458:18;9541:2;9529:10;9525:19;9522:1;9518:27;9512:4;9508:38;9577:4;9565:10;9562:20;9559:47;;;-1:-1:-1;9600:4:15;9559:47;9655:2;9650:3;9646:12;9643:1;9639:20;9633:4;9629:31;9619:41;;9710:81;9728:2;9721:5;9718:13;9710:81;;;9787:1;9773:16;;9754:1;9743:13;9710:81;;9983:1299;10109:3;10103:10;10136:18;10128:6;10125:30;10122:56;;;10158:18;;:::i;:::-;10187:97;10277:6;10237:38;10269:4;10263:11;10237:38;:::i;:::-;10231:4;10187:97;:::i;:::-;10333:4;10364:2;10353:14;;10381:1;10376:649;;;;11069:1;11086:6;11083:89;;;-1:-1:-1;11138:19:15;;;11132:26;11083:89;-1:-1:-1;;9940:1:15;9936:11;;;9932:24;9928:29;9918:40;9964:1;9960:11;;;9915:57;11185:81;;10346:930;;10376:649;9236:1;9229:14;;;9273:4;9260:18;;-1:-1:-1;;10412:20:15;;;10530:222;10544:7;10541:1;10538:14;10530:222;;;10626:19;;;10620:26;10605:42;;10733:4;10718:20;;;;10686:1;10674:14;;;;10560:12;10530:222;;;10534:3;10780:6;10771:7;10768:19;10765:201;;;10841:19;;;10835:26;-1:-1:-1;;10924:1:15;10920:14;;;10936:3;10916:24;10912:37;10908:42;10893:58;10878:74;;10765:201;-1:-1:-1;;;;11012:1:15;10996:14;;;10992:22;10979:36;;-1:-1:-1;9983:1299:15:o;11287:251::-;11357:6;11410:2;11398:9;11389:7;11385:23;11381:32;11378:52;;;11426:1;11423;11416:12;11378:52;11458:9;11452:16;11477:31;11502:5;11477:31;:::i;11543:989::-;11719:3;11748:1;11781:6;11775:13;11811:36;11837:9;11811:36;:::i;:::-;11878:1;11863:17;;11889:133;;;;12036:1;12031:332;;;;11856:507;;11889:133;-1:-1:-1;;11922:24:15;;11910:37;;11995:14;;11988:22;11976:35;;11967:45;;;-1:-1:-1;11889:133:15;;12031:332;12062:6;12059:1;12052:17;12110:4;12107:1;12097:18;12137:1;12151:166;12165:6;12162:1;12159:13;12151:166;;;12245:14;;12232:11;;;12225:35;12301:1;12288:15;;;;12187:4;12180:12;12151:166;;;12155:3;;12346:6;12341:3;12337:16;12330:23;;11856:507;;;;12394:6;12388:13;12440:8;12433:4;12425:6;12421:17;12416:3;12410:39;12506:1;12468:18;;12495:13;;;12468:18;11543:989;-1:-1:-1;;;;11543:989:15:o;14090:485::-;-1:-1:-1;;;;;14321:32:15;;;14303:51;;14390:32;;14385:2;14370:18;;14363:60;14454:2;14439:18;;14432:34;;;14502:3;14497:2;14482:18;;14475:31;;;-1:-1:-1;;14523:46:15;;14549:19;;14541:6;14523:46;:::i;:::-;14515:54;14090:485;-1:-1:-1;;;;;;14090:485:15:o;14580:249::-;14649:6;14702:2;14690:9;14681:7;14677:23;14673:32;14670:52;;;14718:1;14715;14708:12;14670:52;14750:9;14744:16;14769:30;14793:5;14769:30;:::i

ipfs://77179ee031bd7c2581e4843454dfd1fdf4ce53c8bebb99de600613a8dcf5cb60