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 { OwnableWithManagers } from "../../access/OwnableWithManagers.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../../lib/strings.sol";

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

// generic minter contract (ERC-20 token for payment)
// - no minting restrictions (anyone can mint)
// - erc-20 token payment
// - two team addresses
contract MinterErc20MultiplePrices is OwnableWithManagers, ReentrancyGuard {
  address public devAddress;
  address public teamAddress;
  address public immutable tokenAddress;

  bool public paused = false;

  uint256 public referralFee = 1000; // share of each domain purchase (in bips) that goes to the referrer
  uint256 public constant MAX_BPS = 10_000;

  uint256 public price1char; // 1 char domain price
  uint256 public price2char; // 2 chars domain price
  uint256 public price3char; // 3 chars domain price
  uint256 public price4char; // 4 chars domain price
  uint256 public price5char; // 5 chars domain price
  uint256 public price6char; // 6+ chars domain price

  IFlexiPunkTLD public immutable tldContract;

  // CONSTRUCTOR
  constructor(
    address _tldAddress,
    address _devAddress,
    address _teamAddress,
    address _tokenAddress,
    uint256 _price1char,
    uint256 _price2char,
    uint256 _price3char,
    uint256 _price4char,
    uint256 _price5char,
    uint256 _price6char
  ) {
    tldContract = IFlexiPunkTLD(_tldAddress);
    devAddress = _devAddress;
    teamAddress = _teamAddress;
    tokenAddress = _tokenAddress;

    price1char = _price1char;
    price2char = _price2char;
    price3char = _price3char;
    price4char = _price4char;
    price5char = _price5char;
    price6char = _price6char;
  }

  // WRITE

  function mint(
    string memory _domainName,
    address _domainHolder,
    address _referrer
  ) external nonReentrant returns(uint256 tokenId) {
    require(!paused, "Minting paused");

    // find price
    uint256 domainLength = strings.len(strings.toSlice(_domainName));
    uint256 selectedPrice;

    if (domainLength == 1) {
      selectedPrice = price1char;
    } else if (domainLength == 2) {
      selectedPrice = price2char;
    } else if (domainLength == 3) {
      selectedPrice = price3char;
    } else if (domainLength == 4) {
      selectedPrice = price4char;
    } else if (domainLength == 5) {
      selectedPrice = price5char;
    } else {
      selectedPrice = price6char;
    }

    // send referral fee
    if (referralFee > 0 && _referrer != address(0)) {
      uint256 referralPayment = (selectedPrice * referralFee) / 10_000;
      selectedPrice -= referralPayment;
      IERC20(tokenAddress).transferFrom(msg.sender, _referrer, referralPayment);
    }

    // send team fees (half-half)
    IERC20(tokenAddress).transferFrom(msg.sender, devAddress, selectedPrice / 2);

    selectedPrice -= selectedPrice / 2;
    IERC20(tokenAddress).transferFrom(msg.sender, teamAddress, selectedPrice);

    // mint a domain
    tokenId = tldContract.mint{value: 0}(_domainName, _domainHolder, address(0));
  }

  // OWNER

  /// @notice This changes price in the minter contract
  function changePrice(uint256 _price, uint256 _chars) external onlyManagerOrOwner {
    require(_price > 0, "Cannot be zero");

    if (_chars == 1) {
      price1char = _price;
    } else if (_chars == 2) {
      price2char = _price;
    } else if (_chars == 3) {
      price3char = _price;
    } else if (_chars == 4) {
      price4char = _price;
    } else if (_chars == 5) {
      price5char = _price;
    } else if (_chars == 6) {
      price6char = _price;
    }
  }

  /// @notice This changes referral fee in the minter contract
  function changeReferralFee(uint256 _referralFee) external onlyManagerOrOwner {
    require(_referralFee <= 2000, "Cannot exceed 20%");
    referralFee = _referralFee;
  }

  function changeDevAddress(address _devAddress) external onlyManagerOrOwner {
    devAddress = _devAddress;
  }

  function changeTeamAddress(address _teamAddress) external onlyManagerOrOwner {
    teamAddress = _teamAddress;
  }

  function ownerFreeMint(
    string memory _domainName,
    address _domainHolder
  ) external nonReentrant onlyManagerOrOwner returns(uint256 tokenId) {
    // mint a domain
    tokenId = tldContract.mint{value: 0}(_domainName, _domainHolder, address(0));
  }

  /// @notice Recover any ERC-20 token mistakenly sent to this contract address
  function recoverERC20(address tokenAddress_, uint256 tokenAmount_, address recipient_) external onlyManagerOrOwner {
    IERC20(tokenAddress_).transfer(recipient_, tokenAmount_);
  }

  function togglePaused() external onlyManagerOrOwner {
    paused = !paused;
  }

  // recover ETH from contract
  function withdraw() external onlyManagerOrOwner {
    (bool success, ) = msg.sender.call{value: address(this).balance}("");
    require(success, "Failed to withdraw ETH from contract");
  }
 
}

