Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/access/Ownable.sol";
import "../../interfaces/IBasePunkTLDFactory.sol";
import "../../interfaces/IBasePunkTLD.sol";
import "../../lib/strings.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";

/// @title Punk Domains Resolver v2
/// @author Tempe Techie
/// @notice This contract resolves all punk domains and TLDs on the particular blockchain where it is deployed
contract PunkResolverNonUpgradable is Ownable {
  using strings for string;

  address[] public factories;

  mapping (address => bool) public isTldDeprecated; // deprecate an address, not TLD name
  mapping (address => string[2]) public customDefaultDomain; // mapping(0x12... => ["tempe", "op"]) user can set the desired default domain in the Resolver contract

  event FactoryAddressAdded(address user, address fAddr);
  event DeprecatedTldAdded(address user, address tAddr);
  event DeprecatedTldRemoved(address user, address tAddr);
  event CustomDefaultDomainSet(address user, string dName, string dTld);

  // READ

  // reverse resolver: get user's default name for a given TLD
  function getDefaultDomain(address _addr, string memory _tld) public view returns(string memory) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tld);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        return string(IBasePunkTLD(tldAddr).defaultNames(_addr));
      }

      unchecked { ++i; }
    }

    return "";
  }

  // reverse resolver: get user's default names (all TLDs)
  function getDefaultDomains(address _addr) public view returns(string memory) {
    bytes memory result;

    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      string[] memory tldNames = IBasePunkTLDFactory(factories[i]).getTldsArray();

      for (uint256 j = 0; j < tldNames.length; ++j) {
        string memory tldName = tldNames[j];
        address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(tldName);
        string memory defaultName = IBasePunkTLD(tldAddr).defaultNames(_addr);

        if (
          strings.len(strings.toSlice(defaultName)) > 0 && 
          !isTldDeprecated[tldAddr]
        ) {
          if (j == (tldNames.length-1)) { // last TLD (do not include space at the end)
            result = abi.encodePacked(result, defaultName, tldName);
          } else {
            result = abi.encodePacked(result, defaultName, tldName, " ");
          }
        }
      }

      unchecked { ++i; }
    }

    return string(result);
  }

  /// @notice domain resolver
  function getDomainHolder(string memory _domainName, string memory _tld) public view returns(address) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tld);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        return address(IBasePunkTLD(tldAddr).getDomainHolder(_domainName));
      }

      unchecked { ++i; }
    }

    return address(0);
  }
  
  /// @notice fetch domain data for a given domain
  function getDomainData(string memory _domainName, string memory _tld) public view returns(string memory) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tld);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        return string(IBasePunkTLD(tldAddr).getDomainData(_domainName));
      }

      unchecked { ++i; }
    }

    return "";
  }

  /// @notice fetch domain metadata for a given domain (tokenURI)
  function getDomainTokenUri(string memory _domainName, string memory _tld) public view returns(string memory) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tld);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        (, uint256 _tokenId, , ) = IBasePunkTLD(tldAddr).domains(_domainName);
        return IERC721Metadata(tldAddr).tokenURI(_tokenId);
      }

      unchecked { ++i; }
    }

    return "";
  }

  function getFactoriesArray() public view returns(address[] memory) {
    return factories;
  }

  /// @notice reverse resolver: get single user's default name, the first that comes (all TLDs)
  function getFirstDefaultDomain(address _addr) public view returns(string memory) {
    // check if user has set a custom default domain in this contract
    string[2] memory domainParts = customDefaultDomain[_addr];

    if (bytes(domainParts[0]).length > 0 && bytes(domainParts[1]).length > 0) {
      if (getDomainHolder(domainParts[0], domainParts[1]) == _addr) {
        return string(abi.encodePacked(domainParts[0], domainParts[1]));
      }
    }

    // if no custom default domain or if it's not valid, find another default domain
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      string[] memory tldNames = IBasePunkTLDFactory(factories[i]).getTldsArray();

      for (uint256 j = 0; j < tldNames.length; ++j) {
        string memory tldName = tldNames[j];
        address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(tldName);
        string memory defaultName = IBasePunkTLD(tldAddr).defaultNames(_addr);

        if (
          strings.len(strings.toSlice(defaultName)) > 0 && 
          !isTldDeprecated[tldAddr]
        ) {
          return string(abi.encodePacked(defaultName, tldName));
        }
      }

      unchecked { ++i; }
    }

    return "";
  }

  /// @notice get the address of a given TLD name
  function getTldAddress(string memory _tldName) public view returns(address) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tldName);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        return tldAddr;
      } else if (isTldDeprecated[tldAddr]) {
        return address(0);
      }

      unchecked { ++i; }
    }

    return address(0);
  }

  /// @notice get the address of the factory contract through which a given TLD was created
  function getTldFactoryAddress(string memory _tldName) public view returns(address) {
    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(_tldName);

      if (tldAddr != address(0) && !isTldDeprecated[tldAddr]) {
        return factories[i];
      } else if (isTldDeprecated[tldAddr]) {
        return address(0);
      }

      unchecked { ++i; }
    }

    return address(0);
  }

  /// @notice get a stringified CSV of all active TLDs (name,address) across all factories
  function getTlds() public view returns(string memory) {
    bytes memory result;

    uint256 fLength = factories.length;
    for (uint256 i = 0; i < fLength;) {
      string[] memory tldNames = IBasePunkTLDFactory(factories[i]).getTldsArray();

      for (uint256 j = 0; j < tldNames.length; ++j) {
        string memory tldName = tldNames[j];
        address tldAddr = IBasePunkTLDFactory(factories[i]).tldNamesAddresses(tldName);
        

        if (!isTldDeprecated[tldAddr]) {
          result = abi.encodePacked(
            result, 
            abi.encodePacked(tldName, ',', Strings.toHexString(uint256(uint160(tldAddr)), 20), '\n')
          );
        }
      }

      unchecked { ++i; }
    }

    return string(result);
  }

  // WRITE
  function setCustomDefaultDomain(string memory _domainName, string memory _tld) external {
    if (bytes(_domainName).length > 0 && bytes(_tld).length > 0) {
      // set a custom default domain
      require(getDomainHolder(_domainName, _tld) == _msgSender(), "You do not own this domain.");

      customDefaultDomain[_msgSender()] = [_domainName, _tld];
      emit CustomDefaultDomainSet(_msgSender(), _domainName, _tld);
    } else {
      // remove the current custom domain
      delete customDefaultDomain[_msgSender()];
      emit CustomDefaultDomainSet(_msgSender(), "", "");
    }
  }

  // OWNER
  function addFactoryAddress(address _factoryAddress) external onlyOwner {
    factories.push(_factoryAddress);
    emit FactoryAddressAdded(_msgSender(), _factoryAddress);
  }
  
  function addDeprecatedTldAddress(address _deprecatedTldAddress) external onlyOwner {
    isTldDeprecated[_deprecatedTldAddress] = true;
    emit DeprecatedTldAdded(_msgSender(), _deprecatedTldAddress);
  }

  function removeFactoryAddress(uint _addrIndex) external onlyOwner {
    factories[_addrIndex] = factories[factories.length - 1];
    factories.pop();
  }

  function removeDeprecatedTldAddress(address _deprecatedTldAddress) external onlyOwner {
    isTldDeprecated[_deprecatedTldAddress] = false;
    emit DeprecatedTldRemoved(_msgSender(), _deprecatedTldAddress);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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 v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../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 v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @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 caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @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);

    /**
     * @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;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @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 v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        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_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

interface IBasePunkTLD is IERC721 {

  struct Domain {
    string name; // domain name that goes before the TLD name; example: "tempetechie" in "tempetechie.web3"
    uint256 tokenId;
    address holder;
    string data; // stringified JSON object, example: {"description": "Some text", "twitter": "@techie1239", "friends": ["0x123..."], "url": "https://punk.domains"}
  }

  event DomainCreated(address indexed user, address indexed owner, string fullDomainName);
  event DomainBurned(address indexed user, string fullDomainName);
  event DefaultDomainChanged(address indexed user, string defaultDomain);
  event DataChanged(address indexed user, string indexed domain); // note that domain may be missing on events from older contracts
  event TldPriceChanged(address indexed user, uint256 tldPrice);
  event ReferralFeeChanged(address indexed user, uint256 referralFee);
  event TldRoyaltyChanged(address indexed user, uint256 tldRoyalty);
  event DomainBuyingToggle(address indexed user, bool domainBuyingToggle);

  function domains(string calldata _domainName) external view returns(string memory, uint256, address, string memory);

  function defaultNames(address) external view returns(string memory);

  function getDomainData(string calldata _domainName) external view returns(string memory);

  function getDomainHolder(string calldata _domainName) external view returns(address);

  function price() external view returns (uint256);
  function referral() external view returns (uint256);

  function changeNameMaxLength(uint256 _maxLength) external;

  function changePrice(uint256 _price) external;

  function changeReferralFee(uint256 _referral) external;

  function mint(
    string memory _domainName,
    address _domainHolder,
    address _referrer
  ) external payable returns(uint256);

}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;

interface IBasePunkTLDFactory {

  function getTldsArray() external view returns(string[] memory);

  function tldNamesAddresses(string memory) external view returns(address);

  function createTld(
    string memory _name,
    string memory _symbol,
    address _tldOwner,
    uint256 _domainPrice,
    bool _buyingEnabled
  ) external payable returns(address);

}

// SPDX-License-Identifier: Apache-2.0

/*
 * @title String & slice utility library for Solidity contracts.
 * @author Nick Johnson <[email protected]>
 */

