Contract 0x19d0cd1ebe1d93e352e49a0c126e136508126622

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x8f5c950d9e82d8f831db12d05189226e439631ce2cf4aee5a26a53e1f16616d80x6080604024165372021-10-21 6:03:24862 days 2 hrs agoTreasure DAO: Deployer IN  Create: CardsBase0 ETH0.053978223689 ETH0.794204168
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xe2d3252048f741ab378510518886a28b3b3100321c09a4b9c662e7250bea94c2720866312023-03-21 10:18:39345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xe2d3252048f741ab378510518886a28b3b3100321c09a4b9c662e7250bea94c2720866312023-03-21 10:18:39345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xf1ae90f8a697db8fb84e9b34d6d8490cc5cfb74791c805422ca6be420e265eab720864162023-03-21 10:17:50345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xf1ae90f8a697db8fb84e9b34d6d8490cc5cfb74791c805422ca6be420e265eab720864162023-03-21 10:17:50345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x046e1a426f7f1383c770754704c9cb5564aa91cb66338e481de2222d4c72f53f720863492023-03-21 10:17:33345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xcdc8d4d87928a05ac52de96d5aee27f6121b0a266fe2ee55d9164edaf088030b720858802023-03-21 10:15:33345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xcdc8d4d87928a05ac52de96d5aee27f6121b0a266fe2ee55d9164edaf088030b720858802023-03-21 10:15:33345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x13585d6c105af432d0e72797d1f873f6504ab5242ab46a5a1c53ec598c2fabd0720856742023-03-21 10:14:42345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xb4fa65ab3abe78ddd240f43e60ebb1c1ff5e05b8479f51a4c254f8fd909a8e89720852622023-03-21 10:12:58345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xb4fa65ab3abe78ddd240f43e60ebb1c1ff5e05b8479f51a4c254f8fd909a8e89720852622023-03-21 10:12:58345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xb19ee9696a37a7f4b62c4fd4b6755d0f6a8be23c335ff946fa73f5cad4f4d9e9720851752023-03-21 10:12:36345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xb19ee9696a37a7f4b62c4fd4b6755d0f6a8be23c335ff946fa73f5cad4f4d9e9720851752023-03-21 10:12:36345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xdd081337845da10333c5db36baa2fe868f3a228a77aa8149fe74eb8eadf41cfa720851062023-03-21 10:12:18345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xdd081337845da10333c5db36baa2fe868f3a228a77aa8149fe74eb8eadf41cfa720851062023-03-21 10:12:18345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x8bad2abfdd5262f9e9be51058d275d53571eff2cc5c038c7f9a63a360cabf781720850392023-03-21 10:12:01345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x8bad2abfdd5262f9e9be51058d275d53571eff2cc5c038c7f9a63a360cabf781720850392023-03-21 10:12:01345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x416a42f1ed3c60b334fac3243fc6bb0f864a0be4049b5063490c188773fbc185720849442023-03-21 10:11:43345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x416a42f1ed3c60b334fac3243fc6bb0f864a0be4049b5063490c188773fbc185720849442023-03-21 10:11:43345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x4cb019a5b4ff861f93c4d7801f517fc4334310b330844d639466b62f6af3a7ba720847522023-03-21 10:10:53345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x4cb019a5b4ff861f93c4d7801f517fc4334310b330844d639466b62f6af3a7ba720847522023-03-21 10:10:53345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xa2405b25a247bb85979d98d5d2d21d39d4c27b7025faed881f9cb110e2efc0e6720846462023-03-21 10:10:26345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xa2405b25a247bb85979d98d5d2d21d39d4c27b7025faed881f9cb110e2efc0e6720846462023-03-21 10:10:26345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x119a66acccbd16d3320d01542814a48691bb8715594b39b0733c4662706ac999720845752023-03-21 10:10:08345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0x119a66acccbd16d3320d01542814a48691bb8715594b39b0733c4662706ac999720845752023-03-21 10:10:08345 days 22 hrs ago Treasure DAO: Treasures 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
0xa8dec37d324a1c261654a6be71258867e11484abb4e85addd1521f4e099664d6720845122023-03-21 10:09:52345 days 22 hrs ago 0x3956c81a51feaed98d7a678d53f44b9166c8ed66 0x19d0cd1ebe1d93e352e49a0c126e1365081266220 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
CardsBase

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 23 : CardsBase.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import '@solidstate/contracts/token/ERC1155/ERC1155.sol';