// 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 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// 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: GPL-3.0-or-later
pragma solidity 0.8.4;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

/** 
@title Extended Ownable contract with managers functionality
@author Tempe Techie
*/
abstract contract OwnableWithManagers is Ownable {
  address[] public managers; // array of managers
  mapping (address => bool) public isManager; // mapping of managers

  // MODIFIERS
  modifier onlyManagerOrOwner() {
    require(isManager[msg.sender] || msg.sender == owner(), "OwnableWithManagers: caller is not a manager or owner");
    _;
  }

  // EVENTS
  event ManagerAdd(address indexed owner_, address indexed manager_);
  event ManagerRemove(address indexed owner_, address indexed manager_);

  // READ
  function getManagers() external view returns (address[] memory) {
    return managers;
  }

  function getManagersLength() external view returns (uint256) {
    return managers.length;
  }

  // MANAGER
  
  function removeYourselfAsManager() external onlyManagerOrOwner {
    address manager_ = msg.sender;

    isManager[manager_] = false;
    uint256 length = managers.length;

    for (uint256 i = 0; i < length;) {
      if (managers[i] == manager_) {
        managers[i] = managers[length - 1];
        managers.pop();
        emit ManagerRemove(msg.sender, manager_);
        return;
      }

      unchecked {
        i++;
      }
    }
  }

  // OWNER

  function addManager(address manager_) external onlyOwner {
    require(!isManager[manager_], "OwnableWithManagers: manager already added");
    isManager[manager_] = true;
    managers.push(manager_);
    emit ManagerAdd(msg.sender, manager_);
  }

  function removeManagerByAddress(address manager_) external onlyOwner {
    isManager[manager_] = false;
    uint256 length = managers.length;

    for (uint256 i = 0; i < length;) {
      if (managers[i] == manager_) {
        managers[i] = managers[length - 1];
        managers.pop();
        emit ManagerRemove(msg.sender, manager_);
        return;
      }

      unchecked {
        i++;
      }
    }
  }

  function removeManagerByIndex(uint256 index_) external onlyOwner {
    emit ManagerRemove(msg.sender, managers[index_]);
    isManager[managers[index_]] = false;
    managers[index_] = managers[managers.length - 1];
    managers.pop();
  }
}

// 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

