Polygon Sponsored slots available. Book your slot here!
ERC-721
Overview
Max Total Supply
431 SS
Holders
187
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
4 SSLoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
SoldiersSociety
Compiler Version
v0.7.6+commit.7338295f
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2021-11-11 */ // Sources flattened with hardhat v2.3.3 https://hardhat.org // File @openzeppelin/contracts/utils/[email protected] // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <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 GSN 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 payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File @openzeppelin/contracts/access/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @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() internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), 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 { emit OwnershipTransferred(_owner, address(0)); _owner = 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" ); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File @openzeppelin/contracts/math/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } // File @openzeppelin/contracts/token/ERC20/[email protected] pragma solidity >=0.6.0 <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 ); } // File @openzeppelin/contracts/utils/[email protected] pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{value: amount}(""); require( success, "Address: unable to send value, recipient may have reverted" ); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, "Address: low-level call with value failed" ); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require( address(this).balance >= value, "Address: insufficient balance for call" ); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value: value}( data ); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall( target, data, "Address: low-level static call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/token/ERC20/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn( token, abi.encodeWithSelector(token.transfer.selector, to, value) ); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn( token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value) ); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn( token, abi.encodeWithSelector(token.approve.selector, spender, value) ); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).add( value ); _callOptionalReturn( token, abi.encodeWithSelector( token.approve.selector, spender, newAllowance ) ); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).sub( value, "SafeERC20: decreased allowance below zero" ); _callOptionalReturn( token, abi.encodeWithSelector( token.approve.selector, spender, newAllowance ) ); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall( data, "SafeERC20: low-level call failed" ); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require( abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed" ); } } } // File @openzeppelin/contracts/introspection/[email protected] pragma solidity >=0.6.0 <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); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.2 <0.8.0; /** * @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; } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.2 <0.8.0; /** * @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); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.2 <0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File @openzeppelin/contracts/introspection/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ abstract contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor() internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require( set._values.length > index, "EnumerableSet: index out of bounds" ); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping(bytes32 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function _set( Map storage map, bytes32 key, bytes32 value ) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({_key: key, _value: value})); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function _remove(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require( map._entries.length > index, "EnumerableMap: index out of bounds" ); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key) return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } /** * @dev Same as {_get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {_tryGet}. */ function _get( Map storage map, bytes32 key, string memory errorMessage ) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( UintToAddressMap storage map, uint256 key, address value ) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } /** * @dev Returns the element stored at position `index` in the set. O(1). * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint160(uint256(value)))); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. * * _Available since v3.4._ */ function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) { (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key)); return (success, address(uint160(uint256(value)))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key))))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get( UintToAddressMap storage map, uint256 key, string memory errorMessage ) internal view returns (address) { return address( uint160(uint256(_get(map._inner, bytes32(key), errorMessage))) ); } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @dev String operations. */ library Strings { /** * @dev Converts a `uint256` to its ASCII `string` 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); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = bytes1(uint8(48 + (temp % 10))); temp /= 10; } return string(buffer); } } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping(address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require( owner != address(0), "ERC721: balance query for the zero address" ); return _holderTokens[owner].length(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { return _tokenOwners.get( tokenId, "ERC721: owner query for nonexistent token" ); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require( _exists(tokenId), "ERC721Metadata: URI query for nonexistent token" ); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(base, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view virtual returns (string memory) { return _baseURI; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require( _exists(tokenId), "ERC721: approved query for nonexistent token" ); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved" ); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved" ); _safeTransfer(from, to, tokenId, _data); } /** * @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. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require( _exists(tokenId), "ERC721: operator query for nonexistent token" ); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: d* * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory _data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); // internal owner _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require( ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own" ); // internal owner require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require( _exists(tokenId), "ERC721Metadata: URI set of nonexistent token" ); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall( abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer" ); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity >=0.6.0 <0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be irreversibly burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved" ); _burn(tokenId); } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity >=0.6.0 <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() internal { _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 make 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; } } // File contracts/helpers/ContextMixin.sol pragma solidity ^0.7.6; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/ContextMixin.sol */ abstract contract ContextMixin { function msgSender() internal view returns (address payable sender) { if (msg.sender == address(this)) { bytes memory array = msg.data; uint256 index = msg.data.length; assembly { // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those. sender := and( mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff ) } } else { sender = payable(msg.sender); } return sender; } } // File contracts/helpers/Initializable.sol pragma solidity ^0.7.6; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/Initializable.sol */ contract Initializable { bool inited = false; modifier initializer() { require(!inited, "already inited"); _; inited = true; } } // File contracts/helpers/EIP712Base.sol pragma solidity ^0.7.6; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/EIP712Base.sol */ contract EIP712Base is Initializable { struct EIP712Domain { string name; string version; address verifyingContract; bytes32 salt; } string public constant ERC712_VERSION = "1"; bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256( bytes( "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)" ) ); bytes32 internal domainSeperator; // supposed to be called once while initializing. // one of the contractsa that inherits this contract follows proxy pattern // so it is not possible to do this in a constructor function _initializeEIP712(string memory name) internal initializer { _setDomainSeperator(name); } function _setDomainSeperator(string memory name) internal { domainSeperator = keccak256( abi.encode( EIP712_DOMAIN_TYPEHASH, keccak256(bytes(name)), keccak256(bytes(ERC712_VERSION)), address(this), bytes32(getChainId()) ) ); } function getDomainSeperator() public view returns (bytes32) { return domainSeperator; } function getChainId() public view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } /** * Accept message hash and returns hash message in EIP712 compatible form * So that it can be used to recover signer from signature signed using EIP712 formatted data * https://eips.ethereum.org/EIPS/eip-712 * "\\x19" makes the encoding deterministic * "\\x01" is the version byte to make it compatible to EIP-191 */ function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) { return keccak256( abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash) ); } } // File contracts/helpers/NativeMetaTransaction.sol pragma solidity ^0.7.6; /** * https://github.com/maticnetwork/pos-portal/blob/master/contracts/common/NativeMetaTransaction.sol */ contract NativeMetaTransaction is EIP712Base { bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256( bytes( "MetaTransaction(uint256 nonce,address from,bytes functionSignature)" ) ); event MetaTransactionExecuted( address userAddress, address payable relayerAddress, bytes functionSignature ); mapping(address => uint256) nonces; /* * Meta transaction structure. * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas * He should call the desired function directly in that case. */ struct MetaTransaction { uint256 nonce; address from; bytes functionSignature; } function executeMetaTransaction( address userAddress, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV ) public payable returns (bytes memory) { MetaTransaction memory metaTx = MetaTransaction({ nonce: nonces[userAddress], from: userAddress, functionSignature: functionSignature }); require( verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match" ); // increase nonce for user (to avoid re-use) nonces[userAddress] = nonces[userAddress] + 1; emit MetaTransactionExecuted( userAddress, payable(msg.sender), functionSignature ); // Append userAddress and relayer address at the end to extract it from calling context (bool success, bytes memory returnData) = address(this).call( abi.encodePacked(functionSignature, userAddress) ); require(success, "Function call not successful"); return returnData; } function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) { return keccak256( abi.encode( META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature) ) ); } function getNonce(address user) public view returns (uint256 nonce) { nonce = nonces[user]; } function verify( address signer, MetaTransaction memory metaTx, bytes32 sigR, bytes32 sigS, uint8 sigV ) internal view returns (bool) { require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER"); return signer == ecrecover( toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS ); } } // File contracts/SoldiersSociety.sol pragma solidity ^0.7.6; pragma abicoder v2; contract SoldiersSociety is ERC721Burnable, ContextMixin, NativeMetaTransaction, ReentrancyGuard, Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; uint256 public constant pricePerSoldier = 500 ether; uint256 public constant maximumSupply = 3333; uint256 public constant reservedSupply = 111; uint256 public unmintedSupply; IERC20 public immutable xedContract; address public immutable paymentSplitterContract; bool public saleActive; constructor( string memory _name, string memory _symbol, IERC20 _xedContract, address _paymentSplitterContract ) ERC721(_name, _symbol) { xedContract = _xedContract; paymentSplitterContract = _paymentSplitterContract; _initializeEIP712(_name); // Mint the reserved supply unmintedSupply = maximumSupply - reservedSupply; for (uint256 i = 0; i < reservedSupply; i++) { _safeMint(msg.sender, i); } } /** ** Users */ function mint(uint256 _amount) external nonReentrant { require(saleActive, "Sale is not active"); require(_amount > 0, "Nothing to mint"); require(_amount <= 100, "Too many to mint"); uint256 previousUnmintedSupply = unmintedSupply; unmintedSupply = previousUnmintedSupply.sub( _amount, "Not enough available" ); xedContract.safeTransferFrom( msg.sender, address(this), _amount.mul(pricePerSoldier) ); for (uint256 i = 0; i < _amount; i++) { uint256 tokenId = maximumSupply - previousUnmintedSupply + i; _safeMint(msg.sender, tokenId); } } function withdraw() external { uint256 available = xedContract.balanceOf(address(this)); require(available > 0, "Nothing to withdraw"); // Until the end of the tournament (2021-12-05 23:59:59), send the funds to the payment splitter contract. if (block.timestamp < 1638748800) { xedContract.safeTransfer(paymentSplitterContract, available); } else { xedContract.safeTransfer(owner(), available); } } /** ** Owner */ function startSale() external onlyOwner { require(!saleActive, "Sale is already active"); saleActive = true; } /** ** OpenSea and Standards */ function tokenURI(uint256 _tokenId) public pure override returns (string memory) { return string( abi.encodePacked( "ipfs://QmbBEpAvdKJhwtZNEZGf1K4S1wxL9CLPBMdT44Y4vesrnq/", Strings.toString(_tokenId), ".json" ) ); } function isApprovedForAll(address _owner, address _operator) public view override returns (bool) { if (_operator == address(0x58807baD0B376efc12F5AD86aAc70E78ed67deaE)) { return true; } return super.isApprovedForAll(_owner, _operator); } function _msgSender() internal view override returns (address payable sender) { return ContextMixin.msgSender(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"contract IERC20","name":"_xedContract","type":"address"},{"internalType":"address","name":"_paymentSplitterContract","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maximumSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paymentSplitterContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePerSoldier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unmintedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xedContract","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
60c0604052600a805460ff191690553480156200001b57600080fd5b5060405162003b3638038062003b368339810160408190526200003e9162000955565b8383620000526301ffc9a760e01b6200016d565b81516200006790600690602085019062000806565b5080516200007d90600790602084019062000806565b50620000906380ac58cd60e01b6200016d565b620000a2635b5e139f60e01b6200016d565b620000b463780e9d6360e01b6200016d565b50506001600d556000620000c7620001c8565b600e80546001600160a01b0319166001600160a01b038316908117909155604051919250906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a3506001600160601b0319606083811b821660805282901b1660a0526200013a84620001e5565b610c96600f5560005b606f811015620001625762000159338262000226565b60010162000143565b505050505062000c98565b6001600160e01b03198082161415620001a35760405162461bcd60e51b81526004016200019a9062000b04565b60405180910390fd5b6001600160e01b0319166000908152602081905260409020805460ff19166001179055565b6000620001df6200024c60201b620011a41760201c565b90505b90565b600a5460ff16156200020b5760405162461bcd60e51b81526004016200019a9062000bed565b6200021681620002aa565b50600a805460ff19166001179055565b620002488282604051806020016040528060008152506200034c60201b60201c565b5050565b600033301415620002a557600080368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b03169150620001e29050565b503390565b6040518060800160405280604f815260200162003ae7604f913980516020918201208251838301206040805180820190915260018152603160f81b930192909252907fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc630620003186200038b565b6040516200032e95949392919060200162000a71565b60408051601f198184030181529190528051602090910120600b5550565b6200035883836200038f565b6200036760008484846200047d565b620003865760405162461bcd60e51b81526004016200019a9062000ab2565b505050565b4690565b6001600160a01b038216620003b85760405162461bcd60e51b81526004016200019a9062000bb8565b620003c38162000582565b15620003e35760405162461bcd60e51b81526004016200019a9062000b3b565b620003f16000838362000386565b6001600160a01b03821660009081526001602090815260409091206200042291839062001200620005a5821b17901c565b506200044081836002620005ba60201b6200120c179092919060201c565b5060405181906001600160a01b038416906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b60006200049e846001600160a01b0316620005d260201b6200122c1760201c565b620004ac575060016200057a565b600062000548630a85bd0160e11b620004c4620001c8565b888787604051602401620004dc949392919062000a32565b604051602081830303815290604052906001600160e01b0319166020820180516001600160e01b03838183161783525050505060405180606001604052806032815260200162003ab560329139876001600160a01b0316620005d860201b62001232179092919060201c565b90506000818060200190518101906200056291906200092b565b6001600160e01b031916630a85bd0160e11b14925050505b949350505050565b60006200059f826002620005e960201b620012411790919060201c565b92915050565b6000620005b38383620005f7565b9392505050565b60006200057a84846001600160a01b03851662000646565b3b151590565b60606200057a8484600085620006e1565b6000620005b38383620007b0565b6000620006058383620007b0565b6200063d575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556200059f565b5060006200059f565b600082815260018401602052604081205480620006ad575050604080518082018252838152602080820184815286546001818101895560008981528481209551600290930290950191825591519082015586548684528188019092529290912055620005b3565b82856000016001830381548110620006c157fe5b9060005260206000209060020201600101819055506000915050620005b3565b606082471015620007065760405162461bcd60e51b81526004016200019a9062000b72565b6200071185620005d2565b620007305760405162461bcd60e51b81526004016200019a9062000c15565b600080866001600160a01b031685876040516200074e919062000a14565b60006040518083038185875af1925050503d80600081146200078d576040519150601f19603f3d011682016040523d82523d6000602084013e62000792565b606091505b509092509050620007a5828286620007c8565b979650505050505050565b60009081526001919091016020526040902054151590565b60608315620007d9575081620005b3565b825115620007ea5782518084602001fd5b8160405162461bcd60e51b81526004016200019a919062000a9d565b828054600181600116156101000203166002900490600052602060002090601f0160209004810192826200083e576000855562000889565b82601f106200085957805160ff191683800117855562000889565b8280016001018555821562000889579182015b82811115620008895782518255916020019190600101906200086c565b50620008979291506200089b565b5090565b5b808211156200089757600081556001016200089c565b600082601f830112620008c3578081fd5b81516001600160401b0380821115620008d857fe5b604051601f8301601f191681016020018281118282101715620008f757fe5b6040528281528483016020018610156200090f578384fd5b6200092283602083016020880162000c4c565b95945050505050565b6000602082840312156200093d578081fd5b81516001600160e01b031981168114620005b3578182fd5b600080600080608085870312156200096b578283fd5b84516001600160401b038082111562000982578485fd5b6200099088838901620008b2565b95506020870151915080821115620009a6578485fd5b50620009b587828801620008b2565b9350506040850151620009c88162000c7f565b6060860151909250620009db8162000c7f565b939692955090935050565b6000815180845262000a0081602086016020860162000c4c565b601f01601f19169290920160200192915050565b6000825162000a2881846020870162000c4c565b9190910192915050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009062000a6790830184620009e6565b9695505050505050565b948552602085019390935260408401919091526001600160a01b03166060830152608082015260a00190565b600060208252620005b36020830184620009e6565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b6020808252601c908201527f4552433136353a20696e76616c696420696e7465726661636520696400000000604082015260600190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b60208082526026908201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6040820152651c8818d85b1b60d21b606082015260800190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b6020808252600e908201526d185b1c9958591e481a5b9a5d195960921b604082015260600190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b60005b8381101562000c6957818101518382015260200162000c4f565b8381111562000c79576000848401525b50505050565b6001600160a01b038116811462000c9557600080fd5b50565b60805160601c60a05160601c612dda62000cdb600039806109a75280610b0f5250806109455280610a2d5280610aed5280610b4e5280610ea35250612dda6000f3fe60806040526004361061020f5760003560e01c806342966c68116101185780638da5cb5b116100a0578063b66a0e5d1161006f578063b66a0e5d1461056b578063b88d4fde14610580578063c87b56dd146105a0578063e985e9c5146105c0578063f2fde38b146105e05761020f565b80638da5cb5b1461050157806395d89b4114610516578063a0712d681461052b578063a22cb4651461054b5761020f565b806368428a1b116100e757806368428a1b1461048d5780636c0360eb146104a257806370a08231146104b7578063715018a6146104d75780637ec158f2146104ec5761020f565b806342966c681461041857806344d19d2b146104385780634f6ccce71461044d5780636352211e1461046d5761020f565b80631d024fcd1161019b5780632d0335ab1161016a5780632d0335ab1461038e5780632f745c59146103ae5780633408e470146103ce5780633ccfd60b146103e357806342842e0e146103f85761020f565b80631d024fcd1461032f57806320379ee51461034457806323b872dd1461035957806329642f41146103795761020f565b8063095ea7b3116101e2578063095ea7b3146102bb5780630c53c51c146102dd5780630f7e5970146102f057806313f740f11461030557806318160ddd1461031a5761020f565b806301ffc9a7146102145780630480e58b1461024a57806306fdde031461026c578063081812fc1461028e575b600080fd5b34801561022057600080fd5b5061023461022f36600461229b565b610600565b60405161024191906124d3565b60405180910390f35b34801561025657600080fd5b5061025f610623565b60405161024191906124de565b34801561027857600080fd5b50610281610629565b6040516102419190612529565b34801561029a57600080fd5b506102ae6102a93660046122d3565b6106c0565b6040516102419190612410565b3480156102c757600080fd5b506102db6102d6366004612256565b61070c565b005b6102816102eb3660046121dd565b6107a9565b3480156102fc57600080fd5b50610281610908565b34801561031157600080fd5b5061025f610925565b34801561032657600080fd5b5061025f610932565b34801561033b57600080fd5b506102ae610943565b34801561035057600080fd5b5061025f610967565b34801561036557600080fd5b506102db610374366004612106565b61096d565b34801561038557600080fd5b506102ae6109a5565b34801561039a57600080fd5b5061025f6103a93660046120ba565b6109c9565b3480156103ba57600080fd5b5061025f6103c9366004612256565b6109e4565b3480156103da57600080fd5b5061025f610a0f565b3480156103ef57600080fd5b506102db610a13565b34801561040457600080fd5b506102db610413366004612106565b610b78565b34801561042457600080fd5b506102db6104333660046122d3565b610b93565b34801561044457600080fd5b5061025f610bc3565b34801561045957600080fd5b5061025f6104683660046122d3565b610bc8565b34801561047957600080fd5b506102ae6104883660046122d3565b610bde565b34801561049957600080fd5b50610234610c06565b3480156104ae57600080fd5b50610281610c0f565b3480156104c357600080fd5b5061025f6104d23660046120ba565b610c70565b3480156104e357600080fd5b506102db610cb9565b3480156104f857600080fd5b5061025f610d42565b34801561050d57600080fd5b506102ae610d48565b34801561052257600080fd5b50610281610d57565b34801561053757600080fd5b506102db6105463660046122d3565b610db8565b34801561055757600080fd5b506102db6105663660046121a7565b610efb565b34801561057757600080fd5b506102db610fc9565b34801561058c57600080fd5b506102db61059b366004612141565b61103a565b3480156105ac57600080fd5b506102816105bb3660046122d3565b611079565b3480156105cc57600080fd5b506102346105db3660046120d4565b6110aa565b3480156105ec57600080fd5b506102db6105fb3660046120ba565b6110e3565b6001600160e01b0319811660009081526020819052604090205460ff165b919050565b610d0581565b60068054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156106b55780601f1061068a576101008083540402835291602001916106b5565b820191906000526020600020905b81548152906001019060200180831161069857829003601f168201915b505050505090505b90565b60006106cb8261124d565b6106f05760405162461bcd60e51b81526004016106e7906129e7565b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b600061071782610bde565b9050806001600160a01b0316836001600160a01b0316141561074b5760405162461bcd60e51b81526004016106e790612af2565b806001600160a01b031661075d61125a565b6001600160a01b0316148061077e575061077e8161077961125a565b611264565b61079a5760405162461bcd60e51b81526004016106e790612888565b6107a48383611292565b505050565b60408051606081810183526001600160a01b0388166000818152600c6020908152908590205484528301529181018690526107e78782878787611300565b6108035760405162461bcd60e51b81526004016106e790612ab1565b6001600160a01b0387166000908152600c60205260409081902080546001019055517f5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b9061085690899033908a90612461565b60405180910390a1600080306001600160a01b0316888a60405160200161087e92919061234b565b60408051601f19818403018152908290526108989161232f565b6000604051808303816000865af19150503d80600081146108d5576040519150601f19603f3d011682016040523d82523d6000602084013e6108da565b606091505b5091509150816108fc5760405162461bcd60e51b81526004016106e79061269c565b98975050505050505050565b604051806040016040528060018152602001603160f81b81525081565b681b1ae4d6e2ef50000081565b600061093e60026113a6565b905090565b7f000000000000000000000000000000000000000000000000000000000000000081565b600b5490565b61097e61097861125a565b826113b1565b61099a5760405162461bcd60e51b81526004016106e790612b33565b6107a4838383611436565b7f000000000000000000000000000000000000000000000000000000000000000081565b6001600160a01b03166000908152600c602052604090205490565b6001600160a01b0382166000908152600160205260408120610a069083611544565b90505b92915050565b4690565b6040516370a0823160e01b81526000906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906370a0823190610a62903090600401612410565b60206040518083038186803b158015610a7a57600080fd5b505afa158015610a8e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ab291906122eb565b905060008111610ad45760405162461bcd60e51b81526004016106e7906125d7565b6361ad5280421015610b3957610b346001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000167f000000000000000000000000000000000000000000000000000000000000000083611550565b610b75565b610b75610b44610d48565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169083611550565b50565b6107a48383836040518060200160405280600081525061103a565b610b9e61097861125a565b610bba5760405162461bcd60e51b81526004016106e790612c66565b610b75816115a6565b606f81565b600080610bd6600284611673565b509392505050565b6000610a0982604051806060016040528060298152602001612d7c602991396002919061168f565b60105460ff1681565b60098054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156106b55780601f1061068a576101008083540402835291602001916106b5565b60006001600160a01b038216610c985760405162461bcd60e51b81526004016106e7906128e5565b6001600160a01b0382166000908152600160205260409020610a09906113a6565b610cc161125a565b6001600160a01b0316610cd2610d48565b6001600160a01b031614610cf85760405162461bcd60e51b81526004016106e790612a33565b600e546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600e80546001600160a01b0319169055565b600f5481565b600e546001600160a01b031690565b60078054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156106b55780601f1061068a576101008083540402835291602001916106b5565b6002600d541415610ddb5760405162461bcd60e51b81526004016106e790612c2f565b6002600d5560105460ff16610e025760405162461bcd60e51b81526004016106e790612785565b60008111610e225760405162461bcd60e51b81526004016106e79061253c565b6064811115610e435760405162461bcd60e51b81526004016106e790612bbb565b600f546040805180820190915260148152734e6f7420656e6f75676820617661696c61626c6560601b6020820152610e7e908290849061169c565b600f55610ecb3330610e9985681b1ae4d6e2ef5000006116c8565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016929190611702565b60005b82811015610ef157610d058290038101610ee83382611723565b50600101610ece565b50506001600d5550565b610f0361125a565b6001600160a01b0316826001600160a01b03161415610f345760405162461bcd60e51b81526004016106e79061274e565b8060056000610f4161125a565b6001600160a01b03908116825260208083019390935260409182016000908120918716808252919093529120805460ff191692151592909217909155610f8561125a565b6001600160a01b03167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610fbd91906124d3565b60405180910390a35050565b610fd161125a565b6001600160a01b0316610fe2610d48565b6001600160a01b0316146110085760405162461bcd60e51b81526004016106e790612a33565b60105460ff161561102b5760405162461bcd60e51b81526004016106e7906125a7565b6010805460ff19166001179055565b61104b61104561125a565b836113b1565b6110675760405162461bcd60e51b81526004016106e790612b33565b61107384848484611741565b50505050565b606061108482611774565b604051602001611094919061239d565b6040516020818303038152906040529050919050565b60006001600160a01b0382167358807bad0b376efc12f5ad86aac70e78ed67deae14156110d957506001610a09565b610a068383611264565b6110eb61125a565b6001600160a01b03166110fc610d48565b6001600160a01b0316146111225760405162461bcd60e51b81526004016106e790612a33565b6001600160a01b0381166111485760405162461bcd60e51b81526004016106e790612656565b600e546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600e80546001600160a01b0319166001600160a01b0392909216919091179055565b6000333014156111fb57600080368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b031691506106bd9050565b503390565b6000610a06838361184f565b600061122284846001600160a01b038516611899565b90505b9392505050565b3b151590565b60606112228484600085611930565b6000610a0683836119f0565b6000610a09600283611241565b600061093e6111a4565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b600081815260046020526040902080546001600160a01b0319166001600160a01b03841690811790915581906112c782610bde565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60006001600160a01b0386166113285760405162461bcd60e51b81526004016106e790612843565b600161133b61133687611a08565b611a66565b8386866040516000815260200160405260405161135b949392919061250b565b6020604051602081039080840390855afa15801561137d573d6000803e3d6000fd5b505050602060405103516001600160a01b0316866001600160a01b031614905095945050505050565b6000610a0982611a82565b60006113bc8261124d565b6113d85760405162461bcd60e51b81526004016106e7906127f7565b60006113e383610bde565b9050806001600160a01b0316846001600160a01b0316148061141e5750836001600160a01b0316611413846106c0565b6001600160a01b0316145b8061142e575061142e8185611264565b949350505050565b826001600160a01b031661144982610bde565b6001600160a01b03161461146f5760405162461bcd60e51b81526004016106e790612a68565b6001600160a01b0382166114955760405162461bcd60e51b81526004016106e79061270a565b6114a08383836107a4565b6114ab600082611292565b6001600160a01b03831660009081526001602052604090206114cd9082611a86565b506001600160a01b03821660009081526001602052604090206114f09082611200565b506114fd6002828461120c565b5080826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b6000610a068383611a92565b6107a48363a9059cbb60e01b848460405160240161156f9291906124ba565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b031990931692909217909152611ad7565b60006115b182610bde565b90506115bf816000846107a4565b6115ca600083611292565b600082815260086020526040902054600260001961010060018416150201909116041561160857600082815260086020526040812061160891611fd6565b6001600160a01b038116600090815260016020526040902061162a9083611a86565b50611636600283611b66565b5060405182906000906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a45050565b60008080806116828686611b72565b9097909650945050505050565b6000611222848484611bce565b600081848411156116c05760405162461bcd60e51b81526004016106e79190612529565b505050900390565b6000826116d757506000610a09565b828202828482816116e457fe5b0414610a065760405162461bcd60e51b81526004016106e7906129a6565b611073846323b872dd60e01b85858560405160240161156f93929190612496565b61173d828260405180602001604052806000815250611c2d565b5050565b61174c848484611436565b61175884848484611c60565b6110735760405162461bcd60e51b81526004016106e790612604565b60608161179957506040805180820190915260018152600360fc1b602082015261061e565b8160005b81156117b157600101600a8204915061179d565b60008167ffffffffffffffff811180156117ca57600080fd5b506040519080825280601f01601f1916602001820160405280156117f5576020820181803683370190505b50859350905060001982015b831561184657600a840660300160f81b8282806001900393508151811061182457fe5b60200101906001600160f81b031916908160001a905350600a84049350611801565b50949350505050565b600061185b83836119f0565b61189157508154600181810184556000848152602080822090930184905584548482528286019093526040902091909155610a09565b506000610a09565b6000828152600184016020526040812054806118fe575050604080518082018252838152602080820184815286546001818101895560008981528481209551600290930290950191825591519082015586548684528188019092529290912055611225565b8285600001600183038154811061191157fe5b9060005260206000209060020201600101819055506000915050611225565b6060824710156119525760405162461bcd60e51b81526004016106e7906127b1565b61195b8561122c565b6119775760405162461bcd60e51b81526004016106e790612b84565b600080866001600160a01b03168587604051611993919061232f565b60006040518083038185875af1925050503d80600081146119d0576040519150601f19603f3d011682016040523d82523d6000602084013e6119d5565b606091505b50915091506119e5828286611d3f565b979650505050505050565b60009081526001919091016020526040902054151590565b6000604051806080016040528060438152602001612d396043913980516020918201208351848301516040808701518051908601209051611a4995016124e7565b604051602081830303815290604052805190602001209050919050565b6000611a70610967565b82604051602001611a49929190612382565b5490565b6000610a068383611d78565b81546000908210611ab55760405162461bcd60e51b81526004016106e790612565565b826000018281548110611ac457fe5b9060005260206000200154905092915050565b6000611b2c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166112329092919063ffffffff16565b8051909150156107a45780806020019051810190611b4a919061227f565b6107a45760405162461bcd60e51b81526004016106e790612be5565b6000610a068383611e3e565b815460009081908310611b975760405162461bcd60e51b81526004016106e79061292f565b6000846000018481548110611ba857fe5b906000526020600020906002020190508060000154816001015492509250509250929050565b60008281526001840160205260408120548281611bfe5760405162461bcd60e51b81526004016106e79190612529565b50846000016001820381548110611c1157fe5b9060005260206000209060020201600101549150509392505050565b611c378383611f12565b611c446000848484611c60565b6107a45760405162461bcd60e51b81526004016106e790612604565b6000611c74846001600160a01b031661122c565b611c805750600161142e565b6000611d08630a85bd0160e11b611c9561125a565b888787604051602401611cab9493929190612424565b604051602081830303815290604052906001600160e01b0319166020820180516001600160e01b038381831617835250505050604051806060016040528060328152602001612d07603291396001600160a01b0388169190611232565b9050600081806020019051810190611d2091906122b7565b6001600160e01b031916630a85bd0160e11b1492505050949350505050565b60608315611d4e575081611225565b825115611d5e5782518084602001fd5b8160405162461bcd60e51b81526004016106e79190612529565b60008181526001830160205260408120548015611e345783546000198083019190810190600090879083908110611dab57fe5b9060005260206000200154905080876000018481548110611dc857fe5b600091825260208083209091019290925582815260018981019092526040902090840190558654879080611df857fe5b60019003818190600052602060002001600090559055866001016000878152602001908152602001600020600090556001945050505050610a09565b6000915050610a09565b60008181526001830160205260408120548015611e345783546000198083019190810190600090879083908110611e7157fe5b9060005260206000209060020201905080876000018481548110611e9157fe5b600091825260208083208454600290930201918255600193840154918401919091558354825289830190526040902090840190558654879080611ed057fe5b6000828152602080822060026000199094019384020182815560019081018390559290935588815289820190925260408220919091559450610a099350505050565b6001600160a01b038216611f385760405162461bcd60e51b81526004016106e790612971565b611f418161124d565b15611f5e5760405162461bcd60e51b81526004016106e7906126d3565b611f6a600083836107a4565b6001600160a01b0382166000908152600160205260409020611f8c9082611200565b50611f996002828461120c565b5060405181906001600160a01b038416906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b50805460018160011615610100020316600290046000825580601f10611ffc5750610b75565b601f016020900490600052602060002090810190610b7591905b8082111561202a5760008155600101612016565b5090565b80356001600160a01b038116811461061e57600080fd5b600082601f830112612055578081fd5b813567ffffffffffffffff8082111561206a57fe5b604051601f8301601f19168101602001828111828210171561208857fe5b60405282815284830160200186101561209f578384fd5b82602086016020830137918201602001929092529392505050565b6000602082840312156120cb578081fd5b610a068261202e565b600080604083850312156120e6578081fd5b6120ef8361202e565b91506120fd6020840161202e565b90509250929050565b60008060006060848603121561211a578081fd5b6121238461202e565b92506121316020850161202e565b9150604084013590509250925092565b60008060008060808587031215612156578081fd5b61215f8561202e565b935061216d6020860161202e565b925060408501359150606085013567ffffffffffffffff81111561218f578182fd5b61219b87828801612045565b91505092959194509250565b600080604083850312156121b9578182fd5b6121c28361202e565b915060208301356121d281612ce2565b809150509250929050565b600080600080600060a086880312156121f4578081fd5b6121fd8661202e565b9450602086013567ffffffffffffffff811115612218578182fd5b61222488828901612045565b9450506040860135925060608601359150608086013560ff81168114612248578182fd5b809150509295509295909350565b60008060408385031215612268578182fd5b6122718361202e565b946020939093013593505050565b600060208284031215612290578081fd5b8151610a0681612ce2565b6000602082840312156122ac578081fd5b8135610a0681612cf0565b6000602082840312156122c8578081fd5b8151610a0681612cf0565b6000602082840312156122e4578081fd5b5035919050565b6000602082840312156122fc578081fd5b5051919050565b6000815180845261231b816020860160208601612cb6565b601f01601f19169290920160200192915050565b60008251612341818460208701612cb6565b9190910192915050565b6000835161235d818460208801612cb6565b60609390931b6bffffffffffffffffffffffff19169190920190815260140192915050565b61190160f01b81526002810192909252602282015260420190565b60007f697066733a2f2f516d624245704176644b4a6877745a4e455a4766314b34533182527577784c39434c50424d645434345934766573726e712f60501b602083015282516123f4816036850160208701612cb6565b64173539b7b760d91b6036939091019283015250603b01919050565b6001600160a01b0391909116815260200190565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061245790830184612303565b9695505050505050565b6001600160a01b0384811682528316602082015260606040820181905260009061248d90830184612303565b95945050505050565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b03929092168252602082015260400190565b901515815260200190565b90815260200190565b93845260208401929092526001600160a01b03166040830152606082015260800190565b93845260ff9290921660208401526040830152606082015260800190565b600060208252610a066020830184612303565b6020808252600f908201526e139bdd1a1a5b99c81d1bc81b5a5b9d608a1b604082015260600190565b60208082526022908201527f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b60208082526016908201527553616c6520697320616c72656164792061637469766560501b604082015260600190565b6020808252601390820152724e6f7468696e6720746f20776974686472617760681b604082015260600190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b6020808252601c908201527f46756e6374696f6e2063616c6c206e6f74207375636365737366756c00000000604082015260600190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b60208082526024908201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646040820152637265737360e01b606082015260800190565b60208082526019908201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604082015260600190565b60208082526012908201527153616c65206973206e6f742061637469766560701b604082015260600190565b60208082526026908201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6040820152651c8818d85b1b60d21b606082015260800190565b6020808252602c908201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b60208082526025908201527f4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f5360408201526424a3a722a960d91b606082015260800190565b60208082526038908201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760408201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606082015260800190565b6020808252602a908201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604082015269726f206164647265737360b01b606082015260800190565b60208082526022908201527f456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b6020808252602c908201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526029908201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960408201526839903737ba1037bbb760b91b606082015260800190565b60208082526021908201527f5369676e657220616e64207369676e617475726520646f206e6f74206d6174636040820152600d60fb1b606082015260800190565b60208082526021908201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656040820152603960f91b606082015260800190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b60208082526010908201526f151bdbc81b585b9e481d1bc81b5a5b9d60821b604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b6020808252601f908201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604082015260600190565b60208082526030908201527f4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f7760408201526f1b995c881b9bdc88185c1c1c9bdd995960821b606082015260800190565b60005b83811015612cd1578181015183820152602001612cb9565b838111156110735750506000910152565b8015158114610b7557600080fd5b6001600160e01b031981168114610b7557600080fdfe4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e7465724d6574615472616e73616374696f6e2875696e74323536206e6f6e63652c616464726573732066726f6d2c62797465732066756e6374696f6e5369676e6174757265294552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656ea26469706673582212209e5567f78b221eb47edfc2bdfc5a55fc614a597afaec8002a36004be64ecff5964736f6c634300070600334552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e746572454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c6164647265737320766572696679696e67436f6e74726163742c627974657333322073616c7429000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000002fe8733dcb25bfbba79292294347415417510067000000000000000000000000ad4df91e918553b036472860c75156e8ca29207f0000000000000000000000000000000000000000000000000000000000000010536f6c646965727320536f63696574790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025353000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000002fe8733dcb25bfbba79292294347415417510067000000000000000000000000ad4df91e918553b036472860c75156e8ca29207f0000000000000000000000000000000000000000000000000000000000000010536f6c646965727320536f63696574790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025353000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _name (string): Soldiers Society
Arg [1] : _symbol (string): SS
Arg [2] : _xedContract (address): 0x2fe8733dcb25BFbbA79292294347415417510067
Arg [3] : _paymentSplitterContract (address): 0xAD4DF91E918553B036472860c75156E8CA29207f
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000002fe8733dcb25bfbba79292294347415417510067
Arg [3] : 000000000000000000000000ad4df91e918553b036472860c75156e8ca29207f
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [5] : 536f6c646965727320536f636965747900000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [7] : 5353000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
88074:3468:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36803:200;;;;;;;;;;-1:-1:-1;36803:200:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;88339:44;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;63860:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;66868:308::-;;;;;;;;;;-1:-1:-1;66868:308:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;66367:435::-;;;;;;;;;;-1:-1:-1;66367:435:0;;;;;:::i;:::-;;:::i;:::-;;85803:1148;;;;;;:::i;:::-;;:::i;82895:43::-;;;;;;;;;;;;;:::i;88281:51::-;;;;;;;;;;;;;:::i;65795:211::-;;;;;;;;;;;;;:::i;88479:35::-;;;;;;;;;;;;;:::i;83891:101::-;;;;;;;;;;;;;:::i;67927:376::-;;;;;;;;;;-1:-1:-1;67927:376:0;;;;;:::i;:::-;;:::i;88521:48::-;;;;;;;;;;;;;:::i;87377:107::-;;;;;;;;;;-1:-1:-1;87377:107:0;;;;;:::i;:::-;;:::i;65507:212::-;;;;;;;;;;-1:-1:-1;65507:212:0;;;;;:::i;:::-;;:::i;84000:161::-;;;;;;;;;;;;;:::i;89914:486::-;;;;;;;;;;;;;:::i;68374:185::-;;;;;;;;;;-1:-1:-1;68374:185:0;;;;;:::i;:::-;;:::i;78346:282::-;;;;;;;;;;-1:-1:-1;78346:282:0;;;;;:::i;:::-;;:::i;88390:44::-;;;;;;;;;;;;;:::i;66083:222::-;;;;;;;;;;-1:-1:-1;66083:222:0;;;;;:::i;:::-;;:::i;63504:289::-;;;;;;;;;;-1:-1:-1;63504:289:0;;;;;:::i;:::-;;:::i;88576:22::-;;;;;;;;;;;;;:::i;65326:97::-;;;;;;;;;;;;;:::i;63134:308::-;;;;;;;;;;-1:-1:-1;63134:308:0;;;;;:::i;:::-;;:::i;2879:148::-;;;;;;;;;;;;;:::i;88441:29::-;;;;;;;;;;;;;:::i;2228:87::-;;;;;;;;;;;;;:::i;64029:104::-;;;;;;;;;;;;;:::i;89173:733::-;;;;;;;;;;-1:-1:-1;89173:733:0;;;;;:::i;:::-;;:::i;67248:327::-;;;;;;;;;;-1:-1:-1;67248:327:0;;;;;:::i;:::-;;:::i;90443:133::-;;;;;;;;;;;;;:::i;68630:365::-;;;;;;;;;;-1:-1:-1;68630:365:0;;;;;:::i;:::-;;:::i;90635:394::-;;;;;;;;;;-1:-1:-1;90635:394:0;;;;;:::i;:::-;;:::i;91037:325::-;;;;;;;;;;-1:-1:-1;91037:325:0;;;;;:::i;:::-;;:::i;3182:281::-;;;;;;;;;;-1:-1:-1;3182:281:0;;;;;:::i;:::-;;:::i;36803:200::-;-1:-1:-1;;;;;;36962:33:0;;36933:4;36962:33;;;;;;;;;;;;;36803:200;;;;:::o;88339:44::-;88379:4;88339:44;:::o;63860:100::-;63947:5;63940:12;;;;;;;;-1:-1:-1;;63940:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63914:13;;63940:12;;63947:5;;63940:12;;63947:5;63940:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63860:100;;:::o;66868:308::-;66989:7;67036:16;67044:7;67036;:16::i;:::-;67014:110;;;;-1:-1:-1;;;67014:110:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;67144:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;67144:24:0;;66868:308::o;66367:435::-;66448:13;66464:23;66479:7;66464:14;:23::i;:::-;66448:39;;66512:5;-1:-1:-1;;;;;66506:11:0;:2;-1:-1:-1;;;;;66506:11:0;;;66498:57;;;;-1:-1:-1;;;66498:57:0;;;;;;;:::i;:::-;66606:5;-1:-1:-1;;;;;66590:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;66590:21:0;;:86;;;;66632:44;66656:5;66663:12;:10;:12::i;:::-;66632:23;:44::i;:::-;66568:192;;;;-1:-1:-1;;;66568:192:0;;;;;;;:::i;:::-;66773:21;66782:2;66786:7;66773:8;:21::i;:::-;66367:435;;;:::o;85803:1148::-;86061:152;;;86004:12;86061:152;;;;;-1:-1:-1;;;;;86099:19:0;;86029:29;86099:19;;;:6;:19;;;;;;;;;86061:152;;;;;;;;;;;86248:45;86106:11;86061:152;86276:4;86282;86288;86248:6;:45::i;:::-;86226:128;;;;-1:-1:-1;;;86226:128:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;86443:19:0;;;;;;:6;:19;;;;;;;;;86465:1;86443:23;86421:45;;86484:126;;;;;86450:11;;86556:10;;86582:17;;86484:126;:::i;:::-;;;;;;;;86721:12;86735:23;86770:4;-1:-1:-1;;;;;86762:18:0;86812:17;86831:11;86795:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;86795:48:0;;;;;;;;;;86762:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86720:134;;;;86873:7;86865:48;;;;-1:-1:-1;;;86865:48:0;;;;;;;:::i;:::-;86933:10;85803:1148;-1:-1:-1;;;;;;;;85803:1148:0:o;82895:43::-;;;;;;;;;;;;;;-1:-1:-1;;;82895:43:0;;;;:::o;88281:51::-;88323:9;88281:51;:::o;65795:211::-;65856:7;65977:21;:12;:19;:21::i;:::-;65970:28;;65795:211;:::o;88479:35::-;;;:::o;83891:101::-;83969:15;;83891:101;:::o;67927:376::-;68136:41;68155:12;:10;:12::i;:::-;68169:7;68136:18;:41::i;:::-;68114:140;;;;-1:-1:-1;;;68114:140:0;;;;;;;:::i;:::-;68267:28;68277:4;68283:2;68287:7;68267:9;:28::i;88521:48::-;;;:::o;87377:107::-;-1:-1:-1;;;;;87464:12:0;87430:13;87464:12;;;:6;:12;;;;;;;87377:107::o;65507:212::-;-1:-1:-1;;;;;65681:20:0;;65649:7;65681:20;;;:13;:20;;;;;:30;;65705:5;65681:23;:30::i;:::-;65674:37;;65507:212;;;;;:::o;84000:161::-;84114:9;84000:161;:::o;89914:486::-;89974:36;;-1:-1:-1;;;89974:36:0;;89954:17;;-1:-1:-1;;;;;89974:11:0;:21;;;;:36;;90004:4;;89974:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;89954:56;;90041:1;90029:9;:13;90021:45;;;;-1:-1:-1;;;90021:45:0;;;;;;;:::i;:::-;90217:10;90199:15;:28;90195:198;;;90244:60;-1:-1:-1;;;;;90244:11:0;:24;90269:23;90294:9;90244:24;:60::i;:::-;90195:198;;;90337:44;90362:7;:5;:7::i;:::-;-1:-1:-1;;;;;90337:11:0;:24;;90371:9;90337:24;:44::i;:::-;89914:486;:::o;68374:185::-;68512:39;68529:4;68535:2;68539:7;68512:39;;;;;;;;;;;;:16;:39::i;78346:282::-;78478:41;78497:12;:10;:12::i;78478:41::-;78456:139;;;;-1:-1:-1;;;78456:139:0;;;;;;;:::i;:::-;78606:14;78612:7;78606:5;:14::i;88390:44::-;88431:3;88390:44;:::o;66083:222::-;66203:7;;66250:22;:12;66266:5;66250:15;:22::i;:::-;-1:-1:-1;66228:44:0;66083:222;-1:-1:-1;;;66083:222:0:o;63504:289::-;63621:7;63666:119;63701:7;63666:119;;;;;;;;;;;;;;;;;:12;;:119;:16;:119::i;88576:22::-;;;;;;:::o;65326:97::-;65407:8;65400:15;;;;;;;;-1:-1:-1;;65400:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65374:13;;65400:15;;65407:8;;65400:15;;65407:8;65400:15;;;;;;;;;;;;;;;;;;;;;;;;63134:308;63251:7;-1:-1:-1;;;;;63298:19:0;;63276:111;;;;-1:-1:-1;;;63276:111:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;63405:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;2879:148::-;2459:12;:10;:12::i;:::-;-1:-1:-1;;;;;2448:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2448:23:0;;2440:68;;;;-1:-1:-1;;;2440:68:0;;;;;;;:::i;:::-;2970:6:::1;::::0;2949:40:::1;::::0;2986:1:::1;::::0;-1:-1:-1;;;;;2970:6:0::1;::::0;2949:40:::1;::::0;2986:1;;2949:40:::1;3000:6;:19:::0;;-1:-1:-1;;;;;;3000:19:0::1;::::0;;2879:148::o;88441:29::-;;;;:::o;2228:87::-;2301:6;;-1:-1:-1;;;;;2301:6:0;2228:87;:::o;64029:104::-;64118:7;64111:14;;;;;;;;-1:-1:-1;;64111:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64085:13;;64111:14;;64118:7;;64111:14;;64118:7;64111:14;;;;;;;;;;;;;;;;;;;;;;;;89173:733;80389:1;80994:7;;:19;;80986:63;;;;-1:-1:-1;;;80986:63:0;;;;;;;:::i;:::-;80389:1;81127:7;:18;89245:10:::1;::::0;::::1;;89237:41;;;;-1:-1:-1::0;;;89237:41:0::1;;;;;;;:::i;:::-;89309:1;89299:7;:11;89291:39;;;;-1:-1:-1::0;;;89291:39:0::1;;;;;;;:::i;:::-;89360:3;89349:7;:14;;89341:43;;;;-1:-1:-1::0;;;89341:43:0::1;;;;;;;:::i;:::-;89430:14;::::0;89472:96:::1;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;89472:96:0::1;::::0;::::1;::::0;::::1;::::0;89430:14;;89513:7;;89472:26:::1;:96::i;:::-;89455:14;:113:::0;89581:135:::1;89624:10;89657:4;89677:28;:7:::0;88323:9:::1;89677:11;:28::i;:::-;-1:-1:-1::0;;;;;89581:11:0::1;:28;::::0;:135;;:28:::1;:135::i;:::-;89734:9;89729:170;89753:7;89749:1;:11;89729:170;;;88379:4;89800:38:::0;;::::1;:42:::0;::::1;89857:30;89867:10;89800:42:::0;89857:9:::1;:30::i;:::-;-1:-1:-1::0;89762:3:0::1;;89729:170;;;-1:-1:-1::0;;80345:1:0;81306:7;:22;-1:-1:-1;89173:733:0:o;67248:327::-;67395:12;:10;:12::i;:::-;-1:-1:-1;;;;;67383:24:0;:8;-1:-1:-1;;;;;67383:24:0;;;67375:62;;;;-1:-1:-1;;;67375:62:0;;;;;;;:::i;:::-;67495:8;67450:18;:32;67469:12;:10;:12::i;:::-;-1:-1:-1;;;;;67450:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;67450:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;67450:53:0;;;;;;;;;;;67534:12;:10;:12::i;:::-;-1:-1:-1;;;;;67519:48:0;;67558:8;67519:48;;;;;;:::i;:::-;;;;;;;;67248:327;;:::o;90443:133::-;2459:12;:10;:12::i;:::-;-1:-1:-1;;;;;2448:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2448:23:0;;2440:68;;;;-1:-1:-1;;;2440:68:0;;;;;;;:::i;:::-;90503:10:::1;::::0;::::1;;90502:11;90494:46;;;;-1:-1:-1::0;;;90494:46:0::1;;;;;;;:::i;:::-;90551:10;:17:::0;;-1:-1:-1;;90551:17:0::1;90564:4;90551:17;::::0;;90443:133::o;68630:365::-;68819:41;68838:12;:10;:12::i;:::-;68852:7;68819:18;:41::i;:::-;68797:140;;;;-1:-1:-1;;;68797:140:0;;;;;;;:::i;:::-;68948:39;68962:4;68968:2;68972:7;68981:5;68948:13;:39::i;:::-;68630:365;;;;:::o;90635:394::-;90737:13;90931:26;90948:8;90931:16;:26::i;:::-;90813:193;;;;;;;;:::i;:::-;;;;;;;;;;;;;90768:253;;90635:394;;;:::o;91037:325::-;91164:4;-1:-1:-1;;;;;91190:64:0;;91211:42;91190:64;91186:108;;;-1:-1:-1;91278:4:0;91271:11;;91186:108;91313:41;91336:6;91344:9;91313:22;:41::i;3182:281::-;2459:12;:10;:12::i;:::-;-1:-1:-1;;;;;2448:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2448:23:0;;2440:68;;;;-1:-1:-1;;;2440:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3285:22:0;::::1;3263:110;;;;-1:-1:-1::0;;;3263:110:0::1;;;;;;;:::i;:::-;3410:6;::::0;3389:38:::1;::::0;-1:-1:-1;;;;;3389:38:0;;::::1;::::0;3410:6:::1;::::0;3389:38:::1;::::0;3410:6:::1;::::0;3389:38:::1;3438:6;:17:::0;;-1:-1:-1;;;;;;3438:17:0::1;-1:-1:-1::0;;;;;3438:17:0;;;::::1;::::0;;;::::1;::::0;;3182:281::o;81557:618::-;81601:22;81640:10;81662:4;81640:27;81636:508;;;81684:18;81705:8;;81684:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;81744:8:0;81955:17;81949:24;-1:-1:-1;;;;;81923:134:0;;-1:-1:-1;81783:289:0;;-1:-1:-1;81783:289:0;;-1:-1:-1;82121:10:0;81557:618;:::o;46331:131::-;46398:4;46422:32;46427:3;46447:5;46422:4;:32::i;55275:219::-;55398:4;55422:64;55427:3;55447;-1:-1:-1;;;;;55461:23:0;;55422:4;:64::i;:::-;55415:71;;55275:219;;;;;;:::o;14900:444::-;15280:20;15328:8;;;14900:444::o;17937:229::-;18074:12;18106:52;18128:6;18136:4;18142:1;18145:12;18106:21;:52::i;55909:183::-;56020:4;56049:35;56059:3;56079;56049:9;:35::i;70542:127::-;70607:4;70631:30;:12;70653:7;70631:21;:30::i;91370:169::-;91460:22;91507:24;:22;:24::i;67646:214::-;-1:-1:-1;;;;;67817:25:0;;;67788:4;67817:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;67646:214::o;76956:192::-;77031:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;77031:29:0;-1:-1:-1;;;;;77031:29:0;;;;;;;;:24;;77085:23;77031:24;77085:14;:23::i;:::-;-1:-1:-1;;;;;77076:46:0;;;;;;;;;;;76956:192;;:::o;87492:486::-;87670:4;-1:-1:-1;;;;;87695:20:0;;87687:70;;;;-1:-1:-1;;;87687:70:0;;;;;;;:::i;:::-;87811:159;87839:47;87858:27;87878:6;87858:19;:27::i;:::-;87839:18;:47::i;:::-;87905:4;87928;87951;87811:159;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;87788:182:0;:6;-1:-1:-1;;;;;87788:182:0;;87768:202;;87492:486;;;;;;;:::o;56180:155::-;56276:7;56308:19;56316:3;56308:7;:19::i;70836:459::-;70965:4;71009:16;71017:7;71009;:16::i;:::-;70987:110;;;;-1:-1:-1;;;70987:110:0;;;;;;;:::i;:::-;71108:13;71124:23;71139:7;71124:14;:23::i;:::-;71108:39;;71177:5;-1:-1:-1;;;;;71166:16:0;:7;-1:-1:-1;;;;;71166:16:0;;:64;;;;71223:7;-1:-1:-1;;;;;71199:31:0;:20;71211:7;71199:11;:20::i;:::-;-1:-1:-1;;;;;71199:31:0;;71166:64;:120;;;;71247:39;71271:5;71278:7;71247:23;:39::i;:::-;71158:129;70836:459;-1:-1:-1;;;;70836:459:0:o;74147:670::-;74320:4;-1:-1:-1;;;;;74293:31:0;:23;74308:7;74293:14;:23::i;:::-;-1:-1:-1;;;;;74293:31:0;;74271:122;;;;-1:-1:-1;;;74271:122:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;74430:16:0;;74422:65;;;;-1:-1:-1;;;74422:65:0;;;;;;;:::i;:::-;74500:39;74521:4;74527:2;74531:7;74500:20;:39::i;:::-;74604:29;74621:1;74625:7;74604:8;:29::i;:::-;-1:-1:-1;;;;;74646:19:0;;;;;;:13;:19;;;;;:35;;74673:7;74646:26;:35::i;:::-;-1:-1:-1;;;;;;74692:17:0;;;;;;:13;:17;;;;;:30;;74714:7;74692:21;:30::i;:::-;-1:-1:-1;74735:29:0;:12;74752:7;74761:2;74735:16;:29::i;:::-;;74801:7;74797:2;-1:-1:-1;;;;;74782:27:0;74791:4;-1:-1:-1;;;;;74782:27:0;;;;;;;;;;;74147:670;;;:::o;47616:169::-;47714:7;47754:22;47758:3;47770:5;47754:3;:22::i;23522:248::-;23639:123;23673:5;23716:23;;;23741:2;23745:5;23693:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23693:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;23693:58:0;-1:-1:-1;;;;;;23693:58:0;;;;;;;;;;23639:19;:123::i;73265:545::-;73325:13;73341:23;73356:7;73341:14;:23::i;:::-;73325:39;;73395:48;73416:5;73431:1;73435:7;73395:20;:48::i;:::-;73484:29;73501:1;73505:7;73484:8;:29::i;:::-;73572:19;;;;:10;:19;;;;;73566:33;;-1:-1:-1;;73566:33:0;;;;;;;;;;;:38;73562:97;;73628:19;;;;:10;:19;;;;;73621:26;;;:::i;:::-;-1:-1:-1;;;;;73671:20:0;;;;;;:13;:20;;;;;:36;;73699:7;73671:27;:36::i;:::-;-1:-1:-1;73720:28:0;:12;73740:7;73720:19;:28::i;:::-;-1:-1:-1;73766:36:0;;73794:7;;73790:1;;-1:-1:-1;;;;;73766:36:0;;;;;73790:1;;73766:36;73265:545;;:::o;56683:268::-;56790:7;;;;56855:22;56859:3;56871:5;56855:3;:22::i;:::-;56824:53;;;;-1:-1:-1;56683:268:0;-1:-1:-1;;;;;56683:268:0:o;58065:292::-;58206:7;58288:44;58293:3;58313;58319:12;58288:4;:44::i;9256:200::-;9376:7;9412:12;9404:6;;;;9396:29;;;;-1:-1:-1;;;9396:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;9443:5:0;;;9256:200::o;7308:220::-;7366:7;7390:6;7386:20;;-1:-1:-1;7405:1:0;7398:8;;7386:20;7429:5;;;7433:1;7429;:5;:1;7453:5;;;;;:10;7445:56;;;;-1:-1:-1;;;7445:56:0;;;;;;;:::i;23778:285::-;23922:133;23956:5;23999:27;;;24028:4;24034:2;24038:5;23976:68;;;;;;;;;;:::i;71638:110::-;71714:26;71724:2;71728:7;71714:26;;;;;;;;;;;;:9;:26::i;:::-;71638:110;;:::o;69877:352::-;70034:28;70044:4;70050:2;70054:7;70034:9;:28::i;:::-;70095:48;70118:4;70124:2;70128:7;70137:5;70095:22;:48::i;:::-;70073:148;;;;-1:-1:-1;;;70073:148:0;;;;;;;:::i;58610:748::-;58666:13;58887:10;58883:53;;-1:-1:-1;58914:10:0;;;;;;;;;;;;-1:-1:-1;;;58914:10:0;;;;;;58883:53;58961:5;58946:12;59002:78;59009:9;;59002:78;;59035:8;;59066:2;59058:10;;;;59002:78;;;59090:19;59122:6;59112:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59112:17:0;-1:-1:-1;59184:5:0;;-1:-1:-1;59090:39:0;-1:-1:-1;;;59156:10:0;;59200:119;59207:9;;59200:119;;59277:2;59270:4;:9;59264:2;:16;59251:31;;59233:6;59240:7;;;;;;;59233:15;;;;;;;;;;;:49;-1:-1:-1;;;;;59233:49:0;;;;;;;;-1:-1:-1;59305:2:0;59297:10;;;;59200:119;;;-1:-1:-1;59343:6:0;58610:748;-1:-1:-1;;;;58610:748:0:o;39339:414::-;39402:4;39424:21;39434:3;39439:5;39424:9;:21::i;:::-;39419:327;;-1:-1:-1;39462:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;39645:18;;39623:19;;;:12;;;:19;;;;;;:40;;;;39678:11;;39419:327;-1:-1:-1;39729:5:0;39722:12;;49715:737;49825:4;49960:17;;;:12;;;:17;;;;;;49994:13;49990:455;;-1:-1:-1;;50092:36:0;;;;;;;;;;;;;;;;;;50074:55;;;;;;;;:12;:55;;;;;;;;;;;;;;;;;;;;;;;;50287:19;;50267:17;;;:12;;;:17;;;;;;;:39;50321:11;;49990:455;50401:5;50365:3;:12;;50389:1;50378:8;:12;50365:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;50428:5;50421:12;;;;;19153:632;19323:12;19395:5;19370:21;:30;;19348:118;;;;-1:-1:-1;;;19348:118:0;;;;;;;:::i;:::-;19485:18;19496:6;19485:10;:18::i;:::-;19477:60;;;;-1:-1:-1;;;19477:60:0;;;;;;;:::i;:::-;19611:12;19625:23;19652:6;-1:-1:-1;;;;;19652:11:0;19671:5;19692:4;19652:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19610:97;;;;19725:52;19743:7;19752:10;19764:12;19725:17;:52::i;:::-;19718:59;19153:632;-1:-1:-1;;;;;;;19153:632:0:o;52273:157::-;52371:4;52400:17;;;:12;;;;;:17;;;;;;:22;;;52273:157::o;86959:410::-;87069:7;85127:108;;;;;;;;;;;;;;;;;85103:143;;;;;;;87223:12;;87258:11;;;;87302:24;;;;;87292:35;;;;;;87142:204;;;;;;:::i;:::-;;;;;;;;;;;;;87114:247;;;;;;87094:267;;86959:410;;;:::o;84530:258::-;84629:7;84731:20;:18;:20::i;:::-;84753:11;84702:63;;;;;;;;;:::i;52525:110::-;52608:19;;52525:110::o;46638:160::-;46726:4;46755:35;46763:3;46783:5;46755:7;:35::i;42282:273::-;42423:18;;42376:7;;42423:26;-1:-1:-1;42401:110:0;;;;-1:-1:-1;;;42401:110:0;;;;;;;:::i;:::-;42529:3;:11;;42541:5;42529:18;;;;;;;;;;;;;;;;42522:25;;42282:273;;;;:::o;26398:860::-;26822:23;26848:106;26890:4;26848:106;;;;;;;;;;;;;;;;;26856:5;-1:-1:-1;;;;;26848:27:0;;;:106;;;;;:::i;:::-;26969:17;;26822:132;;-1:-1:-1;26969:21:0;26965:286;;27142:10;27131:30;;;;;;;;;;;;:::i;:::-;27105:134;;;;-1:-1:-1;;;27105:134:0;;;;;;;:::i;55660:165::-;55755:4;55784:33;55792:3;55812;55784:7;:33::i;53000:348::-;53150:19;;53094:7;;;;53150:27;-1:-1:-1;53128:111:0;;;;-1:-1:-1;;;53128:111:0;;;;;;;:::i;:::-;53252:22;53277:3;:12;;53290:5;53277:19;;;;;;;;;;;;;;;;;;53252:44;;53315:5;:10;;;53327:5;:12;;;53307:33;;;;;53000:348;;;;;:::o;54598:353::-;54726:7;54765:17;;;:12;;;:17;;;;;;54816:12;54801:13;54793:36;;;;-1:-1:-1;;;54793:36:0;;;;;;;;:::i;:::-;;54883:3;:12;;54907:1;54896:8;:12;54883:26;;;;;;;;;;;;;;;;;;:33;;;54876:40;;;54598:353;;;;;:::o;71975:321::-;72105:18;72111:2;72115:7;72105:5;:18::i;:::-;72156:54;72187:1;72191:2;72195:7;72204:5;72156:22;:54::i;:::-;72134:154;;;;-1:-1:-1;;;72134:154:0;;;;;;;:::i;76143:694::-;76298:4;76320:15;:2;-1:-1:-1;;;;;76320:13:0;;:15::i;:::-;76315:60;;-1:-1:-1;76359:4:0;76352:11;;76315:60;76385:23;76411:313;-1:-1:-1;;;76546:12:0;:10;:12::i;:::-;76577:4;76600:7;76626:5;76441:205;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;76441:205:0;;;;;;;-1:-1:-1;;;;;76441:205:0;;;;;;;;;;;76411:313;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;76411:15:0;;;:313;:15;:313::i;:::-;76385:339;;76735:13;76762:10;76751:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;76802:26:0;-1:-1:-1;;;76802:26:0;;-1:-1:-1;;;76143:694:0;;;;;;:::o;22076:777::-;22226:12;22255:7;22251:595;;;-1:-1:-1;22286:10:0;22279:17;;22251:595;22400:17;;:21;22396:439;;22663:10;22657:17;22724:15;22711:10;22707:2;22703:19;22696:44;22611:148;22806:12;22799:20;;-1:-1:-1;;;22799:20:0;;;;;;;;:::i;39929:1557::-;39995:4;40134:19;;;:12;;;:19;;;;;;40170:15;;40166:1313;;40618:18;;-1:-1:-1;;40569:14:0;;;;40618:22;;;;40545:21;;40618:3;;:22;;40905;;;;;;;;;;;;;;40885:42;;41051:9;41022:3;:11;;41034:13;41022:26;;;;;;;;;;;;;;;;;;;:38;;;;41128:23;;;41170:1;41128:12;;;:23;;;;;;41154:17;;;41128:43;;41280:17;;41128:3;;41280:17;;;;;;;;;;;;;;;;;;;;;;41375:3;:12;;:19;41388:5;41375:19;;;;;;;;;;;41368:26;;;41418:4;41411:11;;;;;;;;40166:1313;41462:5;41455:12;;;;;50627:1562;50691:4;50826:17;;;:12;;;:17;;;;;;50860:13;;50856:1326;;51305:19;;-1:-1:-1;;51258:12:0;;;;51305:23;;;;51234:21;;51305:3;;:23;;51602;;;;;;;;;;;;;;;;51573:52;;51750:9;51720:3;:12;;51733:13;51720:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;51840:14;;51827:28;;:12;;;:28;;;;;51858:17;;;51827:48;;51984:18;;51827:3;;51984:18;;;;;;;;;;;;;;-1:-1:-1;;51984:18:0;;;;;;;;;;;;;;;;;;;;;52080:17;;;:12;;;:17;;;;;;52073:24;;;;51984:18;-1:-1:-1;52114:11:0;;-1:-1:-1;;;;52114:11:0;72632:404;-1:-1:-1;;;;;72712:16:0;;72704:61;;;;-1:-1:-1;;;72704:61:0;;;;;;;:::i;:::-;72785:16;72793:7;72785;:16::i;:::-;72784:17;72776:58;;;;-1:-1:-1;;;72776:58:0;;;;;;;:::i;:::-;72847:45;72876:1;72880:2;72884:7;72847:20;:45::i;:::-;-1:-1:-1;;;;;72905:17:0;;;;;;:13;:17;;;;;:30;;72927:7;72905:21;:30::i;:::-;-1:-1:-1;72948:29:0;:12;72965:7;72974:2;72948:16;:29::i;:::-;-1:-1:-1;72995:33:0;;73020:7;;-1:-1:-1;;;;;72995:33:0;;;73012:1;;72995:33;;73012:1;;72995:33;72632:404;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:694;;291:3;284:4;276:6;272:17;268:27;258:2;;313:5;306;299:20;258:2;353:6;340:20;379:18;416:2;412;409:10;406:2;;;422:9;406:2;462;456:9;531:2;512:13;;-1:-1:-1;;508:27:1;496:40;;538:4;492:51;558:18;;;578:22;;;555:46;552:2;;;604:9;552:2;631;624:22;655:18;;;692:15;;;709:4;688:26;685:35;-1:-1:-1;682:2:1;;;737:5;730;723:20;682:2;805;798:4;790:6;786:17;779:4;771:6;767:17;754:54;828:15;;;845:4;824:26;817:41;;;;832:6;248:640;-1:-1:-1;;;248:640:1:o;893:198::-;;1005:2;993:9;984:7;980:23;976:32;973:2;;;1026:6;1018;1011:22;973:2;1054:31;1075:9;1054:31;:::i;1096:274::-;;;1225:2;1213:9;1204:7;1200:23;1196:32;1193:2;;;1246:6;1238;1231:22;1193:2;1274:31;1295:9;1274:31;:::i;:::-;1264:41;;1324:40;1360:2;1349:9;1345:18;1324:40;:::i;:::-;1314:50;;1183:187;;;;;:::o;1375:342::-;;;;1521:2;1509:9;1500:7;1496:23;1492:32;1489:2;;;1542:6;1534;1527:22;1489:2;1570:31;1591:9;1570:31;:::i;:::-;1560:41;;1620:40;1656:2;1645:9;1641:18;1620:40;:::i;:::-;1610:50;;1707:2;1696:9;1692:18;1679:32;1669:42;;1479:238;;;;;:::o;1722:563::-;;;;;1894:3;1882:9;1873:7;1869:23;1865:33;1862:2;;;1916:6;1908;1901:22;1862:2;1944:31;1965:9;1944:31;:::i;:::-;1934:41;;1994:40;2030:2;2019:9;2015:18;1994:40;:::i;:::-;1984:50;;2081:2;2070:9;2066:18;2053:32;2043:42;;2136:2;2125:9;2121:18;2108:32;2163:18;2155:6;2152:30;2149:2;;;2200:6;2192;2185:22;2149:2;2228:51;2271:7;2262:6;2251:9;2247:22;2228:51;:::i;:::-;2218:61;;;1852:433;;;;;;;:::o;2290:329::-;;;2416:2;2404:9;2395:7;2391:23;2387:32;2384:2;;;2437:6;2429;2422:22;2384:2;2465:31;2486:9;2465:31;:::i;:::-;2455:41;;2546:2;2535:9;2531:18;2518:32;2559:30;2583:5;2559:30;:::i;:::-;2608:5;2598:15;;;2374:245;;;;;:::o;2624:723::-;;;;;;2811:3;2799:9;2790:7;2786:23;2782:33;2779:2;;;2833:6;2825;2818:22;2779:2;2861:31;2882:9;2861:31;:::i;:::-;2851:41;;2943:2;2932:9;2928:18;2915:32;2970:18;2962:6;2959:30;2956:2;;;3007:6;2999;2992:22;2956:2;3035:51;3078:7;3069:6;3058:9;3054:22;3035:51;:::i;:::-;3025:61;;;3133:2;3122:9;3118:18;3105:32;3095:42;;3184:2;3173:9;3169:18;3156:32;3146:42;;3238:3;3227:9;3223:19;3210:33;3283:4;3276:5;3272:16;3265:5;3262:27;3252:2;;3308:6;3300;3293:22;3252:2;3336:5;3326:15;;;2769:578;;;;;;;;:::o;3352:266::-;;;3481:2;3469:9;3460:7;3456:23;3452:32;3449:2;;;3502:6;3494;3487:22;3449:2;3530:31;3551:9;3530:31;:::i;:::-;3520:41;3608:2;3593:18;;;;3580:32;;-1:-1:-1;;;3439:179:1:o;3623:257::-;;3743:2;3731:9;3722:7;3718:23;3714:32;3711:2;;;3764:6;3756;3749:22;3711:2;3801:9;3795:16;3820:30;3844:5;3820:30;:::i;3885:257::-;;3996:2;3984:9;3975:7;3971:23;3967:32;3964:2;;;4017:6;4009;4002:22;3964:2;4061:9;4048:23;4080:32;4106:5;4080:32;:::i;4147:261::-;;4269:2;4257:9;4248:7;4244:23;4240:32;4237:2;;;4290:6;4282;4275:22;4237:2;4327:9;4321:16;4346:32;4372:5;4346:32;:::i;4413:190::-;;4525:2;4513:9;4504:7;4500:23;4496:32;4493:2;;;4546:6;4538;4531:22;4493:2;-1:-1:-1;4574:23:1;;4483:120;-1:-1:-1;4483:120:1:o;4608:194::-;;4731:2;4719:9;4710:7;4706:23;4702:32;4699:2;;;4752:6;4744;4737:22;4699:2;-1:-1:-1;4780:16:1;;4689:113;-1:-1:-1;4689:113:1:o;4807:259::-;;4888:5;4882:12;4915:6;4910:3;4903:19;4931:63;4987:6;4980:4;4975:3;4971:14;4964:4;4957:5;4953:16;4931:63;:::i;:::-;5048:2;5027:15;-1:-1:-1;;5023:29:1;5014:39;;;;5055:4;5010:50;;4858:208;-1:-1:-1;;4858:208:1:o;5071:274::-;;5238:6;5232:13;5254:53;5300:6;5295:3;5288:4;5280:6;5276:17;5254:53;:::i;:::-;5323:16;;;;;5208:137;-1:-1:-1;;5208:137:1:o;5350:415::-;;5545:6;5539:13;5561:53;5607:6;5602:3;5595:4;5587:6;5583:17;5561:53;:::i;:::-;5683:2;5679:15;;;;-1:-1:-1;;5675:53:1;5636:16;;;;5661:68;;;5756:2;5745:14;;5515:250;-1:-1:-1;;5515:250:1:o;5770:392::-;-1:-1:-1;;;6028:27:1;;6080:1;6071:11;;6064:27;;;;6116:2;6107:12;;6100:28;6153:2;6144:12;;6018:144::o;6167:663::-;;6530:34;6525:3;6518:47;-1:-1:-1;;;6590:2:1;6585:3;6581:12;6574:46;6649:6;6643:13;6665:60;6718:6;6713:2;6708:3;6704:12;6699:2;6691:6;6687:15;6665:60;:::i;:::-;-1:-1:-1;;;6784:2:1;6744:16;;;;6776:11;;;6769:28;-1:-1:-1;6821:2:1;6813:11;;6508:322;-1:-1:-1;6508:322:1:o;6835:203::-;-1:-1:-1;;;;;6999:32:1;;;;6981:51;;6969:2;6954:18;;6936:102::o;7043:506::-;-1:-1:-1;;;;;7328:15:1;;;7310:34;;7380:15;;7375:2;7360:18;;7353:43;7427:2;7412:18;;7405:34;;;7475:3;7470:2;7455:18;;7448:31;;;7043:506;;7496:47;;7523:19;;7515:6;7496:47;:::i;:::-;7488:55;7262:287;-1:-1:-1;;;;;;7262:287:1:o;7554:433::-;-1:-1:-1;;;;;7811:15:1;;;7793:34;;7863:15;;7858:2;7843:18;;7836:43;7915:2;7910;7895:18;;7888:30;;;7554:433;;7935:46;;7962:18;;7954:6;7935:46;:::i;:::-;7927:54;7745:242;-1:-1:-1;;;;;7745:242:1:o;7992:375::-;-1:-1:-1;;;;;8250:15:1;;;8232:34;;8302:15;;;;8297:2;8282:18;;8275:43;8349:2;8334:18;;8327:34;;;;8182:2;8167:18;;8149:218::o;8372:274::-;-1:-1:-1;;;;;8564:32:1;;;;8546:51;;8628:2;8613:18;;8606:34;8534:2;8519:18;;8501:145::o;8651:187::-;8816:14;;8809:22;8791:41;;8779:2;8764:18;;8746:92::o;8843:177::-;8989:25;;;8977:2;8962:18;;8944:76::o;9025:417::-;9256:25;;;9312:2;9297:18;;9290:34;;;;-1:-1:-1;;;;;9360:32:1;9355:2;9340:18;;9333:60;9424:2;9409:18;;9402:34;9243:3;9228:19;;9210:232::o;9447:398::-;9674:25;;;9747:4;9735:17;;;;9730:2;9715:18;;9708:45;9784:2;9769:18;;9762:34;9827:2;9812:18;;9805:34;9661:3;9646:19;;9628:217::o;9850:219::-;;9997:2;9986:9;9979:21;10017:46;10059:2;10048:9;10044:18;10036:6;10017:46;:::i;10522:339::-;10724:2;10706:21;;;10763:2;10743:18;;;10736:30;-1:-1:-1;;;10797:2:1;10782:18;;10775:45;10852:2;10837:18;;10696:165::o;10866:398::-;11068:2;11050:21;;;11107:2;11087:18;;;11080:30;11146:34;11141:2;11126:18;;11119:62;-1:-1:-1;;;11212:2:1;11197:18;;11190:32;11254:3;11239:19;;11040:224::o;11269:346::-;11471:2;11453:21;;;11510:2;11490:18;;;11483:30;-1:-1:-1;;;11544:2:1;11529:18;;11522:52;11606:2;11591:18;;11443:172::o;11620:343::-;11822:2;11804:21;;;11861:2;11841:18;;;11834:30;-1:-1:-1;;;11895:2:1;11880:18;;11873:49;11954:2;11939:18;;11794:169::o;11968:414::-;12170:2;12152:21;;;12209:2;12189:18;;;12182:30;12248:34;12243:2;12228:18;;12221:62;-1:-1:-1;;;12314:2:1;12299:18;;12292:48;12372:3;12357:19;;12142:240::o;12387:402::-;12589:2;12571:21;;;12628:2;12608:18;;;12601:30;12667:34;12662:2;12647:18;;12640:62;-1:-1:-1;;;12733:2:1;12718:18;;12711:36;12779:3;12764:19;;12561:228::o;12794:352::-;12996:2;12978:21;;;13035:2;13015:18;;;13008:30;13074;13069:2;13054:18;;13047:58;13137:2;13122:18;;12968:178::o;13151:352::-;13353:2;13335:21;;;13392:2;13372:18;;;13365:30;13431;13426:2;13411:18;;13404:58;13494:2;13479:18;;13325:178::o;13508:400::-;13710:2;13692:21;;;13749:2;13729:18;;;13722:30;13788:34;13783:2;13768:18;;13761:62;-1:-1:-1;;;13854:2:1;13839:18;;13832:34;13898:3;13883:19;;13682:226::o;13913:349::-;14115:2;14097:21;;;14154:2;14134:18;;;14127:30;14193:27;14188:2;14173:18;;14166:55;14253:2;14238:18;;14087:175::o;14267:342::-;14469:2;14451:21;;;14508:2;14488:18;;;14481:30;-1:-1:-1;;;14542:2:1;14527:18;;14520:48;14600:2;14585:18;;14441:168::o;14614:402::-;14816:2;14798:21;;;14855:2;14835:18;;;14828:30;14894:34;14889:2;14874:18;;14867:62;-1:-1:-1;;;14960:2:1;14945:18;;14938:36;15006:3;14991:19;;14788:228::o;15021:408::-;15223:2;15205:21;;;15262:2;15242:18;;;15235:30;15301:34;15296:2;15281:18;;15274:62;-1:-1:-1;;;15367:2:1;15352:18;;15345:42;15419:3;15404:19;;15195:234::o;15434:401::-;15636:2;15618:21;;;15675:2;15655:18;;;15648:30;15714:34;15709:2;15694:18;;15687:62;-1:-1:-1;;;15780:2:1;15765:18;;15758:35;15825:3;15810:19;;15608:227::o;15840:420::-;16042:2;16024:21;;;16081:2;16061:18;;;16054:30;16120:34;16115:2;16100:18;;16093:62;16191:26;16186:2;16171:18;;16164:54;16250:3;16235:19;;16014:246::o;16265:406::-;16467:2;16449:21;;;16506:2;16486:18;;;16479:30;16545:34;16540:2;16525:18;;16518:62;-1:-1:-1;;;16611:2:1;16596:18;;16589:40;16661:3;16646:19;;16439:232::o;16676:398::-;16878:2;16860:21;;;16917:2;16897:18;;;16890:30;16956:34;16951:2;16936:18;;16929:62;-1:-1:-1;;;17022:2:1;17007:18;;17000:32;17064:3;17049:19;;16850:224::o;17079:356::-;17281:2;17263:21;;;17300:18;;;17293:30;17359:34;17354:2;17339:18;;17332:62;17426:2;17411:18;;17253:182::o;17440:397::-;17642:2;17624:21;;;17681:2;17661:18;;;17654:30;17720:34;17715:2;17700:18;;17693:62;-1:-1:-1;;;17786:2:1;17771:18;;17764:31;17827:3;17812:19;;17614:223::o;17842:408::-;18044:2;18026:21;;;18083:2;18063:18;;;18056:30;18122:34;18117:2;18102:18;;18095:62;-1:-1:-1;;;18188:2:1;18173:18;;18166:42;18240:3;18225:19;;18016:234::o;18255:356::-;18457:2;18439:21;;;18476:18;;;18469:30;18535:34;18530:2;18515:18;;18508:62;18602:2;18587:18;;18429:182::o;18616:405::-;18818:2;18800:21;;;18857:2;18837:18;;;18830:30;18896:34;18891:2;18876:18;;18869:62;-1:-1:-1;;;18962:2:1;18947:18;;18940:39;19011:3;18996:19;;18790:231::o;19026:397::-;19228:2;19210:21;;;19267:2;19247:18;;;19240:30;19306:34;19301:2;19286:18;;19279:62;-1:-1:-1;;;19372:2:1;19357:18;;19350:31;19413:3;19398:19;;19200:223::o;19428:397::-;19630:2;19612:21;;;19669:2;19649:18;;;19642:30;19708:34;19703:2;19688:18;;19681:62;-1:-1:-1;;;19774:2:1;19759:18;;19752:31;19815:3;19800:19;;19602:223::o;19830:413::-;20032:2;20014:21;;;20071:2;20051:18;;;20044:30;20110:34;20105:2;20090:18;;20083:62;-1:-1:-1;;;20176:2:1;20161:18;;20154:47;20233:3;20218:19;;20004:239::o;20248:353::-;20450:2;20432:21;;;20489:2;20469:18;;;20462:30;20528:31;20523:2;20508:18;;20501:59;20592:2;20577:18;;20422:179::o;20606:340::-;20808:2;20790:21;;;20847:2;20827:18;;;20820:30;-1:-1:-1;;;20881:2:1;20866:18;;20859:46;20937:2;20922:18;;20780:166::o;20951:406::-;21153:2;21135:21;;;21192:2;21172:18;;;21165:30;21231:34;21226:2;21211:18;;21204:62;-1:-1:-1;;;21297:2:1;21282:18;;21275:40;21347:3;21332:19;;21125:232::o;21362:355::-;21564:2;21546:21;;;21603:2;21583:18;;;21576:30;21642:33;21637:2;21622:18;;21615:61;21708:2;21693:18;;21536:181::o;21722:412::-;21924:2;21906:21;;;21963:2;21943:18;;;21936:30;22002:34;21997:2;21982:18;;21975:62;-1:-1:-1;;;22068:2:1;22053:18;;22046:46;22124:3;22109:19;;21896:238::o;22321:258::-;22393:1;22403:113;22417:6;22414:1;22411:13;22403:113;;;22493:11;;;22487:18;22474:11;;;22467:39;22439:2;22432:10;22403:113;;;22534:6;22531:1;22528:13;22525:2;;;-1:-1:-1;;22569:1:1;22551:16;;22544:27;22374:205::o;22584:120::-;22672:5;22665:13;22658:21;22651:5;22648:32;22638:2;;22694:1;22691;22684:12;22709:133;-1:-1:-1;;;;;;22785:32:1;;22775:43;;22765:2;;22832:1;22829;22822:12
Swarm Source
ipfs://9e5567f78b221eb47edfc2bdfc5a55fc614a597afaec8002a36004be64ecff59
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.