contract CardsBase is ERC1155 {
    function uri(uint256 tokenId) public view override returns (string memory) {
        return string(abi.encodePacked(super.uri(tokenId), '.json'));
    }
}

File 2 of 23 : ERC1155.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { ERC165 } from '../../introspection/ERC165.sol';
import { ERC1155Base, ERC1155BaseInternal } from './base/ERC1155Base.sol';
import { ERC1155Enumerable } from './enumerable/ERC1155Enumerable.sol';
import { ERC1155Metadata } from './metadata/ERC1155Metadata.sol';

/**
 * @title SolidState ERC1155 implementation
 */
abstract contract ERC1155 is
    ERC1155Base,
    ERC1155Enumerable,
    ERC1155Metadata,
    ERC165
{
    /**
     * @inheritdoc ERC1155BaseInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override(ERC1155BaseInternal, ERC1155Enumerable) {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

File 3 of 23 : ERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from './IERC165.sol';
import { ERC165Storage } from './ERC165Storage.sol';

/**
 * @title ERC165 implementation
 */
abstract contract ERC165 is IERC165 {
    using ERC165Storage for ERC165Storage.Layout;

    /**
     * @inheritdoc IERC165
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override
        returns (bool)
    {
        return ERC165Storage.layout().isSupportedInterface(interfaceId);
    }
}

File 4 of 23 : ERC1155Base.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155 } from '../IERC1155.sol';
import { IERC1155Receiver } from '../IERC1155Receiver.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from './ERC1155BaseInternal.sol';

/**
 * @title Base ERC1155 contract
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155Base is IERC1155, ERC1155BaseInternal {
    /**
     * @inheritdoc IERC1155
     */
    function balanceOf(address account, uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _balanceOf(account, id);
    }

    /**
     * @inheritdoc IERC1155
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(
            accounts.length == ids.length,
            'ERC1155: accounts and ids length mismatch'
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        uint256[] memory batchBalances = new uint256[](accounts.length);

        unchecked {
            for (uint256 i; i < accounts.length; i++) {
                require(
                    accounts[i] != address(0),
                    'ERC1155: batch balance query for the zero address'
                );
                batchBalances[i] = balances[ids[i]][accounts[i]];
            }
        }

        return batchBalances;
    }

    /**
     * @inheritdoc IERC1155
     */
    function isApprovedForAll(address account, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return ERC1155BaseStorage.layout().operatorApprovals[account][operator];
    }

    /**
     * @inheritdoc IERC1155
     */
    function setApprovalForAll(address operator, bool status)
        public
        virtual
        override
    {
        require(
            msg.sender != operator,
            'ERC1155: setting approval status for self'
        );
        ERC1155BaseStorage.layout().operatorApprovals[msg.sender][
            operator
        ] = status;
        emit ApprovalForAll(msg.sender, operator, status);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == msg.sender || isApprovedForAll(from, msg.sender),
            'ERC1155: caller is not owner nor approved'
        );
        _safeTransfer(msg.sender, from, to, id, amount, data);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == msg.sender || isApprovedForAll(from, msg.sender),
            'ERC1155: caller is not owner nor approved'
        );
        _safeTransferBatch(msg.sender, from, to, ids, amounts, data);
    }
}

File 5 of 23 : ERC1155Enumerable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';
import { ERC1155Base, ERC1155BaseInternal } from '../base/ERC1155Base.sol';
import { IERC1155Enumerable } from './IERC1155Enumerable.sol';
import { ERC1155EnumerableInternal, ERC1155EnumerableStorage } from './ERC1155EnumerableInternal.sol';

/**
 * @title ERC1155 implementation including enumerable and aggregate functions
 */