pragma solidity ^0.8.0;

library strings {
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint _len) private pure {
        // Copy word-length chunks while possible
        for(; _len >= 32; _len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = type(uint).max;
        if (_len > 0) {
            mask = 256 ** (32 - _len) - 1;
        }
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Returns a slice containing the entire string.
     * @param self The string to make a slice from.
     * @return A newly allocated slice containing the entire string.
     */
    function toSlice(string memory self) internal pure returns (slice memory) {
        uint ptr;
        assembly {
            ptr := add(self, 0x20)
        }
        return slice(bytes(self).length, ptr);
    }

    /*
     * @dev Returns the length of a null-terminated bytes32 string.
     * @param self The value to find the length of.
     * @return The length of the string, from 0 to 32.
     */
    function len(bytes32 self) internal pure returns (uint) {
        uint ret;
        if (self == 0)
            return 0;
        if (uint(self) & type(uint128).max == 0) {
            ret += 16;
            self = bytes32(uint(self) / 0x100000000000000000000000000000000);
        }
        if (uint(self) & type(uint64).max == 0) {
            ret += 8;
            self = bytes32(uint(self) / 0x10000000000000000);
        }
        if (uint(self) & type(uint32).max == 0) {
            ret += 4;
            self = bytes32(uint(self) / 0x100000000);
        }
        if (uint(self) & type(uint16).max == 0) {
            ret += 2;
            self = bytes32(uint(self) / 0x10000);
        }
        if (uint(self) & type(uint8).max == 0) {
            ret += 1;
        }
        return 32 - ret;
    }

    /*
     * @dev Returns a slice containing the entire bytes32, interpreted as a
     *      null-terminated utf-8 string.
     * @param self The bytes32 value to convert to a slice.
     * @return A new slice containing the value of the input argument up to the
     *         first null.
     */
    function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
        // Allocate space for `self` in memory, copy it there, and point ret at it
        assembly {
            let ptr := mload(0x40)
            mstore(0x40, add(ptr, 0x20))
            mstore(ptr, self)
            mstore(add(ret, 0x20), ptr)
        }
        ret._len = len(self);
    }

    /*
     * @dev Returns a new slice containing the same data as the current slice.
     * @param self The slice to copy.
     * @return A new slice containing the same data as `self`.
     */
    function copy(slice memory self) internal pure returns (slice memory) {
        return slice(self._len, self._ptr);
    }

    /*
     * @dev Copies a slice to a new string.
     * @param self The slice to copy.
     * @return A newly allocated string containing the slice's text.
     */
    function toString(slice memory self) internal pure returns (string memory) {
        string memory ret = new string(self._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        memcpy(retptr, self._ptr, self._len);
        return ret;
    }

    /*
     * @dev Returns the length in runes of the slice. Note that this operation
     *      takes time proportional to the length of the slice; avoid using it
     *      in loops, and call `slice.empty()` if you only need to know whether
     *      the slice is empty or not.
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function len(slice memory self) internal pure returns (uint l) {
        // Starting at ptr-31 means the LSB will be the byte we care about
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

    /*
     * @dev Returns true if the slice is empty (has a length of 0).
     * @param self The slice to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function empty(slice memory self) internal pure returns (bool) {
        return self._len == 0;
    }

    /*
     * @dev Returns a positive number if `other` comes lexicographically after
     *      `self`, a negative number if it comes before, or zero if the
     *      contents of the two slices are equal. Comparison is done per-rune,
     *      on unicode codepoints.
     * @param self The first slice to compare.
     * @param other The second slice to compare.
     * @return The result of the comparison.
     */
    function compare(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;
        if (other._len < self._len)
            shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;
        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }
            if (a != b) {
                // Mask out irrelevant bytes and check again
                uint mask = type(uint).max; // 0xffff...
                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                unchecked {
                    uint diff = (a & mask) - (b & mask);
                    if (diff != 0)
                        return int(diff);
                }
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }

    /*
     * @dev Returns true if the two slices contain the same text.
     * @param self The first slice to compare.
     * @param self The second slice to compare.
     * @return True if the slices are equal, false otherwise.
     */
    function equals(slice memory self, slice memory other) internal pure returns (bool) {
        return compare(self, other) == 0;
    }

    /*
     * @dev Extracts the first rune in the slice into `rune`, advancing the
     *      slice to point to the next rune and returning `self`.
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    /*
     * @dev Returns the first rune in the slice, advancing the slice to point
     *      to the next rune.
     * @param self The slice to operate on.
     * @return A slice containing only the first rune from `self`.
     */
    function nextRune(slice memory self) internal pure returns (slice memory ret) {
        nextRune(self, ret);
    }

    /*
     * @dev Returns the number of the first codepoint in the slice.
     * @param self The slice to operate on.
     * @return The number of the first codepoint in the slice.
     */
    function ord(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Returns the keccak-256 hash of the slice.
     * @param self The slice to hash.
     * @return The hash of the slice.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @dev Returns true if `self` starts with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        if (self._ptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let selfptr := mload(add(self, 0x20))
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }
        return equal;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    /*
     * @dev Returns true if the slice ends with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        uint selfptr = self._ptr + self._len - needle._len;

        if (selfptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }

        return equal;
    }

    /*
     * @dev If `self` ends with `needle`, `needle` is removed from the
     *      end of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        uint selfptr = self._ptr + self._len - needle._len;
        bool equal = true;
        if (selfptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask;
                if (needlelen > 0) {
                    mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                }

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

    // Returns the memory address of the first byte after the last occurrence of
    // `needle` in `self`, or the address of `self` if not found.
    function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask;
                if (needlelen > 0) {
                    mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
                }

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                ptr = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr <= selfptr)
                        return selfptr;
                    ptr--;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr + needlelen;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }
                ptr = selfptr + (selflen - needlelen);
                while (ptr >= selfptr) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr + needlelen;
                    ptr -= 1;
                }
            }
        }
        return selfptr;
    }

    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len -= ptr - self._ptr;
        self._ptr = ptr;
        return self;
    }

    /*
     * @dev Modifies `self` to contain the part of the string from the start of
     *      `self` to the end of the first occurrence of `needle`. If `needle`
     *      is not found, `self` is set to the empty slice.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len = ptr - self._ptr;
        return self;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and `token` to everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = self._ptr;
        token._len = ptr - self._ptr;
        if (ptr == self._ptr + self._len) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
            self._ptr = ptr + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and returning everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` up to the first occurrence of `delim`.
     */
    function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        split(self, needle, token);
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and `token` to everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = ptr;
        token._len = self._len - (ptr - self._ptr);
        if (ptr == self._ptr) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and returning everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` after the last occurrence of `delim`.
     */
    function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        rsplit(self, needle, token);
    }

    /*
     * @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return The number of occurrences of `needle` found in `self`.
     */
    function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
        while (ptr <= self._ptr + self._len) {
            cnt++;
            ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
        }
    }

    /*
     * @dev Returns True if `self` contains `needle`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return True if `needle` is found in `self`, false otherwise.
     */
    function contains(slice memory self, slice memory needle) internal pure returns (bool) {
        return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
    }

    /*
     * @dev Returns a newly allocated string containing the concatenation of
     *      `self` and `other`.
     * @param self The first slice to concatenate.
     * @param other The second slice to concatenate.
     * @return The concatenation of the two strings.
     */
    function concat(slice memory self, slice memory other) internal pure returns (string memory) {
        string memory ret = new string(self._len + other._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }
        memcpy(retptr, self._ptr, self._len);
        memcpy(retptr + self._len, other._ptr, other._len);
        return ret;
    }

    /*
     * @dev Joins an array of slices, using `self` as a delimiter, returning a
     *      newly allocated string.
     * @param self The delimiter to use.
     * @param parts A list of slices to join.
     * @return A newly allocated string containing all the slices in `parts`,
     *         joined with `self`.
     */
    function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
        if (parts.length == 0)
            return "";

        uint length = self._len * (parts.length - 1);
        for(uint i = 0; i < parts.length; i++)
            length += parts[i]._len;

        string memory ret = new string(length);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        for(uint i = 0; i < parts.length; i++) {
            memcpy(retptr, parts[i]._ptr, parts[i]._len);
            retptr += parts[i]._len;
            if (i < parts.length - 1) {
                memcpy(retptr, self._ptr, self._len);
                retptr += self._len;
            }
        }

        return ret;
    }

    /**
     * Lower
     * 
     * Converts all the values of a string to their corresponding lower case
     * value.
     * 
     * @param _base When being used for a data type this is the extended object
     *              otherwise this is the string base to convert to lower case
     * @return string 
     */
    function lower(string memory _base)
        internal
        pure
        returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        for (uint i = 0; i < _baseBytes.length; i++) {
            _baseBytes[i] = _lower(_baseBytes[i]);
        }
        return string(_baseBytes);
    }

    /**
     * Lower
     * 
     * Convert an alphabetic character to lower case and return the original
     * value when not alphabetic
     * 
     * @param _b1 The byte to be converted to lower case
     * @return bytes1 The converted value if the passed value was alphabetic
     *                and in a upper case otherwise returns the original value
     */
    function _lower(bytes1 _b1)
        private
        pure
        returns (bytes1) {

        if (_b1 >= 0x41 && _b1 <= 0x5A) {
            return bytes1(uint8(_b1) + 32);
        }

        return _b1;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"string","name":"dName","type":"string"},{"indexed":false,"internalType":"string","name":"dTld","type":"string"}],"name":"CustomDefaultDomainSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"tAddr","type":"address"}],"name":"DeprecatedTldAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"tAddr","type":"address"}],"name":"DeprecatedTldRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"fAddr","type":"address"}],"name":"FactoryAddressAdded","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"},{"inputs":[{"internalType":"address","name":"_deprecatedTldAddress","type":"address"}],"name":"addDeprecatedTldAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_factoryAddress","type":"address"}],"name":"addFactoryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"customDefaultDomain","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"factories","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"string","name":"_tld","type":"string"}],"name":"getDefaultDomain","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getDefaultDomains","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"string","name":"_tld","type":"string"}],"name":"getDomainData","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"string","name":"_tld","type":"string"}],"name":"getDomainHolder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"string","name":"_tld","type":"string"}],"name":"getDomainTokenUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFactoriesArray","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getFirstDefaultDomain","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_tldName","type":"string"}],"name":"getTldAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_tldName","type":"string"}],"name":"getTldFactoryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTlds","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isTldDeprecated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_deprecatedTldAddress","type":"address"}],"name":"removeDeprecatedTldAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_addrIndex","type":"uint256"}],"name":"removeFactoryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"string","name":"_tld","type":"string"}],"name":"setCustomDefaultDomain","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b5061001a3361001f565b61006f565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6127638061007e6000396000f3fe608060405234801561001057600080fd5b50600436106101375760003560e01c80636e94cac9116100b8578063959923281161007c5780639599232814610291578063b9f24d7b146102a4578063cc1b2d02146102b7578063d1406151146102ca578063f267a10c146102df578063f2fde38b146102f257600080fd5b80636e94cac91461023f578063715018a61461025257806371c033fc1461025a5780638da5cb5b1461026d578063924e8a6b1461027e57600080fd5b80635b20cf39116100ff5780635b20cf39146101a857806362169a77146101d357806363d5eee8146101e6578063672383c4146102195780636d3437fb1461022c57600080fd5b8063124b356b1461013c57806318c0c695146101515780632c49faf01461016457806345cbd82a1461018d57806357951ea8146101a0575b600080fd5b61014f61014a3660046120d6565b610305565b005b61014f61015f3660046120d6565b6103a8565b61017761017236600461215c565b610443565b6040516101849190612560565b60405180910390f35b61014f61019b3660046122af565b6104f0565b61017761065c565b6101bb6101b6366004612249565b61089a565b6040516001600160a01b039091168152602001610184565b6101bb6101e1366004612249565b610a0c565b6102096101f43660046120d6565b60026020526000908152604090205460ff1681565b6040519015158152602001610184565b6101bb610227366004612384565b610b3d565b61017761023a3660046120d6565b610b67565b61017761024d3660046122af565b610e7f565b61014f6110a8565b6101776102683660046120d6565b6110de565b6000546001600160a01b03166101bb565b61014f61028c366004612384565b61152f565b61017761029f36600461210e565b611632565b6101776102b23660046122af565b6117b8565b6101bb6102c53660046122af565b6118e2565b6102d2611a66565b6040516101849190612513565b61014f6102ed3660046120d6565b611ac8565b61014f6103003660046120d6565b611b39565b6000546001600160a01b031633146103385760405162461bcd60e51b815260040161032f90612573565b60405180910390fd5b6001600160a01b0381166000908152600260205260409020805460ff191660011790557ff847dbe1168b3644f67f33bf127627062cb7a1777ac983fa83e44edb57989b226103833390565b604080516001600160a01b03928316815291841660208301520160405180910390a150565b6000546001600160a01b031633146103d25760405162461bcd60e51b815260040161032f90612573565b6001805480820182556000919091527fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf60180546001600160a01b0319166001600160a01b0383161790557f5928fa36137089d200461b1b8492840afb1c250ed4dc142dc2bc16f9ca40748933610383565b6003602052816000526040600020816002811061045f57600080fd5b01805490925061046f9150612696565b80601f016020809104026020016040519081016040528092919081815260200182805461049b90612696565b80156104e85780601f106104bd576101008083540402835291602001916104e8565b820191906000526020600020905b8154815290600101906020018083116104cb57829003601f168201915b505050505081565b60008251118015610502575060008151115b156105ec573361051283836118e2565b6001600160a01b0316146105685760405162461bcd60e51b815260206004820152601b60248201527f596f7520646f206e6f74206f776e207468697320646f6d61696e2e0000000000604482015260640161032f565b604051806040016040528083815260200182815250600360006105883390565b6001600160a01b0316815260208101919091526040016000206105ac916002611ee6565b507f8c02f1e7e95aacf499fb03fc1ce7e26584464d505ef15b6b3246e8573aa0bcba3383836040516105e0939291906124d3565b60405180910390a15050565b33600090815260036020526040812061060491611f36565b7f8c02f1e7e95aacf499fb03fc1ce7e26584464d505ef15b6b3246e8573aa0bcba33604080516001600160a01b039092168252606060208301819052600090830181905260809183018290529082015260a0016105e0565b600154606090819060005b818110156108925760006001828154811061069257634e487b7160e01b600052603260045260246000fd5b60009182526020822001546040805163ebe7321760e01b815290516001600160a01b039092169263ebe7321792600480840193829003018186803b1580156106d957600080fd5b505afa1580156106ed573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526107159190810190612187565b905060005b815181101561088857600082828151811061074557634e487b7160e01b600052603260045260246000fd5b6020026020010151905060006001858154811061077257634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d5906107ab908590600401612560565b60206040518083038186803b1580156107c357600080fd5b505afa1580156107d7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107fb91906120f2565b6001600160a01b03811660009081526002602052604090205490915060ff16610875578682610834836001600160a01b03166014611bd4565b604051602001610845929190612489565b60408051601f198184030181529082905261086392916020016123c8565b60405160208183030381529060405296505b505080610881906126d1565b905061071a565b5050600101610667565b509092915050565b600154600090815b81811015610a02576000600182815481106108cd57634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590610906908890600401612560565b60206040518083038186803b15801561091e57600080fd5b505afa158015610932573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061095691906120f2565b90506001600160a01b0381161580159061098957506001600160a01b03811660009081526002602052604090205460ff16155b156109cd57600182815481106109af57634e487b7160e01b600052603260045260246000fd5b6000918252602090912001546001600160a01b031695945050505050565b6001600160a01b03811660009081526002602052604090205460ff16156109f957506000949350505050565b506001016108a2565b5060009392505050565b600154600090815b81811015610a0257600060018281548110610a3f57634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590610a78908890600401612560565b60206040518083038186803b158015610a9057600080fd5b505afa158015610aa4573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ac891906120f2565b90506001600160a01b03811615801590610afb57506001600160a01b03811660009081526002602052604090205460ff16155b15610b0857949350505050565b6001600160a01b03811660009081526002602052604090205460ff1615610b3457506000949350505050565b50600101610a14565b60018181548110610b4d57600080fd5b6000918252602090912001546001600160a01b0316905081565b600154606090819060005b81811015610e7657600060018281548110610b9d57634e487b7160e01b600052603260045260246000fd5b60009182526020822001546040805163ebe7321760e01b815290516001600160a01b039092169263ebe7321792600480840193829003018186803b158015610be457600080fd5b505afa158015610bf8573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610c209190810190612187565b905060005b8151811015610e6c576000828281518110610c5057634e487b7160e01b600052603260045260246000fd5b60200260200101519050600060018581548110610c7d57634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590610cb6908590600401612560565b60206040518083038186803b158015610cce57600080fd5b505afa158015610ce2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d0691906120f2565b6040516318ab1ea160e21b81526001600160a01b038b811660048301529192506000918316906362ac7a849060240160006040518083038186803b158015610d4d57600080fd5b505afa158015610d61573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610d89919081019061227c565b90506000610dc6610dc18360408051808201825260008082526020918201528151808301909252825182529182019181019190915290565b611dbd565b118015610dec57506001600160a01b03821660009081526002602052604090205460ff16155b15610e585760018551610dff9190612638565b841415610e3157878184604051602001610e1b939291906123f7565b6040516020818303038152906040529750610e58565b878184604051602001610e469392919061243a565b60405160208183030381529060405297505b50505080610e65906126d1565b9050610c25565b5050600101610b72565b50909392505050565b60015460609060005b8181101561108d57600060018281548110610eb357634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590610eec908890600401612560565b60206040518083038186803b158015610f0457600080fd5b505afa158015610f18573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f3c91906120f2565b90506001600160a01b03811615801590610f6f57506001600160a01b03811660009081526002602052604090205460ff16155b1561108457604051632644923560e01b81526000906001600160a01b03831690632644923590610fa3908a90600401612560565b60006040518083038186803b158015610fbb57600080fd5b505afa158015610fcf573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610ff79190810190612306565b505060405163c87b56dd60e01b8152600481018290529092506001600160a01b038416915063c87b56dd9060240160006040518083038186803b15801561103d57600080fd5b505afa158015611051573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611079919081019061227c565b9450505050506110a2565b50600101610e88565b50604051806020016040528060008152509150505b92915050565b6000546001600160a01b031633146110d25760405162461bcd60e51b815260040161032f90612573565b6110dc6000611e96565b565b6001600160a01b03811660009081526003602052604080822081518083019092526060929190600283835b828210156111ac57838201805461111f90612696565b80601f016020809104026020016040519081016040528092919081815260200182805461114b90612696565b80156111985780601f1061116d57610100808354040283529160200191611198565b820191906000526020600020905b81548152906001019060200180831161117b57829003601f168201915b505050505081526020019060010190611109565b5050505090506000816000600281106111d557634e487b7160e01b600052603260045260246000fd5b6020020151511180156111ec575060208101515115155b1561124857805160208201516001600160a01b0385169161120c916118e2565b6001600160a01b031614156112485780516020808301516040516112319392016123c8565b604051602081830303815290604052915050919050565b60015460005b818110156115175760006001828154811061127957634e487b7160e01b600052603260045260246000fd5b60009182526020822001546040805163ebe7321760e01b815290516001600160a01b039092169263ebe7321792600480840193829003018186803b1580156112c057600080fd5b505afa1580156112d4573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526112fc9190810190612187565b905060005b815181101561150d57600082828151811061132c57634e487b7160e01b600052603260045260246000fd5b6020026020010151905060006001858154811061135957634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590611392908590600401612560565b60206040518083038186803b1580156113aa57600080fd5b505afa1580156113be573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113e291906120f2565b6040516318ab1ea160e21b81526001600160a01b038b811660048301529192506000918316906362ac7a849060240160006040518083038186803b15801561142957600080fd5b505afa15801561143d573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611465919081019061227c565b9050600061149d610dc18360408051808201825260008082526020918201528151808301909252825182529182019181019190915290565b1180156114c357506001600160a01b03821660009081526002602052604090205460ff16155b156114f95780836040516020016114db9291906123c8565b60405160208183030381529060405298505050505050505050919050565b50505080611506906126d1565b9050611301565b505060010161124e565b50506040805160208101909152600081529392505050565b6000546001600160a01b031633146115595760405162461bcd60e51b815260040161032f90612573565b60018054611568908290612638565b8154811061158657634e487b7160e01b600052603260045260246000fd5b600091825260209091200154600180546001600160a01b0390921691839081106115c057634e487b7160e01b600052603260045260246000fd5b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550600180548061160d57634e487b7160e01b600052603160045260246000fd5b600082815260209020810160001990810180546001600160a01b031916905501905550565b60015460609060005b8181101561108d5760006001828154811061166657634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d59061169f908890600401612560565b60206040518083038186803b1580156116b757600080fd5b505afa1580156116cb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116ef91906120f2565b90506001600160a01b0381161580159061172257506001600160a01b03811660009081526002602052604090205460ff16155b156117af576040516318ab1ea160e21b81526001600160a01b0387811660048301528216906362ac7a84906024015b60006040518083038186803b15801561176957600080fd5b505afa15801561177d573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526117a5919081019061227c565b93505050506110a2565b5060010161163b565b60015460609060005b8181101561108d576000600182815481106117ec57634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d590611825908890600401612560565b60206040518083038186803b15801561183d57600080fd5b505afa158015611851573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061187591906120f2565b90506001600160a01b038116158015906118a857506001600160a01b03811660009081526002602052604090205460ff16155b156118d957604051637afdfb4f60e01b81526001600160a01b03821690637afdfb4f90611751908990600401612560565b506001016117c1565b600154600090815b81811015611a5b5760006001828154811061191557634e487b7160e01b600052603260045260246000fd5b60009182526020909120015460405163399122d560e01b81526001600160a01b039091169063399122d59061194e908890600401612560565b60206040518083038186803b15801561196657600080fd5b505afa15801561197a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061199e91906120f2565b90506001600160a01b038116158015906119d157506001600160a01b03811660009081526002602052604090205460ff16155b15611a525760405163bfcdd7c360e01b81526001600160a01b0382169063bfcdd7c390611a02908990600401612560565b60206040518083038186803b158015611a1a57600080fd5b505afa158015611a2e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117a591906120f2565b506001016118ea565b506000949350505050565b60606001805480602002602001604051908101604052809291908181526020018280548015611abe57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311611aa0575b5050505050905090565b6000546001600160a01b03163314611af25760405162461bcd60e51b815260040161032f90612573565b6001600160a01b0381166000908152600260205260409020805460ff191690557f9bb0227be14fac452f137fab7d0f8e1fb0441159a8b26f843c02355e4340eaa933610383565b6000546001600160a01b03163314611b635760405162461bcd60e51b815260040161032f90612573565b6001600160a01b038116611bc85760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161032f565b611bd181611e96565b50565b60606000611be3836002612619565b611bee906002612601565b67ffffffffffffffff811115611c1457634e487b7160e01b600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015611c3e576020820181803683370190505b509050600360fc1b81600081518110611c6757634e487b7160e01b600052603260045260246000fd5b60200101906001600160f81b031916908160001a905350600f60fb1b81600181518110611ca457634e487b7160e01b600052603260045260246000fd5b60200101906001600160f81b031916908160001a9053506000611cc8846002612619565b611cd3906001612601565b90505b6001811115611d67576f181899199a1a9b1b9c1cb0b131b232b360811b85600f1660108110611d1557634e487b7160e01b600052603260045260246000fd5b1a60f81b828281518110611d3957634e487b7160e01b600052603260045260246000fd5b60200101906001600160f81b031916908160001a90535060049490941c93611d608161267f565b9050611cd6565b508315611db65760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e74604482015260640161032f565b9392505050565b600080601f8360200151611dd19190612638565b8351909150600090611de39083612601565b9050600092505b80821015611e8f57815160ff166080811015611e1257611e0b600184612601565b9250611e7c565b60e08160ff161015611e2957611e0b600284612601565b60f08160ff161015611e4057611e0b600384612601565b60f88160ff161015611e5757611e0b600484612601565b60fc8160ff161015611e6e57611e0b600584612601565b611e79600684612601565b92505b5082611e87816126d1565b935050611dea565b5050919050565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b8260028101928215611f26579160200282015b82811115611f265782518051611f16918491602090910190611f52565b5091602001919060010190611ef9565b50611f32929150611fd2565b5090565b506000611f438282611fef565b506110dc906001016000611fef565b828054611f5e90612696565b90600052602060002090601f016020900481019282611f805760008555611fc6565b82601f10611f9957805160ff1916838001178555611fc6565b82800160010185558215611fc6579182015b82811115611fc6578251825591602001919060010190611fab565b50611f32929150612025565b80821115611f32576000611fe68282611fef565b50600101611fd2565b508054611ffb90612696565b6000825580601f1061200b575050565b601f016020900490600052602060002090810190611bd191905b5b80821115611f325760008155600101612026565b600082601f83011261204a578081fd5b813561205d612058826125d9565b6125a8565b818152846020838601011115612071578283fd5b816020850160208301379081016020019190915292915050565b600082601f83011261209b578081fd5b81516120a9612058826125d9565b8181528460208386010111156120bd578283fd5b6120ce82602083016020870161264f565b949350505050565b6000602082840312156120e7578081fd5b8135611db681612718565b600060208284031215612103578081fd5b8151611db681612718565b60008060408385031215612120578081fd5b823561212b81612718565b9150602083013567ffffffffffffffff811115612146578182fd5b6121528582860161203a565b9150509250929050565b6000806040838503121561216e578182fd5b823561217981612718565b946020939093013593505050565b60006020808385031215612199578182fd5b825167ffffffffffffffff808211156121b0578384fd5b818501915085601f8301126121c3578384fd5b8151818111156121d5576121d5612702565b8060051b6121e48582016125a8565b8281528581019085870183870188018b10156121fe578889fd5b8893505b8484101561223b5780518681111561221857898afd5b6122268c8a838b010161208b565b84525060019390930192918701918701612202565b509998505050505050505050565b60006020828403121561225a578081fd5b813567ffffffffffffffff811115612270578182fd5b6120ce8482850161203a565b60006020828403121561228d578081fd5b815167ffffffffffffffff8111156122a3578182fd5b6120ce8482850161208b565b600080604083850312156122c1578182fd5b823567ffffffffffffffff808211156122d8578384fd5b6122e48683870161203a565b935060208501359150808211156122f9578283fd5b506121528582860161203a565b6000806000806080858703121561231b578182fd5b845167ffffffffffffffff80821115612332578384fd5b61233e8883890161208b565b9550602087015194506040870151915061235782612718565b60608701519193508082111561236b578283fd5b506123788782880161208b565b91505092959194509250565b600060208284031215612395578081fd5b5035919050565b600081518084526123b481602086016020860161264f565b601f01601f19169290920160200192915050565b600083516123da81846020880161264f565b8351908301906123ee81836020880161264f565b01949350505050565b6000845161240981846020890161264f565b84519083019061241d81836020890161264f565b845191019061243081836020880161264f565b0195945050505050565b6000845161244c81846020890161264f565b84519083019061246081836020890161264f565b845191019061247381836020880161264f565b600160fd1b910190815260010195945050505050565b6000835161249b81846020880161264f565b600b60fa1b90830190815283516124b981600184016020880161264f565b600560f91b60019290910191820152600201949350505050565b6001600160a01b03841681526060602082018190526000906124f79083018561239c565b8281036040840152612509818561239c565b9695505050505050565b6020808252825182820181905260009190848201906040850190845b818110156125545783516001600160a01b03168352928401929184019160010161252f565b50909695505050505050565b602081526000611db6602083018461239c565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b604051601f8201601f1916810167ffffffffffffffff811182821017156125d1576125d1612702565b604052919050565b600067ffffffffffffffff8211156125f3576125f3612702565b50601f01601f191660200190565b60008219821115612614576126146126ec565b500190565b6000816000190483118215151615612633576126336126ec565b500290565b60008282101561264a5761264a6126ec565b500390565b60005b8381101561266a578181015183820152602001612652565b83811115612679576000848401525b50505050565b60008161268e5761268e6126ec565b506000190190565b600181811c908216806126aa57607f821691505b602082108114156126cb57634e487b7160e01b600052602260045260246000fd5b50919050565b60006000198214156126e5576126e56126ec565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b0381168114611bd157600080fdfea2646970667358221220dc7b06a5183ba4bd1eb461a5bc448f6b71d97a3a6650981e5ffd7a0853e1e5a064736f6c63430008040033

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