Token FEXRA
Overview ERC-721
Total Supply:
3 FEXRA
Holders:
2 addresses
Profile Summary
Contract:
Balance
0 FEXRA
[ Download CSV Export ]
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
FinancialNFT
Compiler Version
v0.8.10+commit.fc410830
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-01-09 */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; // Sources flattened with hardhat v2.8.2 https://hardhat.org // File @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol) /** * @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/Address.sol // OpenZeppelin Contracts v4.4.1 (utils/Address.sol) /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 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" ); (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"); (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"); (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"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol) /** * @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 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' 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) + value; _callOptionalReturn( token, abi.encodeWithSelector( token.approve.selector, spender, newAllowance ) ); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require( oldAllowance >= value, "SafeERC20: decreased allowance below zero" ); uint256 newAllowance = oldAllowance - value; _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 require( abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed" ); } } } // File @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) /** * @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/IERC721.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol) /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer( address indexed from, address indexed to, uint256 indexed tokenId ); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval( address indexed owner, address indexed approved, uint256 indexed tokenId ); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll( address indexed owner, address indexed operator, bool approved ); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; } // File @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol) /** * @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/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/ERC721.sol) /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // 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; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require( owner != address(0), "ERC721: balance query for the zero address" ); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require( owner != address(0), "ERC721: owner query for nonexistent token" ); return owner; } /** * @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 baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @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 || 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 { _setApprovalForAll(_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 _owners[tokenId] != address(0); } /** * @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 || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal 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); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(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); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(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 from incorrect 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); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits a {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @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()) { try IERC721Receiver(to).onERC721Received( _msgSender(), from, tokenId, _data ) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert( "ERC721: transfer to non ERC721Receiver implementer" ); } else { assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @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` and `to` are never both zero. * * 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 {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File @openzeppelin/contracts/interfaces/IERC165.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol) // File @openzeppelin/contracts/interfaces/IERC2981.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC2981.sol) /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. * * _Available since v4.5._ */ interface IERC2981 is IERC165 { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be payed in that same unit of exchange. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // File @openzeppelin/contracts/token/common/ERC2981.sol // OpenZeppelin Contracts v4.4.0 (token/common/ERC2981.sol) /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC2981 is IERC2981, ERC165 { struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /** * @inheritdoc IERC2981 */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view override returns (address, uint256) { RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId]; if (royalty.receiver == address(0)) { royalty = _defaultRoyaltyInfo; } uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator(); return (royalty.receiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { require( feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice" ); require(receiver != address(0), "ERC2981: invalid receiver"); _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `tokenId` must be already minted. * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) internal virtual { require( feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice" ); require(receiver != address(0), "ERC2981: Invalid parameters"); _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } } // File @openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol // OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/ERC721Royalty.sol) /** * @dev Extension of ERC721 with the ERC2981 NFT Royalty Standard, a standardized way to retrieve royalty payment * information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC721Royalty is ERC2981, ERC721 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) { return super.supportsInterface(interfaceId); } /** * @dev See {ERC721-_burn}. This override additionally clears the royalty information for the token. */ function _burn(uint256 tokenId) internal virtual override { super._burn(tokenId); _resetTokenRoyalty(tokenId); } } // File @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol) /** * @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); /** * @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/extensions/ERC721Enumerable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol) /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require( index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds" ); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require( index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds" ); return _allTokens[index]; } /** * @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 override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File @openzeppelin/contracts/access/IOwnable.sol // OpenZeppelin Contracts v4.4.0 (access/Ownable.sol) interface IOwnable { function owner() external view returns (address); function pushOwnership(address newOwner) external; function pullOwnership() external; function renounceOwnership() external; function transferOwnership(address newOwner) external; } // File @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is IOwnable, Context { address private _owner; address private _newOwner; event OwnershipPushed( address indexed previousOwner, address indexed newOwner ); event OwnershipPulled( address indexed previousOwner, address indexed newOwner ); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual override 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 Sets up a push of the ownership of the contract to the specified * address which must subsequently pull the ownership to accept it. */ function pushOwnership(address newOwner) public virtual override onlyOwner { require( newOwner != address(0), "Ownable: new owner is the zero address" ); emit OwnershipPushed(_owner, newOwner); _newOwner = newOwner; } /** * @dev Accepts the push of ownership of the contract. Must be called by * the new owner. */ function pullOwnership() public virtual override { require(msg.sender == _newOwner, "Ownable: must be new owner to pull"); emit OwnershipPulled(_owner, _newOwner); _owner = _newOwner; } /** * @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 override onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual override onlyOwner { require( newOwner != address(0), "Ownable: new owner is the zero address" ); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File contracts/ERC721.sol contract FinancialNFT is ERC721Enumerable, ERC721Royalty, Ownable { using Counters for Counters.Counter; using Strings for uint256; using SafeERC20 for IERC20; Counters.Counter private _tokenIds; event Mint( address indexed owner, address indexed asset, uint256 amount, uint256 issue, uint256 term, uint256 indexed tokenId ); event Burn(uint256 indexed tokenId); string private baseURI_; address public URIHelper; modifier onlyHelper() { require(URIHelper == _msgSender(), "Helper: caller is not the helper"); _; } struct CertificateDetail { address asset; uint256 amount; uint256 issue; uint256 term; } mapping(uint256 => CertificateDetail) private _certificates; mapping(uint256 => string) private _URIs; constructor(string memory name, string memory symbol) ERC721(name, symbol) {} /** * @dev makes sure that we call the hook properly */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); } /** * @dev Burns the provided token * * Requirements: * * - tokenId must be owned by caller * - must be contract owner * - NFT must be matured */ function burn(uint256 tokenId) public onlyOwner { _burn(tokenId); } /** * @dev internal _burn override */ function _burn(uint256 tokenId) internal override(ERC721, ERC721Royalty) { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved" ); require(_exists(tokenId), "ERC721Burnable: burn of nonexistent token"); (, , , , , bool mature) = details(tokenId); require(mature, "ERC721Burnable: token cannot be burned until mature"); delete _certificates[tokenId]; delete _URIs[tokenId]; ERC721._burn(tokenId); _resetTokenRoyalty(tokenId); emit Burn(tokenId); } /** * @dev Retrieves the certificate details for the given token * * Requirements: * * - tokenId must exist */ function details(uint256 tokenId) public view returns ( address asset, uint256 amount, uint8 decimals, uint256 issue, uint256 term, bool mature ) { require( _exists(tokenId), "ERC721Metadata: details query for nonexistent token" ); CertificateDetail memory detail = _certificates[tokenId]; asset = detail.asset; amount = detail.amount; decimals = IERC20Metadata(asset).decimals(); issue = detail.issue; term = detail.term; mature = block.timestamp >= (issue + term); } /** * @dev Mints a new token with the given details * * Requirements: * * - Must be contract owner * - Term must be greater than 900 seconds */ function mint( address owner, address asset, uint256 amount, uint256 term ) public onlyOwner returns (uint256) { require(term >= 900, "ERC721: mint term must be greater than 900"); _tokenIds.increment(); uint256 newTokenId = _tokenIds.current(); _certificates[newTokenId] = CertificateDetail({ asset: asset, amount: amount, issue: block.timestamp, term: term }); _mint(owner, newTokenId); emit Mint(owner, asset, amount, block.timestamp, term, newTokenId); return newTokenId; } /** * @dev Changes the Base (shared) URI for tokens * * Requirements: * * - Must be contract owner */ function setBaseURI(string memory _baseURI) public onlyOwner { baseURI_ = _baseURI; } /** * @dev Sets the Default Royalty amount for token sales * * Requirements: * * - Must be contract owner */ function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner { _setDefaultRoyalty(receiver, feeNumerator); } /** * @dev Sets the token's CID * * Requirements: * * - Must be contract owner or URI helper */ function setTokenCID(uint256 tokenId, string memory CID) public { require( _msgSender() == URIHelper || _msgSender() == owner(), "ERC721Metadata: must be owner or helper" ); require( _exists(tokenId), "ERC721Metadata: CID set for nonexistent token" ); _URIs[tokenId] = CID; } /** * @dev sets the URI helper address that is permitted to update token URIs * * Requirements: * * - must be contract owner */ function setURIHelper(address _helper) public onlyOwner { URIHelper = _helper; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721Royalty, ERC721Enumerable) returns (bool) { return ERC721Royalty.supportsInterface(interfaceId) || ERC721Enumerable.supportsInterface(interfaceId) || super.supportsInterface(interfaceId); } /** * @dev Retrieves the token URI for the informational schema * * Generally speaking, as all of the pertinent data is stored * on-chain in the contract, the URI can be used to attach * additional metadata to the ERC721 including image, video, etc. * * Requirements: * * - tokenId must exist * */ function tokenURI(uint256 tokenId) public view override returns (string memory) { require( _exists(tokenId), "ERC721Metadata: URI query for nonexistent token" ); string memory CID = _URIs[tokenId]; return bytes(CID).length > 0 ? string(abi.encodePacked("ipfs://", CID)) : string(abi.encodePacked(baseURI_, tokenId.toString())); } /** * @dev allow for withdrawing native currency sent to the contract * * Requirements: * * - Must be contract owner */ function withdraw() public payable onlyOwner { (bool success, ) = payable(msg.sender).call{ value: address(this).balance }(""); require(success); } /** * @dev allow for withdrawing specific tokens send to the contract * * Requirements: * * - Must be contract owner */ function withdrawERC20(address _token) public onlyOwner { IERC20 token = IERC20(_token); SafeERC20.safeTransfer(token, owner(), token.balanceOf(address(this))); } /** * @dev catches native payments if users send such here */ receive() external payable {} }
[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"issue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"term","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipPulled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipPushed","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":"URIHelper","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"details","outputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"issue","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"},{"internalType":"bool","name":"mature","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"pullOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"pushOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"CID","type":"string"}],"name":"setTokenCID","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_helper","type":"address"}],"name":"setURIHelper","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":"view","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":"withdraw","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000005464558524100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054645585241000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name (string): FEXRA
Arg [1] : symbol (string): FEXRA
-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 4645585241000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 4645585241000000000000000000000000000000000000000000000000000000
Deployed ByteCode Sourcemap
65110:7540:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70575:374;;;;;;;;;;-1:-1:-1;70575:374:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;70575:374:0;;;;;;;;69541:167;;;;;;;;;;-1:-1:-1;69541:167:0;;;;;:::i;:::-;;:::i;:::-;;31345:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;33038:308::-;;;;;;;;;;-1:-1:-1;33038:308:0;;;;;:::i;:::-;;:::i;:::-;;;2403:42:1;2391:55;;;2373:74;;2361:2;2346:18;33038:308:0;2227:226:1;32561:411:0;;;;;;;;;;-1:-1:-1;32561:411:0;;;;;:::i;:::-;;:::i;53937:113::-;;;;;;;;;;-1:-1:-1;54025:10:0;:17;53937:113;;;2863:25:1;;;2851:2;2836:18;53937:113:0;2717:177:1;69853:379:0;;;;;;;;;;-1:-1:-1;69853:379:0;;;;;:::i;:::-;;:::i;33957:376::-;;;;;;;;;;-1:-1:-1;33957:376:0;;;;;:::i;:::-;;:::i;46904:490::-;;;;;;;;;;-1:-1:-1;46904:490:0;;;;;:::i;:::-;;:::i;:::-;;;;5196:42:1;5184:55;;;5166:74;;5271:2;5256:18;;5249:34;;;;5139:18;46904:490:0;4992:297:1;53518:343:0;;;;;;;;;;-1:-1:-1;53518:343:0;;;;;:::i;:::-;;:::i;71983:192::-;;;:::i;34404:185::-;;;;;;;;;;-1:-1:-1;34404:185:0;;;;;:::i;:::-;;:::i;66625:81::-;;;;;;;;;;-1:-1:-1;66625:81:0;;;;;:::i;:::-;;:::i;54127:320::-;;;;;;;;;;-1:-1:-1;54127:320:0;;;;;:::i;:::-;;:::i;69284:99::-;;;;;;;;;;-1:-1:-1;69284:99:0;;;;;:::i;:::-;;:::i;30952:326::-;;;;;;;;;;-1:-1:-1;30952:326:0;;;;;:::i;:::-;;:::i;30595:295::-;;;;;;;;;;-1:-1:-1;30595:295:0;;;;;:::i;:::-;;:::i;62730:112::-;;;;;;;;;;;;;:::i;62162:217::-;;;;;;;;;;;;;:::i;70409:94::-;;;;;;;;;;-1:-1:-1;70409:94:0;;;;;:::i;:::-;;:::i;61265:96::-;;;;;;;;;;-1:-1:-1;61347:6:0;;;;61265:96;;31514:104;;;;;;;;;;;;;:::i;67562:713::-;;;;;;;;;;-1:-1:-1;67562:713:0;;;;;:::i;:::-;;:::i;:::-;;;;6119:42:1;6107:55;;;6089:74;;6194:2;6179:18;;6172:34;;;;6254:4;6242:17;;;6222:18;;;6215:45;;;;6291:2;6276:18;;6269:34;6334:3;6319:19;;6312:35;;;;6391:14;6384:22;6378:3;6363:19;;6356:51;6076:3;6061:19;67562:713:0;5812:601:1;33418:187:0;;;;;;;;;;-1:-1:-1;33418:187:0;;;;;:::i;:::-;;:::i;65605:24::-;;;;;;;;;;-1:-1:-1;65605:24:0;;;;;;;;68474:659;;;;;;;;;;-1:-1:-1;68474:659:0;;;;;:::i;:::-;;:::i;34660:365::-;;;;;;;;;;-1:-1:-1;34660:365:0;;;;;:::i;:::-;;:::i;71326:488::-;;;;;;;;;;-1:-1:-1;71326:488:0;;;;;:::i;:::-;;:::i;61751:284::-;;;;;;;;;;-1:-1:-1;61751:284:0;;;;;:::i;:::-;;:::i;33676:214::-;;;;;;;;;;-1:-1:-1;33676:214:0;;;;;:::i;:::-;33847:25;;;;33818:4;33847:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;33676:214;62997:288;;;;;;;;;;-1:-1:-1;62997:288:0;;;;;:::i;:::-;;:::i;72344:187::-;;;;;;;;;;-1:-1:-1;72344:187:0;;;;;:::i;:::-;;:::i;70575:374::-;70738:4;70780:44;70812:11;70780:31;:44::i;:::-;:108;;;;70841:47;70876:11;70841:34;:47::i;:::-;70780:161;;;;70905:36;70929:11;70905:23;:36::i;:::-;70760:181;70575:374;-1:-1:-1;;70575:374:0:o;69541:167::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;;;;;;;;;69658:42:::1;69677:8;69687:12;69658:18;:42::i;:::-;69541:167:::0;;:::o;31345:100::-;31399:13;31432:5;31425:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31345:100;:::o;33038:308::-;33159:7;36661:16;;;:7;:16;;;;;;:30;:16;33184:110;;;;;;;9205:2:1;33184:110:0;;;9187:21:1;9244:2;9224:18;;;9217:30;9283:34;9263:18;;;9256:62;9354:14;9334:18;;;9327:42;9386:19;;33184:110:0;9003:408:1;33184:110:0;-1:-1:-1;33314:24:0;;;;:15;:24;;;;;;;;;33038:308::o;32561:411::-;32642:13;32658:23;32673:7;32658:14;:23::i;:::-;32642:39;;32706:5;32700:11;;:2;:11;;;;32692:57;;;;;;;9618:2:1;32692:57:0;;;9600:21:1;9657:2;9637:18;;;9630:30;9696:34;9676:18;;;9669:62;9767:3;9747:18;;;9740:31;9788:19;;32692:57:0;9416:397:1;32692:57:0;25521:10;32784:21;;;;;:62;;-1:-1:-1;32809:37:0;32826:5;25521:10;33676:214;:::i;32809:37::-;32762:168;;;;;;;10020:2:1;32762:168:0;;;10002:21:1;10059:2;10039:18;;;10032:30;10098:34;10078:18;;;10071:62;10169:26;10149:18;;;10142:54;10213:19;;32762:168:0;9818:420:1;32762:168:0;32943:21;32952:2;32956:7;32943:8;:21::i;:::-;32631:341;32561:411;;:::o;69853:379::-;69966:9;;;;25521:10;69950:25;;;:52;;;-1:-1:-1;61347:6:0;;;;25521:10;69979:23;69950:52;69928:141;;;;;;;10445:2:1;69928:141:0;;;10427:21:1;10484:2;10464:18;;;10457:30;10523:34;10503:18;;;10496:62;10594:9;10574:18;;;10567:37;10621:19;;69928:141:0;10243:403:1;69928:141:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;70080:111;;;;;;;10853:2:1;70080:111:0;;;10835:21:1;10892:2;10872:18;;;10865:30;10931:34;10911:18;;;10904:62;11002:15;10982:18;;;10975:43;11035:19;;70080:111:0;10651:409:1;70080:111:0;70204:14;;;;:5;:14;;;;;;;;:20;;;;;;;;:::i;33957:376::-;34166:41;25521:10;34185:12;34199:7;34166:18;:41::i;:::-;34144:140;;;;;;;11267:2:1;34144:140:0;;;11249:21:1;11306:2;11286:18;;;11279:30;11345:34;11325:18;;;11318:62;11416:19;11396:18;;;11389:47;11453:19;;34144:140:0;11065:413:1;34144:140:0;34297:28;34307:4;34313:2;34317:7;34297:9;:28::i;46904:490::-;47031:7;47094:27;;;:17;:27;;;;;;;;47065:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;47031:7;;47134:92;;-1:-1:-1;47185:29:0;;;;;;;;;-1:-1:-1;47185:29:0;;;;;;;;;;;;;;;47134:92;47276:23;;;;47238:21;;47760:5;;47263:36;;47262:71;47263:36;:10;:36;:::i;:::-;47262:71;;;;:::i;:::-;47354:16;;;;;-1:-1:-1;46904:490:0;;-1:-1:-1;;;;46904:490:0:o;53518:343::-;53660:7;53715:23;53732:5;53715:16;:23::i;:::-;53707:5;:31;53685:124;;;;;;;12421:2:1;53685:124:0;;;12403:21:1;12460:2;12440:18;;;12433:30;12499:34;12479:18;;;12472:62;12570:13;12550:18;;;12543:41;12601:19;;53685:124:0;12219:407:1;53685:124:0;-1:-1:-1;53827:19:0;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;53518:343::o;71983:192::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;72058:82:::1;::::0;72040:12:::1;::::0;72066:10:::1;::::0;72104:21:::1;::::0;72040:12;72058:82;72040:12;72058:82;72104:21;72066:10;72058:82:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72039:101;;;72159:7;72151:16;;;::::0;::::1;;72028:147;71983:192::o:0;34404:185::-;34542:39;34559:4;34565:2;34569:7;34542:39;;;;;;;;;;;;:16;:39::i;66625:81::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;66684:14:::1;66690:7;66684:5;:14::i;54127:320::-:0;54247:7;54302:30;54025:10;:17;;53937:113;54302:30;54294:5;:38;54272:132;;;;;;;13043:2:1;54272:132:0;;;13025:21:1;13082:2;13062:18;;;13055:30;13121:34;13101:18;;;13094:62;13192:14;13172:18;;;13165:42;13224:19;;54272:132:0;12841:408:1;54272:132:0;54422:10;54433:5;54422:17;;;;;;;;:::i;:::-;;;;;;;;;54415:24;;54127:320;;;:::o;69284:99::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;69356:19;;::::1;::::0;:8:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;30952:326::-:0;31069:7;31110:16;;;:7;:16;;;;;;;;31159:19;31137:110;;;;;;;13645:2:1;31137:110:0;;;13627:21:1;13684:2;13664:18;;;13657:30;13723:34;13703:18;;;13696:62;13794:11;13774:18;;;13767:39;13823:19;;31137:110:0;13443:405:1;30595:295:0;30712:7;30759:19;;;30737:111;;;;;;;14055:2:1;30737:111:0;;;14037:21:1;14094:2;14074:18;;;14067:30;14133:34;14113:18;;;14106:62;14204:12;14184:18;;;14177:40;14234:19;;30737:111:0;13853:406:1;30737:111:0;-1:-1:-1;30866:16:0;;;;;;:9;:16;;;;;;;30595:295::o;62730:112::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;62804:30:::1;62831:1;62804:18;:30::i;:::-;62730:112::o:0;62162:217::-;62244:9;;;;62230:10;:23;62222:70;;;;;;;14466:2:1;62222:70:0;;;14448:21:1;14505:2;14485:18;;;14478:30;14544:34;14524:18;;;14517:62;14615:4;14595:18;;;14588:32;14637:19;;62222:70:0;14264:398:1;62222:70:0;62332:9;;62324:6;;62308:34;;62332:9;;;;;62324:6;;;;62308:34;;62332:9;;62308:34;62362:9;;62353:6;:18;;;;62362:9;;;;62353:18;;;;;;62162:217::o;70409:94::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;70476:9:::1;:19:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;70409:94::o;31514:104::-;31570:13;31603:7;31596:14;;;;;:::i;67562:713::-;67658:13;67686:14;67715;67744:13;67772:12;67799:11;67860:16;67868:7;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;:30;;;36572:127;67860:16;67838:117;;;;;;;14869:2:1;67838:117:0;;;14851:21:1;14908:2;14888:18;;;14881:30;14947:34;14927:18;;;14920:62;15018:21;14998:18;;;14991:49;15057:19;;67838:117:0;14667:415:1;67838:117:0;67968:31;68002:22;;;:13;:22;;;;;;;;;67968:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68116:32;;;;;;;67968:56;;-1:-1:-1;67968:56:0;;-1:-1:-1;67968:56:0;;;68116:30;;:32;;;;;;;;;;67968:56;68116:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68169:12;;;;68201:11;;;;68105:43;;-1:-1:-1;68169:12:0;-1:-1:-1;68201:11:0;-1:-1:-1;68254:12:0;68201:11;68169:12;68254;:::i;:::-;68234:15;:33;;68225:42;;67827:448;67562:713;;;;;;;:::o;33418:187::-;33545:52;25521:10;33578:8;33588;33545:18;:52::i;68474:659::-;61347:6;;68617:7;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;68653:3:::1;68645:4;:11;;68637:66;;;::::0;::::1;::::0;;15700:2:1;68637:66:0::1;::::0;::::1;15682:21:1::0;15739:2;15719:18;;;15712:30;15778:34;15758:18;;;15751:62;15849:12;15829:18;;;15822:40;15879:19;;68637:66:0::1;15498:406:1::0;68637:66:0::1;68716:21;:9;64696:19:::0;;64714:1;64696:19;;;64607:127;68716:21:::1;68750:18;68771:19;:9;64577:14:::0;;64485:114;68771:19:::1;68831:148;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;68927:15:::1;68831:148:::0;;;;;;;;;;;;-1:-1:-1;68803:25:0;;;:13:::1;:25:::0;;;;;;;:176;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;;-1:-1:-1;68803:176:0;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;::::1;::::0;:25;-1:-1:-1;68992:24:0::1;68998:5:::0;68803:25;68992:5:::1;:24::i;:::-;69034:61;::::0;;16111:25:1;;;69061:15:0::1;16167:2:1::0;16152:18;;16145:34;16195:18;;;16188:34;;;69084:10:0;;69034:61:::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;16099:2:1;16084:18;69034:61:0::1;;;;;;;69115:10:::0;-1:-1:-1;61565:1:0::1;68474:659:::0;;;;;;:::o;34660:365::-;34849:41;25521:10;34882:7;34849:18;:41::i;:::-;34827:140;;;;;;;11267:2:1;34827:140:0;;;11249:21:1;11306:2;11286:18;;;11279:30;11345:34;11325:18;;;11318:62;11416:19;11396:18;;;11389:47;11453:19;;34827:140:0;11065:413:1;34827:140:0;34978:39;34992:4;34998:2;35002:7;35011:5;34978:13;:39::i;:::-;34660:365;;;;:::o;71326:488::-;36637:4;36661:16;;;:7;:16;;;;;;71427:13;;36661:30;:16;71458:113;;;;;;;16435:2:1;71458:113:0;;;16417:21:1;16474:2;16454:18;;;16447:30;16513:34;16493:18;;;16486:62;16584:17;16564:18;;;16557:45;16619:19;;71458:113:0;16233:411:1;71458:113:0;71584:17;71604:14;;;:5;:14;;;;;71584:34;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71671:1;71657:3;71651:17;:21;:155;;71776:8;71786:18;:7;:16;:18::i;:::-;71759:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71651:155;;;71727:3;71699:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;71651:155;71631:175;71326:488;-1:-1:-1;;;71326:488:0:o;61751:284::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;61859:22:::1;::::0;::::1;61837:110;;;::::0;::::1;::::0;;18890:2:1;61837:110:0::1;::::0;::::1;18872:21:1::0;18929:2;18909:18;;;18902:30;18968:34;18948:18;;;18941:62;19039:8;19019:18;;;19012:36;19065:19;;61837:110:0::1;18688:402:1::0;61837:110:0::1;61979:6;::::0;61963:33:::1;::::0;::::1;::::0;;::::1;::::0;61979:6:::1;::::0;61963:33:::1;::::0;61979:6:::1;::::0;61963:33:::1;62007:9;:20:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;61751:284::o;62997:288::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;63150:22:::1;::::0;::::1;63128:110;;;::::0;::::1;::::0;;18890:2:1;63128:110:0::1;::::0;::::1;18872:21:1::0;18929:2;18909:18;;;18902:30;18968:34;18948:18;;;18941:62;19039:8;19019:18;;;19012:36;19065:19;;63128:110:0::1;18688:402:1::0;63128:110:0::1;63249:28;63268:8;63249:18;:28::i;72344:187::-:0;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;72433:6;72453:70:::1;72433:6:::0;72483:7:::1;61347:6:::0;;;;;61265:96;72483:7:::1;72492:30;::::0;;;;72516:4:::1;72492:30;::::0;::::1;2373:74:1::0;72492:15:0::1;::::0;::::1;::::0;::::1;::::0;2346:18:1;;72492:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72453:22;:70::i;50603:220::-:0;50750:4;50779:36;50803:11;53134:300;53281:4;53323:50;;;53338:35;53323:50;;:103;;;53390:36;53414:11;53390:23;:36::i;48044:392::-;47760:5;48184:33;;;;;48162:125;;;;;;;19486:2:1;48162:125:0;;;19468:21:1;19525:2;19505:18;;;19498:30;19564:34;19544:18;;;19537:62;19635:12;19615:18;;;19608:40;19665:19;;48162:125:0;19284:406:1;48162:125:0;48306:22;;;48298:60;;;;;;;19897:2:1;48298:60:0;;;19879:21:1;19936:2;19916:18;;;19909:30;19975:27;19955:18;;;19948:55;20020:18;;48298:60:0;19695:349:1;48298:60:0;48393:35;;;;;;;;;;;;;;;;;;;;;;;;;;;48371:57;;;;;-1:-1:-1;48371:57:0;48044:392::o;40859:174::-;40934:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;40988:23;40934:24;40988:14;:23::i;:::-;40979:46;;;;;;;;;;;;40859:174;;:::o;36866:452::-;36995:4;36661:16;;;:7;:16;;;;;;:30;:16;37017:110;;;;;;;20251:2:1;37017:110:0;;;20233:21:1;20290:2;20270:18;;;20263:30;20329:34;20309:18;;;20302:62;20400:14;20380:18;;;20373:42;20432:19;;37017:110:0;20049:408:1;37017:110:0;37138:13;37154:23;37169:7;37154:14;:23::i;:::-;37138:39;;37207:5;37196:16;;:7;:16;;;:64;;;;37253:7;37229:31;;:20;37241:7;37229:11;:20::i;:::-;:31;;;37196:64;:113;;;-1:-1:-1;33847:25:0;;;;33818:4;33847:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;37277:32;33676:214;40079:662;40252:4;40225:31;;:23;40240:7;40225:14;:23::i;:::-;:31;;;40203:118;;;;;;;20664:2:1;40203:118:0;;;20646:21:1;20703:2;20683:18;;;20676:30;20742:34;20722:18;;;20715:62;20813:7;20793:18;;;20786:35;20838:19;;40203:118:0;20462:401:1;40203:118:0;40340:16;;;40332:65;;;;;;;21070:2:1;40332:65:0;;;21052:21:1;21109:2;21089:18;;;21082:30;21148:34;21128:18;;;21121:62;21219:6;21199:18;;;21192:34;21243:19;;40332:65:0;20868:400:1;40332:65:0;40410:39;40431:4;40437:2;40441:7;40410:20;:39::i;:::-;40514:29;40531:1;40535:7;40514:8;:29::i;:::-;40556:15;;;;;;;:9;:15;;;;;:20;;40575:1;;40556:15;:20;;40575:1;;40556:20;:::i;:::-;;;;-1:-1:-1;;40587:13:0;;;;;;;:9;:13;;;;;:18;;40604:1;;40587:13;:18;;40604:1;;40587:18;:::i;:::-;;;;-1:-1:-1;;40616:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;40655:27;;40616:16;;40655:27;;;;;;;32631:341;32561:411;;:::o;66769:633::-;66875:41;25521:10;66894:12;25441:98;66875:41;66853:139;;;;;;;21605:2:1;66853:139:0;;;21587:21:1;21644:2;21624:18;;;21617:30;21683:34;21663:18;;;21656:62;21754:18;21734;;;21727:46;21790:19;;66853:139:0;21403:412:1;66853:139:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;67005:70;;;;;;;22022:2:1;67005:70:0;;;22004:21:1;22061:2;22041:18;;;22034:30;22100:34;22080:18;;;22073:62;22171:11;22151:18;;;22144:39;22200:19;;67005:70:0;21820:405:1;67005:70:0;67099:11;67114:16;67122:7;67114;:16::i;:::-;67088:42;;;;;;;67151:6;67143:70;;;;;;;22432:2:1;67143:70:0;;;22414:21:1;22471:2;22451:18;;;22444:30;22510:34;22490:18;;;22483:62;22581:21;22561:18;;;22554:49;22620:19;;67143:70:0;22230:415:1;67143:70:0;67233:22;;;;:13;:22;;;;;;;;67226:29;;;;;;;;;;;;;;;;;;;;;;;67275:5;:14;;;;;67268:21;;;:::i;:::-;67302;67315:7;67302:12;:21::i;:::-;49549:26;;;;:17;:26;;;;;49542:33;67381:13;;67386:7;;67381:13;;;;;66842:560;66769:633;:::o;63445:191::-;63538:6;;;;63555:17;;;;;;;;;;;63588:40;;63538:6;;;63555:17;63538:6;;63588:40;;63519:16;;63588:40;63508:128;63445:191;:::o;41175:315::-;41330:8;41321:17;;:5;:17;;;;41313:55;;;;;;;22852:2:1;41313:55:0;;;22834:21:1;22891:2;22871:18;;;22864:30;22930:27;22910:18;;;22903:55;22975:18;;41313:55:0;22650:349:1;41313:55:0;41379:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;41441:41;;586::1;;;41441::0;;559:18:1;41441:41:0;;;;;;;41175:315;;;:::o;38654:439::-;38734:16;;;38726:61;;;;;;;23206:2:1;38726:61:0;;;23188:21:1;;;23225:18;;;23218:30;23284:34;23264:18;;;23257:62;23336:18;;38726:61:0;23004:356:1;38726:61:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;:30;38798:58;;;;;;;23567:2:1;38798:58:0;;;23549:21:1;23606:2;23586:18;;;23579:30;23645;23625:18;;;23618:58;23693:18;;38798:58:0;23365:352:1;38798:58:0;38869:45;38898:1;38902:2;38906:7;38869:20;:45::i;:::-;38927:13;;;;;;;:9;:13;;;;;:18;;38944:1;;38927:13;:18;;38944:1;;38927:18;:::i;:::-;;;;-1:-1:-1;;38956:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;38995:33;;38956:16;;;38995:33;;38956:16;;38995:33;69541:167;;:::o;35907:352::-;36064:28;36074:4;36080:2;36084:7;36064:9;:28::i;:::-;36125:48;36148:4;36154:2;36158:7;36167:5;36125:22;:48::i;:::-;36103:148;;;;;;;23924:2:1;36103:148:0;;;23906:21:1;23963:2;23943:18;;;23936:30;24002:34;23982:18;;;23975:62;24073:20;24053:18;;;24046:48;24111:19;;36103:148:0;23722:414:1;25990:723:0;26046:13;26267:10;26263:53;;-1:-1:-1;;26294:10:0;;;;;;;;;;;;;;;;;;25990:723::o;26263:53::-;26341:5;26326:12;26382:78;26389:9;;26382:78;;26415:8;;;;:::i;:::-;;-1:-1:-1;26438:10:0;;-1:-1:-1;26446:2:0;26438:10;;:::i;:::-;;;26382:78;;;26470:19;26502:6;26492:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26492:17:0;;26470:39;;26520:154;26527:10;;26520:154;;26554:11;26564:1;26554:11;;:::i;:::-;;-1:-1:-1;26623:10:0;26631:2;26623:5;:10;:::i;:::-;26610:24;;:2;:24;:::i;:::-;26597:39;;26580:6;26587;26580:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;26651:11:0;26660:2;26651:11;;:::i;:::-;;;26520:154;;12658:248;12829:58;;;5196:42:1;5184:55;;12829:58:0;;;5166:74:1;5256:18;;;;5249:34;;;12829:58:0;;;;;;;;;;5139:18:1;;;;12829:58:0;;;;;;;;;;12852:23;12829:58;;;12775:123;;12809:5;;12775:19;:123::i;30176:355::-;30323:4;30365:40;;;30380:25;30365:40;;:105;;-1:-1:-1;30422:48:0;;;30437:33;30422:48;30365:105;:158;;;;30487:36;30511:11;30487:23;:36::i;66195:223::-;66365:45;66392:4;66398:2;66402:7;66365:26;:45::i;39322:420::-;39382:13;39398:23;39413:7;39398:14;:23::i;:::-;39382:39;;39434:48;39455:5;39470:1;39474:7;39434:20;:48::i;:::-;39523:29;39540:1;39544:7;39523:8;:29::i;:::-;39565:16;;;;;;;:9;:16;;;;;:21;;39585:1;;39565:16;:21;;39585:1;;39565:21;:::i;:::-;;;;-1:-1:-1;;39604:16:0;;;;:7;:16;;;;;;39597:23;;;;;;39638:36;39612:7;;39604:16;39597:23;39638:36;;;;;39604:16;;39638:36;69541:167;;:::o;42055:980::-;42210:4;42231:13;;;4553:19;:23;42227:801;;42284:175;;;;;:36;;;;;;:175;;25521:10;;42378:4;;42405:7;;42435:5;;42284:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42284:175:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;42263:710;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42642:13:0;;42638:320;;42685:108;;;;;23924:2:1;42685:108:0;;;23906:21:1;23963:2;23943:18;;;23936:30;24002:34;23982:18;;;23975:62;24073:20;24053:18;;;24046:48;24111:19;;42685:108:0;23722:414:1;42638:320:0;42908:6;42902:13;42893:6;42889:2;42885:15;42878:38;42263:710;42523:51;;42533:41;42523:51;;-1:-1:-1;42516:58:0;;42227:801;-1:-1:-1;43012:4:0;43005:11;;15625:802;16049:23;16075:106;16117:4;16075:106;;;;;;;;;;;;;;;;;16083:5;16075:27;;;;:106;;;;;:::i;:::-;16196:17;;16049:132;;-1:-1:-1;16196:21:0;16192:228;;16311:10;16300:30;;;;;;;;;;;;:::i;:::-;16274:134;;;;;;;25692:2:1;16274:134:0;;;25674:21:1;25731:2;25711:18;;;25704:30;25770:34;25750:18;;;25743:62;25841:12;25821:18;;;25814:40;25871:19;;16274:134:0;25490:406:1;46558:291:0;46705:4;46747:41;;;46762:26;46747:41;;:94;;-1:-1:-1;28788:25:0;28773:40;;;;46805:36;28614:207;55060:589;55266:18;;;55262:187;;55301:40;55333:7;56476:10;:17;;56449:24;;;;:15;:24;;;;;:44;;;56504:24;;;;;;;;;;;;56372:164;55301:40;55262:187;;;55371:2;55363:10;;:4;:10;;;55359:90;;55390:47;55423:4;55429:7;55390:32;:47::i;:::-;55463:16;;;55459:183;;55496:45;55533:7;55496:36;:45::i;55459:183::-;55569:4;55563:10;;:2;:10;;;55559:83;;55590:40;55618:2;55622:7;55590:27;:40::i;7100:229::-;7237:12;7269:52;7291:6;7299:4;7305:1;7308:12;7269:21;:52::i;57163:1002::-;57443:22;57493:1;57468:22;57485:4;57468:16;:22::i;:::-;:26;;;;:::i;:::-;57505:18;57526:26;;;:17;:26;;;;;;57443:51;;-1:-1:-1;57659:28:0;;;57655:328;;57726:18;;;57704:19;57726:18;;;:12;:18;;;;;;;;:34;;;;;;;;;57777:30;;;;;;:44;;;57894:30;;:17;:30;;;;;:43;;;57655:328;-1:-1:-1;58079:26:0;;;;:17;:26;;;;;;;;58072:33;;;58123:18;;;;;;:12;:18;;;;;:34;;;;;;;58116:41;57163:1002::o;58460:1079::-;58738:10;:17;58713:22;;58738:21;;58758:1;;58738:21;:::i;:::-;58770:18;58791:24;;;:15;:24;;;;;;59164:10;:26;;58713:46;;-1:-1:-1;58791:24:0;;58713:46;;59164:26;;;;;;:::i;:::-;;;;;;;;;59142:48;;59228:11;59203:10;59214;59203:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;59308:28;;;:15;:28;;;;;;;:41;;;59480:24;;;;;59473:31;59515:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;58531:1008;;;58460:1079;:::o;55950:221::-;56035:14;56052:20;56069:2;56052:16;:20::i;:::-;56083:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;56128:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;55950:221:0:o;8316:571::-;8486:12;8558:5;8533:21;:30;;8511:118;;;;;;;26292:2:1;8511:118:0;;;26274:21:1;26331:2;26311:18;;;26304:30;26370:34;26350:18;;;26343:62;26441:8;26421:18;;;26414:36;26467:19;;8511:118:0;26090:402:1;8511:118:0;4553:19;;;;8640:60;;;;;;;26699:2:1;8640:60:0;;;26681:21:1;26738:2;26718:18;;;26711:30;26777:31;26757:18;;;26750:59;26826:18;;8640:60:0;26497:353:1;8640:60:0;8714:12;8728:23;8755:6;:11;;8774:5;8795:4;8755:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8713:97;;;;8828:51;8845:7;8854:10;8866:12;8828:16;:51::i;:::-;8821:58;8316:571;-1:-1:-1;;;;;;;8316:571:0:o;11276:712::-;11426:12;11455:7;11451:530;;;-1:-1:-1;11486:10:0;11479:17;;11451:530;11600:17;;:21;11596:374;;11798:10;11792:17;11859:15;11846:10;11842:2;11838:19;11831:44;11596:374;11941:12;11934:20;;;;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:177:1;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:196::-;706:20;;766:42;755:54;;745:65;;735:93;;824:1;821;814:12;735:93;638:196;;;:::o;839:366::-;906:6;914;967:2;955:9;946:7;942:23;938:32;935:52;;;983:1;980;973:12;935:52;1006:29;1025:9;1006:29;:::i;:::-;996:39;;1085:2;1074:9;1070:18;1057:32;1129:26;1122:5;1118:38;1111:5;1108:49;1098:77;;1171:1;1168;1161:12;1098:77;1194:5;1184:15;;;839:366;;;;;:::o;1210:258::-;1282:1;1292:113;1306:6;1303:1;1300:13;1292:113;;;1382:11;;;1376:18;1363:11;;;1356:39;1328:2;1321:10;1292:113;;;1423:6;1420:1;1417:13;1414:48;;;-1:-1:-1;;1458:1:1;1440:16;;1433:27;1210:258::o;1473:328::-;1526:3;1564:5;1558:12;1591:6;1586:3;1579:19;1607:63;1663:6;1656:4;1651:3;1647:14;1640:4;1633:5;1629:16;1607:63;:::i;:::-;1715:2;1703:15;1720:66;1699:88;1690:98;;;;1790:4;1686:109;;1473:328;-1:-1:-1;;1473:328:1:o;1806:231::-;1955:2;1944:9;1937:21;1918:4;1975:56;2027:2;2016:9;2012:18;2004:6;1975:56;:::i;2042:180::-;2101:6;2154:2;2142:9;2133:7;2129:23;2125:32;2122:52;;;2170:1;2167;2160:12;2122:52;-1:-1:-1;2193:23:1;;2042:180;-1:-1:-1;2042:180:1:o;2458:254::-;2526:6;2534;2587:2;2575:9;2566:7;2562:23;2558:32;2555:52;;;2603:1;2600;2593:12;2555:52;2626:29;2645:9;2626:29;:::i;:::-;2616:39;2702:2;2687:18;;;;2674:32;;-1:-1:-1;;;2458:254:1:o;2899:184::-;2951:77;2948:1;2941:88;3048:4;3045:1;3038:15;3072:4;3069:1;3062:15;3088:691;3153:5;3183:18;3224:2;3216:6;3213:14;3210:40;;;3230:18;;:::i;:::-;3364:2;3358:9;3430:2;3418:15;;3269:66;3414:24;;;3440:2;3410:33;3406:42;3394:55;;;3464:18;;;3484:22;;;3461:46;3458:72;;;3510:18;;:::i;:::-;3550:10;3546:2;3539:22;3579:6;3570:15;;3609:6;3601;3594:22;3649:3;3640:6;3635:3;3631:16;3628:25;3625:45;;;3666:1;3663;3656:12;3625:45;3716:6;3711:3;3704:4;3696:6;3692:17;3679:44;3771:1;3764:4;3755:6;3747;3743:19;3739:30;3732:41;;;;3088:691;;;;;:::o;3784:222::-;3827:5;3880:3;3873:4;3865:6;3861:17;3857:27;3847:55;;3898:1;3895;3888:12;3847:55;3920:80;3996:3;3987:6;3974:20;3967:4;3959:6;3955:17;3920:80;:::i;4011:390::-;4089:6;4097;4150:2;4138:9;4129:7;4125:23;4121:32;4118:52;;;4166:1;4163;4156:12;4118:52;4202:9;4189:23;4179:33;;4263:2;4252:9;4248:18;4235:32;4290:18;4282:6;4279:30;4276:50;;;4322:1;4319;4312:12;4276:50;4345;4387:7;4378:6;4367:9;4363:22;4345:50;:::i;:::-;4335:60;;;4011:390;;;;;:::o;4406:328::-;4483:6;4491;4499;4552:2;4540:9;4531:7;4527:23;4523:32;4520:52;;;4568:1;4565;4558:12;4520:52;4591:29;4610:9;4591:29;:::i;:::-;4581:39;;4639:38;4673:2;4662:9;4658:18;4639:38;:::i;:::-;4629:48;;4724:2;4713:9;4709:18;4696:32;4686:42;;4406:328;;;;;:::o;4739:248::-;4807:6;4815;4868:2;4856:9;4847:7;4843:23;4839:32;4836:52;;;4884:1;4881;4874:12;4836:52;-1:-1:-1;;4907:23:1;;;4977:2;4962:18;;;4949:32;;-1:-1:-1;4739:248:1:o;5294:322::-;5363:6;5416:2;5404:9;5395:7;5391:23;5387:32;5384:52;;;5432:1;5429;5422:12;5384:52;5472:9;5459:23;5505:18;5497:6;5494:30;5491:50;;;5537:1;5534;5527:12;5491:50;5560;5602:7;5593:6;5582:9;5578:22;5560:50;:::i;5621:186::-;5680:6;5733:2;5721:9;5712:7;5708:23;5704:32;5701:52;;;5749:1;5746;5739:12;5701:52;5772:29;5791:9;5772:29;:::i;6418:118::-;6504:5;6497:13;6490:21;6483:5;6480:32;6470:60;;6526:1;6523;6516:12;6541:315;6606:6;6614;6667:2;6655:9;6646:7;6642:23;6638:32;6635:52;;;6683:1;6680;6673:12;6635:52;6706:29;6725:9;6706:29;:::i;:::-;6696:39;;6785:2;6774:9;6770:18;6757:32;6798:28;6820:5;6798:28;:::i;6861:397::-;6947:6;6955;6963;6971;7024:3;7012:9;7003:7;6999:23;6995:33;6992:53;;;7041:1;7038;7031:12;6992:53;7064:29;7083:9;7064:29;:::i;:::-;7054:39;;7112:38;7146:2;7135:9;7131:18;7112:38;:::i;:::-;6861:397;;7102:48;;-1:-1:-1;;;;7197:2:1;7182:18;;7169:32;;7248:2;7233:18;7220:32;;6861:397::o;7263:667::-;7358:6;7366;7374;7382;7435:3;7423:9;7414:7;7410:23;7406:33;7403:53;;;7452:1;7449;7442:12;7403:53;7475:29;7494:9;7475:29;:::i;:::-;7465:39;;7523:38;7557:2;7546:9;7542:18;7523:38;:::i;:::-;7513:48;;7608:2;7597:9;7593:18;7580:32;7570:42;;7663:2;7652:9;7648:18;7635:32;7690:18;7682:6;7679:30;7676:50;;;7722:1;7719;7712:12;7676:50;7745:22;;7798:4;7790:13;;7786:27;-1:-1:-1;7776:55:1;;7827:1;7824;7817:12;7776:55;7850:74;7916:7;7911:2;7898:16;7893:2;7889;7885:11;7850:74;:::i;:::-;7840:84;;;7263:667;;;;;;;:::o;7935:260::-;8003:6;8011;8064:2;8052:9;8043:7;8039:23;8035:32;8032:52;;;8080:1;8077;8070:12;8032:52;8103:29;8122:9;8103:29;:::i;:::-;8093:39;;8151:38;8185:2;8174:9;8170:18;8151:38;:::i;:::-;8141:48;;7935:260;;;;;:::o;8561:437::-;8640:1;8636:12;;;;8683;;;8704:61;;8758:4;8750:6;8746:17;8736:27;;8704:61;8811:2;8803:6;8800:14;8780:18;8777:38;8774:218;;;8848:77;8845:1;8838:88;8949:4;8946:1;8939:15;8977:4;8974:1;8967:15;8774:218;;8561:437;;;:::o;11483:184::-;11535:77;11532:1;11525:88;11632:4;11629:1;11622:15;11656:4;11653:1;11646:15;11672:228;11712:7;11838:1;11770:66;11766:74;11763:1;11760:81;11755:1;11748:9;11741:17;11737:105;11734:131;;;11845:18;;:::i;:::-;-1:-1:-1;11885:9:1;;11672:228::o;11905:184::-;11957:77;11954:1;11947:88;12054:4;12051:1;12044:15;12078:4;12075:1;12068:15;12094:120;12134:1;12160;12150:35;;12165:18;;:::i;:::-;-1:-1:-1;12199:9:1;;12094:120::o;13254:184::-;13306:77;13303:1;13296:88;13403:4;13400:1;13393:15;13427:4;13424:1;13417:15;15087:273;15155:6;15208:2;15196:9;15187:7;15183:23;15179:32;15176:52;;;15224:1;15221;15214:12;15176:52;15256:9;15250:16;15306:4;15299:5;15295:16;15288:5;15285:27;15275:55;;15326:1;15323;15316:12;15365:128;15405:3;15436:1;15432:6;15429:1;15426:13;15423:39;;;15442:18;;:::i;:::-;-1:-1:-1;15478:9:1;;15365:128::o;16775:185::-;16817:3;16855:5;16849:12;16870:52;16915:6;16910:3;16903:4;16896:5;16892:16;16870:52;:::i;:::-;16938:16;;;;;16775:185;-1:-1:-1;;16775:185:1:o;16965:1289::-;17141:3;17170:1;17203:6;17197:13;17233:3;17255:1;17283:9;17279:2;17275:18;17265:28;;17343:2;17332:9;17328:18;17365;17355:61;;17409:4;17401:6;17397:17;17387:27;;17355:61;17435:2;17483;17475:6;17472:14;17452:18;17449:38;17446:222;;;17522:77;17517:3;17510:90;17623:4;17620:1;17613:15;17653:4;17648:3;17641:17;17446:222;17684:18;17711:162;;;;17887:1;17882:320;;;;17677:525;;17711:162;17759:66;17748:9;17744:82;17739:3;17732:95;17856:6;17851:3;17847:16;17840:23;;17711:162;;17882:320;16722:1;16715:14;;;16759:4;16746:18;;17977:1;17991:165;18005:6;18002:1;17999:13;17991:165;;;18083:14;;18070:11;;;18063:35;18126:16;;;;18020:10;;17991:165;;;17995:3;;18185:6;18180:3;18176:16;18169:23;;17677:525;;;;;;;18218:30;18244:3;18236:6;18218:30;:::i;:::-;18211:37;16965:1289;-1:-1:-1;;;;;16965:1289:1:o;18259:424::-;18521:9;18516:3;18509:22;18491:3;18560:6;18554:13;18576:61;18630:6;18626:1;18621:3;18617:11;18610:4;18602:6;18598:17;18576:61;:::i;:::-;18657:16;;;;18675:1;18653:24;;18259:424;-1:-1:-1;;18259:424:1:o;19095:184::-;19165:6;19218:2;19206:9;19197:7;19193:23;19189:32;19186:52;;;19234:1;19231;19224:12;19186:52;-1:-1:-1;19257:16:1;;19095:184;-1:-1:-1;19095:184:1:o;21273:125::-;21313:4;21341:1;21338;21335:8;21332:34;;;21346:18;;:::i;:::-;-1:-1:-1;21383:9:1;;21273:125::o;24141:195::-;24180:3;24211:66;24204:5;24201:77;24198:103;;;24281:18;;:::i;:::-;-1:-1:-1;24328:1:1;24317:13;;24141:195::o;24341:112::-;24373:1;24399;24389:35;;24404:18;;:::i;:::-;-1:-1:-1;24438:9:1;;24341:112::o;24458:523::-;24652:4;24681:42;24762:2;24754:6;24750:15;24739:9;24732:34;24814:2;24806:6;24802:15;24797:2;24786:9;24782:18;24775:43;;24854:6;24849:2;24838:9;24834:18;24827:34;24897:3;24892:2;24881:9;24877:18;24870:31;24918:57;24970:3;24959:9;24955:19;24947:6;24918:57;:::i;:::-;24910:65;24458:523;-1:-1:-1;;;;;;24458:523:1:o;24986:249::-;25055:6;25108:2;25096:9;25087:7;25083:23;25079:32;25076:52;;;25124:1;25121;25114:12;25076:52;25156:9;25150:16;25175:30;25199:5;25175:30;:::i;25240:245::-;25307:6;25360:2;25348:9;25339:7;25335:23;25331:32;25328:52;;;25376:1;25373;25366:12;25328:52;25408:9;25402:16;25427:28;25449:5;25427:28;:::i;25901:184::-;25953:77;25950:1;25943:88;26050:4;26047:1;26040:15;26074:4;26071:1;26064:15;26855:274;26984:3;27022:6;27016:13;27038:53;27084:6;27079:3;27072:4;27064:6;27060:17;27038:53;:::i;:::-;27107:16;;;;;26855:274;-1:-1:-1;;26855:274:1:o
Swarm Source
ipfs://361214e83bbf7c1f004f4cb6eb8195155f825142b621095dc2d738fe8fff83a9