abstract contract ERC1155Enumerable is
    IERC1155Enumerable,
    ERC1155Base,
    ERC1155EnumerableInternal
{
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalSupply(uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return ERC1155EnumerableStorage.layout().totalSupply[id];
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalHolders(uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return ERC1155EnumerableStorage.layout().accountsByToken[id].length();
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function accountsByToken(uint256 id)
        public
        view
        virtual
        override
        returns (address[] memory)
    {
        EnumerableSet.AddressSet storage accounts = ERC1155EnumerableStorage
            .layout()
            .accountsByToken[id];

        address[] memory addresses = new address[](accounts.length());

        for (uint256 i; i < accounts.length(); i++) {
            addresses[i] = accounts.at(i);
        }

        return addresses;
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function tokensByAccount(address account)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        EnumerableSet.UintSet storage tokens = ERC1155EnumerableStorage
            .layout()
            .tokensByAccount[account];

        uint256[] memory ids = new uint256[](tokens.length());

        for (uint256 i; i < tokens.length(); i++) {
            ids[i] = tokens.at(i);
        }

        return ids;
    }

    /**
     * @notice ERC1155 hook: update aggregate values
     * @inheritdoc ERC1155EnumerableInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        internal
        virtual
        override(ERC1155BaseInternal, ERC1155EnumerableInternal)
    {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

File 6 of 23 : ERC1155Metadata.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { UintUtils } from '../../../utils/UintUtils.sol';
import { IERC1155Metadata } from './IERC1155Metadata.sol';
import { ERC1155MetadataInternal } from './ERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @notice ERC1155 metadata extensions
 */
abstract contract ERC1155Metadata is IERC1155Metadata, ERC1155MetadataInternal {
    using UintUtils for uint256;

    /**
     * @notice inheritdoc IERC1155Metadata
     */
    function uri(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        ERC1155MetadataStorage.Layout storage l = ERC1155MetadataStorage
            .layout();

        string memory tokenIdURI = l.tokenURIs[tokenId];
        string memory baseURI = l.baseURI;

        if (bytes(baseURI).length == 0) {
            return tokenIdURI;
        } else if (bytes(tokenIdURI).length > 0) {
            return string(abi.encodePacked(baseURI, tokenIdURI));
        } else {
            return string(abi.encodePacked(baseURI, tokenId.toString()));
        }
    }
}

File 7 of 23 : IERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC165 interface registration interface
 * @dev see https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice query whether contract has registered support for given interface
     * @param interfaceId interface id
     * @return bool whether interface is supported
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

File 8 of 23 : ERC165Storage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library ERC165Storage {
    struct Layout {
        mapping(bytes4 => bool) supportedInterfaces;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC165');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function isSupportedInterface(Layout storage l, bytes4 interfaceId)
        internal
        view
        returns (bool)
    {
        return l.supportedInterfaces[interfaceId];
    }

    function setSupportedInterface(
        Layout storage l,
        bytes4 interfaceId,
        bool status
    ) internal {
        require(interfaceId != 0xffffffff, 'ERC165: invalid interface id');
        l.supportedInterfaces[interfaceId] = status;
    }
}

File 9 of 23 : IERC1155.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155Internal } from './IERC1155Internal.sol';
import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @notice ERC1155 interface
 * @dev see https://github.com/ethereum/EIPs/issues/1155
 */
interface IERC1155 is IERC1155Internal, IERC165 {
    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function balanceOf(address account, uint256 id)
        external
        view
        returns (uint256);

    /**
     * @notice query the balances of given tokens held by given addresses
     * @param accounts addresss to query
     * @param ids tokens to query
     * @return token balances
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @notice query approval status of given operator with respect to given address
     * @param account address to query for approval granted
     * @param operator address to query for approval received
     * @return whether operator is approved to spend tokens held by account
     */
    function isApprovedForAll(address account, address operator)
        external
        view
        returns (bool);

    /**
     * @notice grant approval to or revoke approval from given operator to spend held tokens
     * @param operator address whose approval status to update
     * @param status whether operator should be considered approved
     */
    function setApprovalForAll(address operator, bool status) external;

    /**
     * @notice transfer tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @notice transfer batch of tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to transfer
     * @param data data payload
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

File 10 of 23 : IERC1155Receiver.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @title ERC1155 transfer receiver interface
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @notice validate receipt of ERC1155 transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param id token ID received
     * @param value quantity of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @notice validate receipt of ERC1155 batch transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param ids token IDs received
     * @param values quantities of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

File 11 of 23 : ERC1155BaseInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { AddressUtils } from '../../../utils/AddressUtils.sol';
import { IERC1155Internal } from '../IERC1155Internal.sol';
import { IERC1155Receiver } from '../IERC1155Receiver.sol';
import { ERC1155BaseStorage } from './ERC1155BaseStorage.sol';

/**
 * @title Base ERC1155 internal functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155BaseInternal is IERC1155Internal {
    using AddressUtils for address;

    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function _balanceOf(address account, uint256 id)
        internal
        view
        virtual
        returns (uint256)
    {
        require(
            account != address(0),
            'ERC1155: balance query for the zero address'
        );
        return ERC1155BaseStorage.layout().balances[id][account];
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(account != address(0), 'ERC1155: mint to the zero address');

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        mapping(address => uint256) storage balances = ERC1155BaseStorage
            .layout()
            .balances[id];
        balances[account] += amount;

        emit TransferSingle(msg.sender, address(0), account, id, amount);
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _safeMint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _doSafeTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            id,
            amount,
            data
        );
        _mint(account, id, amount, data);
    }

    /**
     * @notice mint batch of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _mintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(account != address(0), 'ERC1155: mint to the zero address');
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        for (uint256 i; i < ids.length; i++) {
            balances[ids[i]][account] += amounts[i];
        }

        emit TransferBatch(msg.sender, address(0), account, ids, amounts);
    }

    /**
     * @notice mint batch of tokens for given address
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _safeMintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _doSafeBatchTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );
        _mintBatch(account, ids, amounts, data);
    }

    /**
     * @notice burn given quantity of tokens held by given address
     * @param account holder of tokens to burn
     * @param id token ID
     * @param amount quantity of tokens to burn
     */
    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(account != address(0), 'ERC1155: burn from the zero address');

        _beforeTokenTransfer(
            msg.sender,
            account,
            address(0),
            _asSingletonArray(id),
            _asSingletonArray(amount),
            ''
        );

        mapping(address => uint256) storage balances = ERC1155BaseStorage
            .layout()
            .balances[id];

        unchecked {
            require(
                balances[account] >= amount,
                'ERC1155: burn amount exceeds balances'
            );
            balances[account] -= amount;
        }

        emit TransferSingle(msg.sender, account, address(0), id, amount);
    }

    /**
     * @notice burn given batch of tokens held by given address
     * @param account holder of tokens to burn
     * @param ids token IDs
     * @param amounts quantities of tokens to burn
     */
    function _burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(account != address(0), 'ERC1155: burn from the zero address');
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(msg.sender, account, address(0), ids, amounts, '');

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            for (uint256 i; i < ids.length; i++) {
                uint256 id = ids[i];
                require(
                    balances[id][account] >= amounts[i],
                    'ERC1155: burn amount exceeds balance'
                );
                balances[id][account] -= amounts[i];
            }
        }

        emit TransferBatch(msg.sender, account, address(0), ids, amounts);
    }

    /**
     * @notice transfer tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _transfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(
            recipient != address(0),
            'ERC1155: transfer to the zero address'
        );

        _beforeTokenTransfer(
            operator,
            sender,
            recipient,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            uint256 senderBalance = balances[id][sender];
            require(
                senderBalance >= amount,
                'ERC1155: insufficient balances for transfer'
            );
            balances[id][sender] = senderBalance - amount;
        }

        balances[id][recipient] += amount;

        emit TransferSingle(operator, sender, recipient, id, amount);
    }

    /**
     * @notice transfer tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _safeTransfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _doSafeTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            id,
            amount,
            data
        );
        _transfer(operator, sender, recipient, id, amount, data);
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _transferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(
            recipient != address(0),
            'ERC1155: transfer to the zero address'
        );
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(operator, sender, recipient, ids, amounts, data);

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        for (uint256 i; i < ids.length; i++) {
            uint256 token = ids[i];
            uint256 amount = amounts[i];

            unchecked {
                uint256 senderBalance = balances[token][sender];
                require(
                    senderBalance >= amount,
                    'ERC1155: insufficient balances for transfer'
                );
                balances[token][sender] = senderBalance - amount;
            }

            balances[token][recipient] += amount;
        }

        emit TransferBatch(operator, sender, recipient, ids, amounts);
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _safeTransferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _doSafeBatchTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            ids,
            amounts,
            data
        );
        _transferBatch(operator, sender, recipient, ids, amounts, data);
    }

    /**
     * @notice wrap given element in array of length 1
     * @param element element to wrap
     * @return singleton array
     */
    function _asSingletonArray(uint256 element)
        private
        pure
        returns (uint256[] memory)
    {
        uint256[] memory array = new uint256[](1);
        array[0] = element;
        return array;
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155Received(
                    operator,
                    from,
                    id,
                    amount,
                    data
                )
            returns (bytes4 response) {
                require(
                    response == IERC1155Receiver.onERC1155Received.selector,
                    'ERC1155: ERC1155Receiver rejected tokens'
                );
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert('ERC1155: transfer to non ERC1155Receiver implementer');
            }
        }
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    amounts,
                    data
                )
            returns (bytes4 response) {
                require(
                    response ==
                        IERC1155Receiver.onERC1155BatchReceived.selector,
                    'ERC1155: ERC1155Receiver rejected tokens'
                );
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert('ERC1155: transfer to non ERC1155Receiver implementer');
            }
        }
    }

    /**
     * @notice ERC1155 hook, called before all transfers including mint and burn
     * @dev function should be overridden and new implementation must call super
     * @dev called for both single and batch transfers
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}
}

File 12 of 23 : IERC1155Internal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @notice Partial ERC1155 interface needed by internal functions
 */