[{"inputs":[{"internalType":"address","name":"_tldAddress","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_teamAddress","type":"address"},{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_price1char","type":"uint256"},{"internalType":"uint256","name":"_price2char","type":"uint256"},{"internalType":"uint256","name":"_price3char","type":"uint256"},{"internalType":"uint256","name":"_price4char","type":"uint256"},{"internalType":"uint256","name":"_price5char","type":"uint256"},{"internalType":"uint256","name":"_price6char","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner_","type":"address"},{"indexed":true,"internalType":"address","name":"manager_","type":"address"}],"name":"ManagerAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner_","type":"address"},{"indexed":true,"internalType":"address","name":"manager_","type":"address"}],"name":"ManagerRemove","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":[],"name":"MAX_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"manager_","type":"address"}],"name":"addManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"changeDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"uint256","name":"_chars","type":"uint256"}],"name":"changePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_referralFee","type":"uint256"}],"name":"changeReferralFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_teamAddress","type":"address"}],"name":"changeTeamAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getManagers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getManagersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"managers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"address","name":"_domainHolder","type":"address"},{"internalType":"address","name":"_referrer","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_domainName","type":"string"},{"internalType":"address","name":"_domainHolder","type":"address"}],"name":"ownerFreeMint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price1char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price2char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price3char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price4char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price5char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price6char","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress_","type":"address"},{"internalType":"uint256","name":"tokenAmount_","type":"uint256"},{"internalType":"address","name":"recipient_","type":"address"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"referralFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"manager_","type":"address"}],"name":"removeManagerByAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index_","type":"uint256"}],"name":"removeManagerByIndex","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"removeYourselfAsManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"teamAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tldContract","outputs":[{"internalType":"contract IFlexiPunkTLD","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"togglePaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101fb5760003560e01c806384ae2bc61161011a578063b51609b4116100ad578063f0f0784e1161007c578063f0f0784e146103fd578063f2fde38b14610410578063f3ae241514610423578063f883a69614610446578063fd967f471461045957600080fd5b8063b51609b4146103d1578063b7002309146103e4578063d570fb34146103ec578063df4b86b2146103f457600080fd5b80639d76ea58116100e95780639d76ea5814610379578063a8d088bb146103a0578063aae5c344146103b5578063b3de019c146103be57600080fd5b806384ae2bc61461032557806385eb407e1461032e5780638da5cb5b1461035557806392b463901461036657600080fd5b80633ccfd60b1161019257806361d3f3fe1161016157806361d3f3fe146102ee578063715018a6146102f757806378a6743b146102ff5780637e6d945e1461031257600080fd5b80633ccfd60b1461029c5780633d39c260146102a45780635ab5de8a146102b75780635c975abb146102ca57600080fd5b80632d06177a116101ce5780632d06177a1461025957806336566f061461026e5780633ad10ef6146102765780633aee69bb1461028957600080fd5b806301204bcc146102005780631c75f0851461021c5780631dce11fe14610247578063248758bd14610250575b600080fd5b610209600b5481565b6040519081526020015b60405180910390f35b60055461022f906001600160a01b031681565b6040516001600160a01b039091168152602001610213565b610209600c5481565b61020960095481565b61026c610267366004611727565b610462565b005b61026c61059d565b60045461022f906001600160a01b031681565b61026c610297366004611727565b610602565b61026c610668565b61022f6102b2366004611842565b610753565b61026c6102c5366004611727565b61077d565b6005546102de90600160a01b900460ff1681565b6040519015158152602001610213565b61020960085481565b61026c610936565b61026c61030d366004611842565b61096c565b6102096103203660046117ef565b6109fb565b61020960065481565b61022f7f000000000000000000000000c2c543d39426bfd1db66bbde2dd9e4a5c721287681565b6000546001600160a01b031661022f565b61026c610374366004611727565b610e79565b61022f7f000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be881565b6103a8610edf565b6040516102139190611893565b61020960075481565b61026c6103cc366004611872565b610f41565b61026c6103df366004611748565b611024565b61026c6110f0565b600154610209565b610209600a5481565b61020961040b3660046117a3565b6111b2565b61026c61041e366004611727565b611304565b6102de610431366004611727565b60026020526000908152604090205460ff1681565b61026c610454366004611842565b61139c565b61020961271081565b6000546001600160a01b031633146104955760405162461bcd60e51b815260040161048c90611959565b60405180910390fd5b6001600160a01b03811660009081526002602052604090205460ff16156105115760405162461bcd60e51b815260206004820152602a60248201527f4f776e61626c65576974684d616e61676572733a206d616e6167657220616c726044820152691958591e48185919195960b21b606482015260840161048c565b6001600160a01b038116600081815260026020526040808220805460ff19166001908117909155805480820182559083527fb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf60180546001600160a01b031916841790555133917ffef4b799044e6259138adfd04ab1cca8b2442cc484dd25672ae344fa8a9e208b91a350565b3360009081526002602052604090205460ff16806105c557506000546001600160a01b031633145b6105e15760405162461bcd60e51b815260040161048c9061198e565b6005805460ff60a01b198116600160a01b9182900460ff1615909102179055565b3360009081526002602052604090205460ff168061062a57506000546001600160a01b031633145b6106465760405162461bcd60e51b815260040161048c9061198e565b600580546001600160a01b0319166001600160a01b0392909216919091179055565b3360009081526002602052604090205460ff168061069057506000546001600160a01b031633145b6106ac5760405162461bcd60e51b815260040161048c9061198e565b604051600090339047908381818185875af1925050503d80600081146106ee576040519150601f19603f3d011682016040523d82523d6000602084013e6106f3565b606091505b50509050806107505760405162461bcd60e51b8152602060048201526024808201527f4661696c656420746f207769746864726177204554482066726f6d20636f6e746044820152631c9858dd60e21b606482015260840161048c565b50565b6001818154811061076357600080fd5b6000918252602090912001546001600160a01b0316905081565b6000546001600160a01b031633146107a75760405162461bcd60e51b815260040161048c90611959565b6001600160a01b0381166000908152600260205260408120805460ff19169055600154905b8181101561093157826001600160a01b0316600182815481106107ff57634e487b7160e01b600052603260045260246000fd5b6000918252602090912001546001600160a01b031614156109295760016108268184611a3a565b8154811061084457634e487b7160e01b600052603260045260246000fd5b600091825260209091200154600180546001600160a01b03909216918390811061087e57634e487b7160e01b600052603260045260246000fd5b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b0316021790555060018054806108cb57634e487b7160e01b600052603160045260246000fd5b600082815260208120820160001990810180546001600160a01b03191690559091019091556040516001600160a01b0385169133917fc322b4d5159f72837eec184e14dde68867f91c6da39449fb9829f42121fc704d9190a3505050565b6001016107cc565b505050565b6000546001600160a01b031633146109605760405162461bcd60e51b815260040161048c90611959565b61096a600061155b565b565b3360009081526002602052604090205460ff168061099457506000546001600160a01b031633145b6109b05760405162461bcd60e51b815260040161048c9061198e565b6107d08111156109f65760405162461bcd60e51b815260206004820152601160248201527043616e6e6f74206578636565642032302560781b604482015260640161048c565b600655565b600060026003541415610a505760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161048c565b6002600355600554600160a01b900460ff1615610aa05760405162461bcd60e51b815260206004820152600e60248201526d135a5b9d1a5b99c81c185d5cd95960921b604482015260640161048c565b6000610adb610ad68660408051808201825260008082526020918201528151808301909252825182529182019181019190915290565b6115ab565b905060008160011415610af15750600754610b3e565b8160021415610b035750600854610b3e565b8160031415610b155750600954610b3e565b8160041415610b275750600a54610b3e565b8160051415610b395750600b54610b3e565b50600c545b6000600654118015610b5857506001600160a01b03841615155b15610c3657600061271060065483610b709190611a1b565b610b7a91906119fb565b9050610b868183611a3a565b6040516323b872dd60e01b81523360048201526001600160a01b038781166024830152604482018490529193507f000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be8909116906323b872dd90606401602060405180830381600087803b158015610bfb57600080fd5b505af1158015610c0f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c339190611783565b50505b6004546001600160a01b037f000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be88116916323b872dd91339116610c796002866119fb565b6040516001600160e01b031960e086901b1681526001600160a01b0393841660048201529290911660248301526044820152606401602060405180830381600087803b158015610cc857600080fd5b505af1158015610cdc573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d009190611783565b50610d0c6002826119fb565b610d169082611a3a565b6005546040516323b872dd60e01b81523360048201526001600160a01b039182166024820152604481018390529192507f000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be816906323b872dd90606401602060405180830381600087803b158015610d8c57600080fd5b505af1158015610da0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610dc49190611783565b50604051633f36ca2f60e11b81526001600160a01b037f000000000000000000000000c2c543d39426bfd1db66bbde2dd9e4a5c72128761690637e6d945e90600090610e18908a908a9084906004016118e0565b6020604051808303818588803b158015610e3157600080fd5b505af1158015610e45573d6000803e3d6000fd5b50505050506040513d601f19601f82011682018060405250810190610e6a919061185a565b60016003559695505050505050565b3360009081526002602052604090205460ff1680610ea157506000546001600160a01b031633145b610ebd5760405162461bcd60e51b815260040161048c9061198e565b600480546001600160a01b0319166001600160a01b0392909216919091179055565b60606001805480602002602001604051908101604052809291908181526020018280548015610f3757602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311610f19575b5050505050905090565b3360009081526002602052604090205460ff1680610f6957506000546001600160a01b031633145b610f855760405162461bcd60e51b815260040161048c9061198e565b60008211610fc65760405162461bcd60e51b815260206004820152600e60248201526d43616e6e6f74206265207a65726f60901b604482015260640161048c565b8060011415610fd55750600755565b8060021415610fe45750600855565b8060031415610ff35750600955565b80600414156110025750600a55565b80600514156110115750600b55565b806006141561102057600c8290555b5050565b3360009081526002602052604090205460ff168061104c57506000546001600160a01b031633145b6110685760405162461bcd60e51b815260040161048c9061198e565b60405163a9059cbb60e01b81526001600160a01b0382811660048301526024820184905284169063a9059cbb90604401602060405180830381600087803b1580156110b257600080fd5b505af11580156110c6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110ea9190611783565b50505050565b3360009081526002602052604090205460ff168061111857506000546001600160a01b031633145b6111345760405162461bcd60e51b815260040161048c9061198e565b336000818152600260205260408120805460ff19169055600154905b8181101561093157826001600160a01b03166001828154811061118357634e487b7160e01b600052603260045260246000fd5b6000918252602090912001546001600160a01b031614156111aa5760016108268184611a3a565b600101611150565b6000600260035414156112075760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161048c565b60026003819055336000908152602091909152604090205460ff168061123757506000546001600160a01b031633145b6112535760405162461bcd60e51b815260040161048c9061198e565b604051633f36ca2f60e11b81526001600160a01b037f000000000000000000000000c2c543d39426bfd1db66bbde2dd9e4a5c72128761690637e6d945e906000906112a6908790879084906004016118e0565b6020604051808303818588803b1580156112bf57600080fd5b505af11580156112d3573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906112f8919061185a565b60016003559392505050565b6000546001600160a01b0316331461132e5760405162461bcd60e51b815260040161048c90611959565b6001600160a01b0381166113935760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161048c565b6107508161155b565b6000546001600160a01b031633146113c65760405162461bcd60e51b815260040161048c90611959565b600181815481106113e757634e487b7160e01b600052603260045260246000fd5b60009182526020822001546040516001600160a01b039091169133917fc322b4d5159f72837eec184e14dde68867f91c6da39449fb9829f42121fc704d9190a36000600260006001848154811061144e57634e487b7160e01b600052603260045260246000fd5b6000918252602080832091909101546001600160a01b031683528201929092526040019020805460ff191691151591909117905560018054611491908290611a3a565b815481106114af57634e487b7160e01b600052603260045260246000fd5b600091825260209091200154600180546001600160a01b0390921691839081106114e957634e487b7160e01b600052603260045260246000fd5b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550600180548061153657634e487b7160e01b600052603160045260246000fd5b600082815260209020810160001990810180546001600160a01b031916905501905550565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b600080601f83602001516115bf9190611a3a565b83519091506000906115d190836119e3565b9050600092505b8082101561167d57815160ff166080811015611600576115f96001846119e3565b925061166a565b60e08160ff161015611617576115f96002846119e3565b60f08160ff16101561162e576115f96003846119e3565b60f88160ff161015611645576115f96004846119e3565b60fc8160ff16101561165c576115f96005846119e3565b6116676006846119e3565b92505b508261167581611a51565b9350506115d8565b5050919050565b80356001600160a01b038116811461169b57600080fd5b919050565b600082601f8301126116b0578081fd5b813567ffffffffffffffff808211156116cb576116cb611a82565b604051601f8301601f19908116603f011681019082821181831017156116f3576116f3611a82565b8160405283815286602085880101111561170b578485fd5b8360208701602083013792830160200193909352509392505050565b600060208284031215611738578081fd5b61174182611684565b9392505050565b60008060006060848603121561175c578182fd5b61176584611684565b92506020840135915061177a60408501611684565b90509250925092565b600060208284031215611794578081fd5b81518015158114611741578182fd5b600080604083850312156117b5578182fd5b823567ffffffffffffffff8111156117cb578283fd5b6117d7858286016116a0565b9250506117e660208401611684565b90509250929050565b600080600060608486031215611803578283fd5b833567ffffffffffffffff811115611819578384fd5b611825868287016116a0565b93505061183460208501611684565b915061177a60408501611684565b600060208284031215611853578081fd5b5035919050565b60006020828403121561186b578081fd5b5051919050565b60008060408385031215611884578182fd5b50508035926020909101359150565b6020808252825182820181905260009190848201906040850190845b818110156118d45783516001600160a01b0316835292840192918401916001016118af565b50909695505050505050565b6060815260008451806060840152815b8181101561190d57602081880181015160808684010152016118f0565b8181111561191e5782608083860101525b506001600160a01b0385166020840152601f01601f19168201608001905061195160408301846001600160a01b03169052565b949350505050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526035908201527f4f776e61626c65576974684d616e61676572733a2063616c6c6572206973206e60408201527437ba10309036b0b730b3b2b91037b91037bbb732b960591b606082015260800190565b600082198211156119f6576119f6611a6c565b500190565b600082611a1657634e487b7160e01b81526012600452602481fd5b500490565b6000816000190483118215151615611a3557611a35611a6c565b500290565b600082821015611a4c57611a4c611a6c565b500390565b6000600019821415611a6557611a65611a6c565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fdfea26469706673582212201929b7e8f20c0f2f31cdd1fcd10b385245c3b791e6b583077c0230ea4eb1460464736f6c63430008040033

000000000000000000000000c2c543d39426bfd1db66bbde2dd9e4a5c7212876000000000000000000000000b29050965a5ac70ab487aa47546cdcbc97dae45d0000000000000000000000001e7487b34cdef80536f70e085ac875d7b7cc6812000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be80000000000000000000000000000000000000000033b2e3c9fd0803ce800000000000000000000000000000000000000000000000052b7d2dcc80cd2e400000000000000000000000000000000000000000000000018d0bf423c03d8de00000000000000000000000000000000000000000000000000a968163f0a57b4000000000000000000000000000000000000000000000000002a5a058fc295ed000000000000000000000000000000000000000000000000000a968163f0a57b400000

-----Decoded View---------------
Arg [0] : _tldAddress (address): 0xc2C543D39426bfd1dB66bBde2Dd9E4a5c7212876
Arg [1] : _devAddress (address): 0xb29050965A5AC70ab487aa47546cdCBc97dAE45D
Arg [2] : _teamAddress (address): 0x1e7487b34CDeF80536F70e085AC875d7b7cC6812
Arg [3] : _tokenAddress (address): 0xb65aD8d81d1E4Cb2975352338805AF6e39BA8Be8
Arg [4] : _price1char (uint256): 1000000000000000000000000000
Arg [5] : _price2char (uint256): 100000000000000000000000000
Arg [6] : _price3char (uint256): 30000000000000000000000000
Arg [7] : _price4char (uint256): 800000000000000000000000
Arg [8] : _price5char (uint256): 200000000000000000000000
Arg [9] : _price6char (uint256): 50000000000000000000000

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 000000000000000000000000c2c543d39426bfd1db66bbde2dd9e4a5c7212876
Arg [1] : 000000000000000000000000b29050965a5ac70ab487aa47546cdcbc97dae45d
Arg [2] : 0000000000000000000000001e7487b34cdef80536f70e085ac875d7b7cc6812
Arg [3] : 000000000000000000000000b65ad8d81d1e4cb2975352338805af6e39ba8be8
Arg [4] : 0000000000000000000000000000000000000000033b2e3c9fd0803ce8000000
Arg [5] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Arg [6] : 00000000000000000000000000000000000000000018d0bf423c03d8de000000
Arg [7] : 00000000000000000000000000000000000000000000a968163f0a57b4000000
Arg [8] : 000000000000000000000000000000000000000000002a5a058fc295ed000000
Arg [9] : 000000000000000000000000000000000000000000000a968163f0a57b400000