interface IERC1155Internal {
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );
}

File 13 of 23 : AddressUtils.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library AddressUtils {
    function toString(address account) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(uint160(account)));
        bytes memory alphabet = '0123456789abcdef';
        bytes memory chars = new bytes(42);

        chars[0] = '0';
        chars[1] = 'x';

        for (uint256 i = 0; i < 20; i++) {
            chars[2 + i * 2] = alphabet[uint8(value[i + 12] >> 4)];
            chars[3 + i * 2] = alphabet[uint8(value[i + 12] & 0x0f)];
        }

        return string(chars);
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable account, uint256 amount) internal {
        (bool success, ) = account.call{ value: amount }('');
        require(success, 'AddressUtils: failed to send value');
    }

    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionCall(target, data, 'AddressUtils: failed low-level call');
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory error
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, error);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                'AddressUtils: failed low-level call with value'
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            'AddressUtils: insufficient balance for call'
        );
        return _functionCallWithValue(target, data, value, error);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) private returns (bytes memory) {
        require(
            isContract(target),
            'AddressUtils: function call to non-contract'
        );

        (bool success, bytes memory returnData) = target.call{ value: value }(
            data
        );

        if (success) {
            return returnData;
        } else if (returnData.length > 0) {
            assembly {
                let returnData_size := mload(returnData)
                revert(add(32, returnData), returnData_size)
            }
        } else {
            revert(error);
        }
    }
}

File 14 of 23 : ERC1155BaseStorage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library ERC1155BaseStorage {
    struct Layout {
        mapping(uint256 => mapping(address => uint256)) balances;
        mapping(address => mapping(address => bool)) operatorApprovals;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Base');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

File 15 of 23 : EnumerableSet.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Set implementation with enumeration functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
 */
library EnumerableSet {
    struct Set {
        bytes32[] _values;
        // 1-indexed to allow 0 to signify nonexistence
        mapping(bytes32 => uint256) _indexes;
    }

    struct Bytes32Set {
        Set _inner;
    }

    struct AddressSet {
        Set _inner;
    }

    struct UintSet {
        Set _inner;
    }

    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }

    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    function indexOf(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, value);
    }

    function indexOf(AddressSet storage set, address value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, bytes32(uint256(uint160(value))));
    }

    function indexOf(UintSet storage set, uint256 value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, bytes32(value));
    }

    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }

    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        require(
            set._values.length > index,
            'EnumerableSet: index out of bounds'
        );
        return set._values[index];
    }

    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    function _indexOf(Set storage set, bytes32 value)
        private
        view
        returns (uint256)
    {
        unchecked {
            return set._indexes[value] - 1;
        }
    }

    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    function _remove(Set storage set, bytes32 value) private returns (bool) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            uint256 index = valueIndex - 1;
            bytes32 last = set._values[set._values.length - 1];

            // move last value to now-vacant index

            set._values[index] = last;
            set._indexes[last] = index + 1;

            // clear last index

            set._values.pop();
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }
}

File 16 of 23 : IERC1155Enumerable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC1155 enumerable and aggregate function interface
 */
interface IERC1155Enumerable {
    /**
     * @notice query total minted supply of given token
     * @param id token id to query
     * @return token supply
     */
    function totalSupply(uint256 id) external view returns (uint256);

    /**
     * @notice query total number of holders for given token
     * @param id token id to query
     * @return quantity of holders
     */
    function totalHolders(uint256 id) external view returns (uint256);

    /**
     * @notice query holders of given token
     * @param id token id to query
     * @return list of holder addresses
     */
    function accountsByToken(uint256 id)
        external
        view
        returns (address[] memory);

    /**
     * @notice query tokens held by given address
     * @param account address to query
     * @return list of token ids
     */
    function tokensByAccount(address account)
        external
        view
        returns (uint256[] memory);
}

File 17 of 23 : ERC1155EnumerableInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from '../base/ERC1155BaseInternal.sol';
import { ERC1155EnumerableStorage } from './ERC1155EnumerableStorage.sol';

/**
 * @title ERC1155Enumerable internal functions
 */
abstract contract ERC1155EnumerableInternal is ERC1155BaseInternal {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @notice ERC1155 hook: update aggregate values
     * @inheritdoc ERC1155BaseInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from != to) {
            ERC1155EnumerableStorage.Layout storage l = ERC1155EnumerableStorage
                .layout();
            mapping(uint256 => EnumerableSet.AddressSet)
                storage tokenAccounts = l.accountsByToken;
            EnumerableSet.UintSet storage fromTokens = l.tokensByAccount[from];
            EnumerableSet.UintSet storage toTokens = l.tokensByAccount[to];

            for (uint256 i; i < ids.length; i++) {
                uint256 amount = amounts[i];

                if (amount > 0) {
                    uint256 id = ids[i];

                    if (from == address(0)) {
                        l.totalSupply[id] += amount;
                    } else if (_balanceOf(from, id) == amount) {
                        tokenAccounts[id].remove(from);
                        fromTokens.remove(id);
                    }

                    if (to == address(0)) {
                        l.totalSupply[id] -= amount;
                    } else if (_balanceOf(to, id) == 0) {
                        tokenAccounts[id].add(to);
                        toTokens.add(id);
                    }
                }
            }
        }
    }
}

File 18 of 23 : ERC1155EnumerableStorage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';

library ERC1155EnumerableStorage {
    struct Layout {
        mapping(uint256 => uint256) totalSupply;
        mapping(uint256 => EnumerableSet.AddressSet) accountsByToken;
        mapping(address => EnumerableSet.UintSet) tokensByAccount;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Enumerable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

File 19 of 23 : UintUtils.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library UintUtils {
    function toString(uint256 value) internal pure returns (string memory) {
        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);
    }
}

File 20 of 23 : IERC1155Metadata.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC1155Metadata interface
 */
interface IERC1155Metadata {
    /**
     * @notice get generated URI for given token
     * @return token URI
     */
    function uri(uint256 tokenId) external view returns (string memory);
}

File 21 of 23 : ERC1155MetadataInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155MetadataInternal } from './IERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @notice ERC1155Metadata internal functions
 */
abstract contract ERC1155MetadataInternal is IERC1155MetadataInternal {
    /**
     * @notice set base metadata URI
     * @dev base URI is a non-standard feature adapted from the ERC721 specification
     * @param baseURI base URI
     */
    function _setBaseURI(string memory baseURI) internal {
        ERC1155MetadataStorage.layout().baseURI = baseURI;
    }

    /**
     * @notice set per-token metadata URI
     * @param tokenId token whose metadata URI to set
     * @param tokenURI per-token URI
     */
    function _setTokenURI(uint256 tokenId, string memory tokenURI) internal {
        ERC1155MetadataStorage.layout().tokenURIs[tokenId] = tokenURI;
        emit URI(tokenURI, tokenId);
    }
}

File 22 of 23 : ERC1155MetadataStorage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @notice ERC1155 metadata extensions
 */
library ERC1155MetadataStorage {
    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Metadata');

    struct Layout {
        string baseURI;
        mapping(uint256 => string) tokenURIs;
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

File 23 of 23 : IERC1155MetadataInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Partial ERC1155Metadata interface needed by internal functions
 */
interface IERC1155MetadataInternal {
    event URI(string value, uint256 indexed tokenId);
}

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

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"accountsByToken","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"status","type":"bool"}],"name":"setApprovalForAll","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":[{"internalType":"address","name":"account","type":"address"}],"name":"tokensByAccount","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

Deployed Bytecode

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

Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.