Contract 0x09e8ec3182678442c346977a2b0fd5be639cde25

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

import "./ERC1155NonTransferableUpgradeable.sol";

interface ICommunityRegistry {
    function doesCommunityExist(string memory uniqId) external view returns (bool);
}

contract KudosV7 is
    Initializable,
    OwnableUpgradeable,
    PausableUpgradeable,
    ERC1155NonTransferableUpgradeable
{
    ////////////////////////////////// CONSTANTS //////////////////////////////////
    /// @notice The name of this contract
    string public constant CONTRACT_NAME = "Kudos";

    /// @notice The version of this contract
    string public constant CONTRACT_VERSION = "7";

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 private constant DOMAIN_TYPE_HASH =
        keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );

    /// @notice The EIP-712 typehash for the Kudos input struct used by the contract
    bytes32 public constant KUDOS_TYPE_HASH =
        keccak256(
            "Kudos(string headline,string description,uint256 startDateTimestamp,uint256 endDateTimestamp,string[] links,string communityUniqId,bool isSignatureRequired,bool isAllowlistRequired,int256 totalClaimCount,uint256 expirationTimestamp)"
        );

    /// @notice The EIP-712 typehash for the claiming flow by the contract
    bytes32 public constant CLAIM_TYPE_HASH =
        keccak256("Claim(uint256 tokenId)");
    
    /// @notice The EIP-712 typehash for adding new allowlisted addresses to an existing Kudos token
    bytes32 public constant ADD_ALLOWLISTED_ADDRESSES_TYPE_HASH = keccak256("AllowlistedAddress(uint256 tokenId)");

    ////////////////////////////////// STRUCTS //////////////////////////////////
    /// @dev Struct used to contain the Kudos metadata input
    ///      Also, note that using structs in mappings should be safe:
    ///      https://forum.openzeppelin.com/t/how-to-use-a-struct-in-an-upgradable-contract/832/4
    struct KudosInputContainer {
        string headline;
        string description;
        uint256 startDateTimestamp;
        uint256 endDateTimestamp;
        string[] links;
        string communityUniqId;
        KudosContributorsInputContainer contributorMerkleRoots;

        KudosClaimabilityAttributesInputContainer claimabilityAttributes;
    }

    /// @dev Struct used to contain the full Kudos metadata at the time of mint
    struct KudosContainer {
        string headline;
        string description;
        uint256 startDateTimestamp;
        uint256 endDateTimestamp;
        string[] links;
        string DEPRECATED_communityDiscordId;    // don't use this value anymore
        string DEPRECATED_communityName;         // don't use this value anymore
        address creator;
        uint256 registeredTimestamp;
        string communityUniqId;

        KudosClaimabilityAttributesContainer claimabilityAttributes;
    }

    struct KudosClaimabilityAttributesInputContainer {
        bool isSignatureRequired;
        bool isAllowlistRequired;

        int256 totalClaimCount; // -1 indicates infinite
        uint256 expirationTimestamp; // 0 indicates no expiration
    }

    struct KudosClaimabilityAttributesContainer {
        bool isSignatureRequired;
        bool isAllowlistRequired;

        int256 totalClaimCount; // -1 indicates infinite
        uint256 remainingClaimCount; // if totalClaimCount = -1 then irrelevant
        uint256 expirationTimestamp; // 0 indicates no expiration
    }

    /// @dev Struct used to contain string and address Kudos contributors
    struct KudosContributorsInputContainer {
        bytes32 stringContributorsMerkleRoot;
        bytes32 addressContributorsMerkleRoot;
    }

    /// @dev Struct used to contain merkle tree roots of string and address contributors.
    ///      Note that the actual list of contributors is left DEPRECATED in order to not change the
    ///      existing data when upgrading.
    struct KudosContributorsContainer {
        string[] DEPRECATED_stringContributors;
        address[] DEPRECATED_addressContributors;
        bytes32 stringContributorsMerkleRoot;
        bytes32 addressContributorsMerkleRoot;
    }

    /// @dev This event is solely so that we can easily track which creator registered
    ///      which Kudos tokens without having to store the mapping on-chain.
    event RegisteredKudos(address creator, uint256 tokenId);

    ////////////////////////////////// VARIABLES //////////////////////////////////
    /// @dev This has been deprecated to allow for mapping tokens to both string and address contributors.
    mapping(uint256 => address[]) public DEPRECATED_tokenIdToContributors;

    mapping(uint256 => KudosContainer) public tokenIdToKudosContainer;

    /// @notice This value signifies the largest tokenId value that has not been used yet.
    /// Whenever we register a new token, we increment this value by one, so essentially the tokenID
    /// signifies the total number of types of tokens registered through this contract.
    uint256 public latestUnusedTokenId;

    /// @notice the address pointing to the community registry
    address public communityRegistryAddress;

    /// @dev Mapping from tokens to string and address Kudos contributors
    mapping(uint256 => KudosContributorsContainer) private tokenIdToContributors;

    ////////////////////////////////// CODE //////////////////////////////////
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() initializer {}

    function initialize(uint256 _latestUnusedTokenId) public initializer {
        __ERC1155_init("https://api.mintkudos.xyz/metadata/{id}");
        __Ownable_init();
        __Pausable_init();
        __ERC1155Supply_init();

        // We start with some passed-in latest unused token ID
        if (_latestUnusedTokenId > 0) {
            latestUnusedTokenId = _latestUnusedTokenId;
        } else {
            latestUnusedTokenId = 1;
        }

        // Start off the contract as paused
        _pause();
    }

    /// @notice Allows owner to set new URI that contains token metadata
    /// @param newuri               The Kudos creator's address
    function setURI(string memory newuri) public onlyOwner whenNotPaused {
        _setURI(newuri);
    }

    /// @notice Setting the latest unused token ID value so we can start the next token mint from a different ID.
    /// @param _latestUnusedTokenId  The latest unused token ID that should be set in the contract
    function setLatestUnusedTokenId(uint256 _latestUnusedTokenId) public onlyOwner whenPaused {
        latestUnusedTokenId = _latestUnusedTokenId;
    }

    /// @notice Setting the contract address of the community registry
    /// @param _communityRegistryAddress The community registry address
    function setCommunityRegistryAddress(address _communityRegistryAddress) public onlyOwner {
        communityRegistryAddress = _communityRegistryAddress;
    }

    /// @notice Register new Kudos token type for contributors to claim.
    /// @dev This just allowlists the tokens that are able to claim this particular token type, but it does not necessarily mint the token until later.
    ///      Note that because we are using signed messages, if the Kudos input data is not the same as what it was at the time of user signing, the
    ///      function call with fail. This ensures that whatever the user signs is what will get minted, and that we as the admins cannot tamper with
    ///      the content of a Kudos.
    /// @param creator              The Kudos creator's address
    /// @param metadata             Metadata of the Kudos token
    /// @param v                    Part of the creator's signature (v)
    /// @param r                    Part of the creator's signature (r)
    /// @param s                    Part of the creator's signature (s)
    function registerBySig(
        address creator,
        KudosInputContainer memory metadata,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public onlyOwner whenNotPaused {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPE_HASH,
                keccak256(bytes(CONTRACT_NAME)),
                keccak256(bytes(CONTRACT_VERSION)),
                block.chainid,
                address(this)
            )
        );
        bytes32 structHash = keccak256(
            abi.encode(
                KUDOS_TYPE_HASH,
                keccak256(bytes(metadata.headline)),
                keccak256(bytes(metadata.description)),
                metadata.startDateTimestamp,
                metadata.endDateTimestamp,
                convertStringArraytoByte32(metadata.links),
                keccak256(bytes(metadata.communityUniqId)),
                metadata.claimabilityAttributes.isSignatureRequired,
                metadata.claimabilityAttributes.isAllowlistRequired,
                metadata.claimabilityAttributes.totalClaimCount,
                metadata.claimabilityAttributes.expirationTimestamp
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked("\x19\x01", domainSeparator, structHash)
        );
        address signatory = ecrecover(digest, v, r, s);
        require(signatory == creator, "invalid signature");

        _register(signatory, metadata);
    }

    function _register(
        address creator,
        KudosInputContainer memory metadata
    ) internal {
        // Note that we currently don't have an easy way to de-duplicate Kudos tokens.
        // Because we are the only ones that can mint Kudos for now (since we're covering the cost),
        // we will gate duplicated tokens in the caller side.
        // However, once we open this up to the public (if the public wants to pay for their own Kudos at some point),
        // we may need to come up with some validation routine here to prevent the "same" Kudos from being minted.

        // Translate the Kudos input container to the actual container
        require(ICommunityRegistry(communityRegistryAddress).doesCommunityExist(metadata.communityUniqId), "uniqId does not exist in registry");

        KudosContainer memory kc;
        kc.creator = creator;
        kc.headline = metadata.headline;
        kc.description = metadata.description;
        kc.startDateTimestamp = metadata.startDateTimestamp;
        kc.endDateTimestamp = metadata.endDateTimestamp;
        kc.links = metadata.links;
        kc.communityUniqId = metadata.communityUniqId;
        kc.registeredTimestamp = block.timestamp;

        kc.claimabilityAttributes.isSignatureRequired = metadata.claimabilityAttributes.isSignatureRequired;
        kc.claimabilityAttributes.isAllowlistRequired = metadata.claimabilityAttributes.isAllowlistRequired;

        // Register the contributor merkle roots for the allowlist
        // This is used later in the claim flow to see if an address can actually claim the token or not.
        if (kc.claimabilityAttributes.isAllowlistRequired) {
            tokenIdToContributors[latestUnusedTokenId].addressContributorsMerkleRoot = metadata.contributorMerkleRoots.addressContributorsMerkleRoot;
            tokenIdToContributors[latestUnusedTokenId].stringContributorsMerkleRoot = metadata.contributorMerkleRoots.stringContributorsMerkleRoot;

            require(metadata.claimabilityAttributes.totalClaimCount == 0, "Total claim count should not be set if allowlist is required");
        }

        kc.claimabilityAttributes.totalClaimCount = metadata.claimabilityAttributes.totalClaimCount;
        if (kc.claimabilityAttributes.totalClaimCount > 0) {
            kc.claimabilityAttributes.remainingClaimCount = uint256(kc.claimabilityAttributes.totalClaimCount);
        }
        kc.claimabilityAttributes.expirationTimestamp = metadata.claimabilityAttributes.expirationTimestamp;

        // Store the metadata into a mapping for viewing later
        tokenIdToKudosContainer[latestUnusedTokenId] = kc;

        emit RegisteredKudos(creator, latestUnusedTokenId);

        // increment the latest unused TokenId because we now have an additionally registered
        // token.
        latestUnusedTokenId++;
    }

    /// @notice Mints a token for the specified address if allowlisted
    /// @param id                  ID of the Token
    /// @param claimingAddress     Claiming address
    /// @param v                   Part of the claimee's signature (v)
    /// @param r                   Part of the claimee's signature (r)
    /// @param s                   Part of the claimee's signature (s)
    /// @param merkleProof         Merkle proof for the particular claiming address
    function claim(
        uint256 id,
        address claimingAddress,
        uint8 v,
        bytes32 r,
        bytes32 s,
        bytes32[] calldata merkleProof
    ) public onlyOwner whenNotPaused {
        _validateClaimability(id, claimingAddress, v, r, s);

        if (tokenIdToKudosContainer[id].claimabilityAttributes.isAllowlistRequired) {
            require(
                MerkleProofUpgradeable.verify(
                    merkleProof,
                    tokenIdToContributors[id].addressContributorsMerkleRoot,
                    generateAddressMerkleLeaf(claimingAddress)
                ),
                "address not allowlisted"
            );
        }

        _claim(id, claimingAddress);
    }
    
    /// @notice Mints a token for the specified address if allowlisted without signature 
    ///         verification that the string contributor is owned by the claimee address. 
    ///         The integrity will be checked off-chain.
    /// @param id                  ID of the Token
    /// @param claimingAddress     Claiming address
    /// @param v                   Part of the claimee's signature (v)
    /// @param r                   Part of the claimee's signature (r)
    /// @param s                   Part of the claimee's signature (s)
    /// @param contributor         String ID of the contributor that should claim this token
    /// @param merkleProof         Merkle proof for the particular claiming address
    function unsafeClaim(
        uint256 id,
        address claimingAddress,
        uint8 v,
        bytes32 r,
        bytes32 s,
        string memory contributor,
        bytes32[] calldata merkleProof
    ) public onlyOwner whenNotPaused {
        _validateClaimability(id, claimingAddress, v, r, s);
    
        if (tokenIdToKudosContainer[id].claimabilityAttributes.isAllowlistRequired) {
            require(
                MerkleProofUpgradeable.verify(
                    merkleProof,
                    tokenIdToContributors[id].stringContributorsMerkleRoot,
                    generateStringMerkleLeaf(contributor)
                ),
                "contributor not allowlisted"
            );
            
        }

        _claim(id, claimingAddress);
    }


    function _claim(uint256 id, address dst) internal {
        // Address dst should not already have the token
        require(
            balanceOf(dst, id) == 0,
            "address should not own token"
        );

        // If everything is allowed, then mint the token for dst
        _mint(dst, id, 1, "");

        // Decrement counter if necessary
        bool hasFiniteCount = tokenIdToKudosContainer[id].claimabilityAttributes.totalClaimCount > 0;
        if (hasFiniteCount) {
            tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount--;
        }
    }

    function _validateClaimability(
        uint256 id,
        address claimee,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal view {
        require(tokenIdToKudosContainer[id].creator != address(0), "token does not exist");

        bool hasExpirationSet = tokenIdToKudosContainer[id].claimabilityAttributes.expirationTimestamp != 0;
        require(!hasExpirationSet || hasExpirationSet && tokenIdToKudosContainer[id].claimabilityAttributes.expirationTimestamp > block.timestamp, "token claim expired");

        // if not allowlist flow, then check to make sure there are enough tokens to claim
        bool isAllowlistRequired = tokenIdToKudosContainer[id].claimabilityAttributes.isAllowlistRequired;
        bool hasClaimCountLimit = tokenIdToKudosContainer[id].claimabilityAttributes.totalClaimCount >= 0;
        uint256 remainingCount = tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount;
        require(isAllowlistRequired || !isAllowlistRequired && (!hasClaimCountLimit || hasClaimCountLimit && remainingCount > 0), "no more tokens");

        if (tokenIdToKudosContainer[id].claimabilityAttributes.isSignatureRequired) {
            bytes32 domainSeparator = keccak256(
                abi.encode(
                    DOMAIN_TYPE_HASH,
                    keccak256(bytes(CONTRACT_NAME)),
                    keccak256(bytes(CONTRACT_VERSION)),
                    block.chainid,
                    address(this)
                )
            );
            bytes32 claimHash = keccak256(abi.encode(CLAIM_TYPE_HASH, id));
            bytes32 digest = keccak256(
                abi.encodePacked("\x19\x01", domainSeparator, claimHash)
            );
            address signatory = ecrecover(digest, v, r, s);
            require(signatory == claimee, "invalid signature");
        }
    }

    function modifyKudosClaimAttributes(
        uint256 id,
        int256 totalClaimCount, // -1 indicates infinite
        uint256 expirationTimestamp, // 0 indicates no expiration
        bool isSignatureRequired,
        bool isAllowlistRequired
    ) public onlyOwner whenNotPaused {
        require(tokenIdToKudosContainer[id].creator != address(0), "token does not exist");

        int256 diff;
        if (tokenIdToKudosContainer[id].claimabilityAttributes.totalClaimCount == -1) {
            // when it was infinite claim before, we impose a fresh new limit
            diff = totalClaimCount;
        } else {
            // otherwise we decrease the remaining claim count
            diff = totalClaimCount - tokenIdToKudosContainer[id].claimabilityAttributes.totalClaimCount;
        }
        if (diff < 0 && int256(tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount) < -diff) {
            tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount = 0;
        } else {
            tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount = uint256(int256(tokenIdToKudosContainer[id].claimabilityAttributes.remainingClaimCount) + diff);
        }

        tokenIdToKudosContainer[id].claimabilityAttributes.totalClaimCount = totalClaimCount;
        tokenIdToKudosContainer[id].claimabilityAttributes.expirationTimestamp = expirationTimestamp;
        tokenIdToKudosContainer[id].claimabilityAttributes.isSignatureRequired = isSignatureRequired;
        tokenIdToKudosContainer[id].claimabilityAttributes.isAllowlistRequired = isAllowlistRequired;
    }

    /// @notice Adds allowlisted addresses to an existing Kudos token. Note that this function is actually
    ///         unsafe in that there is no signature verification. We must trust the owner of the contract
    ///         to correctly verify off-chain that the operation is valid. This is added as a way for the team
    ///         to enable API integrations where partners want to add contributors to an existing Kudos token
    ///         programmatically.
    /// @param id                            ID of the Token
    /// @param allowlistedContributorRoots   Merkle roots of allowlisted contributors
    /// @param v                             Part of the creator's signature (v)
    /// @param r                             Part of the creator's signature (r)
    /// @param s                             Part of the creator's signature (s)
    function addAllowlistedAddressesBySig(
        uint256 id,
        KudosContributorsInputContainer memory allowlistedContributorRoots,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public onlyOwner whenNotPaused {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPE_HASH,
                keccak256(bytes(CONTRACT_NAME)),
                keccak256(bytes(CONTRACT_VERSION)),
                block.chainid,
                address(this)
            )
        );
        // Note: not verifying the content of allowlisted addresses for now
        bytes32 addAllowlistedAddressesHash = keccak256(
            abi.encode(
                ADD_ALLOWLISTED_ADDRESSES_TYPE_HASH,
                id
            )
        );
        bytes32 digest = keccak256(
            abi.encodePacked("\x19\x01", domainSeparator, addAllowlistedAddressesHash)
        );
        address signatory = ecrecover(digest, v, r, s);

        // Check if token created by this creator
        require(tokenIdToKudosContainer[id].creator == signatory, "only creator can add allowlisted addresses");

        _addAllowlistedContributorRoots(id, allowlistedContributorRoots);
    }

    /// @notice Adds allowlisted addresses to an existing Kudos token. Note that this function is actually
    ///         unsafe in that there is no signature verification. We must trust the owner of the contract
    ///         to correctly verify off-chain that the operation is valid. This is added as a way for the team
    ///         to enable API integrations where partners want to add contributors to an existing Kudos token
    ///         programmatically.
    ///
    ///         In the future, we expect to push partners to use the addAllowlistedAddressesBySig function so at least
    ///         we can validate to a degree that the operation is at least user-signed.
    /// @param id                            ID of the Token
    /// @param allowlistedContributorRoots   Merkle roots of allowlisted contributors
    function unsafeAddAllowlistedContributors(
        uint256 id,
        KudosContributorsInputContainer memory allowlistedContributorRoots
    ) public onlyOwner whenNotPaused {
        require(tokenIdToKudosContainer[id].creator != address(0), "token should already exist");

        _addAllowlistedContributorRoots(id, allowlistedContributorRoots);
    }

    function _addAllowlistedContributorRoots(uint256 id, KudosContributorsInputContainer memory newAllowlistedContributorRoots) internal {
        tokenIdToContributors[id].addressContributorsMerkleRoot = newAllowlistedContributorRoots.addressContributorsMerkleRoot;
        tokenIdToContributors[id].stringContributorsMerkleRoot = newAllowlistedContributorRoots.stringContributorsMerkleRoot;
    }

    /// @notice We add a temporary backdoor function to update the contents of the toeknIdToContributors map.
    ///         Previously, we were storing the raw contributor list, but because this is extremely inefficient,
    ///         we only want to store the merkle roots instead. This backdoor function allows us to update the
    ///         existing Kudos tokens' contributor data.
    /// @param id                            ID of the Token
    /// @param allowlistedContributorRoots   Merkle roots of allowlisted contributors
    function backdoorUpdateContributors(
        uint256 id,
        KudosContributorsInputContainer memory allowlistedContributorRoots
    ) public onlyOwner whenPaused {
        require(tokenIdToKudosContainer[id].creator != address(0), "token should already exist");

        // clear allowlist to free up space
        delete tokenIdToContributors[id];
        
        tokenIdToContributors[id].addressContributorsMerkleRoot = allowlistedContributorRoots.addressContributorsMerkleRoot;
        tokenIdToContributors[id].stringContributorsMerkleRoot = allowlistedContributorRoots.stringContributorsMerkleRoot;
    }

    /// @notice Returns the allowlisted contributors as an array.
    /// @dev The solidity compiler automatically returns the getter for mappings with arrays
    ///      as map(key, idx), which prevents us from getting the entire array back for a given key.
    /// @param tokenId     ID of the token
    function getAllowlistedContributors(uint256 tokenId)
        public
        view
        returns (KudosContributorsContainer memory)
    {
        return tokenIdToContributors[tokenId];
    }

    /// @notice Returns the Kudos metadata for a given token ID
    /// @dev Getters generated by the compiler for a public storage variable
    ///      silently skips mappings and arrays inside structs.
    //       This is why we need our own getter function to return the entirety of the struct.
    ///      https://ethereum.stackexchange.com/questions/107027/how-to-return-an-array-of-structs-that-has-mappings-nested-within-them/107124
    /// @param tokenId     ID of the token
    function getKudosMetadata(uint256 tokenId)
        public
        view
        returns (KudosContainer memory)
    {
        return tokenIdToKudosContainer[tokenId];
    }

    /// @notice Owner can pause the contract
    function pause() public onlyOwner {
        _pause();
    }

    /// @notice Owner can unpause the contract
    function unpause() public onlyOwner {
        _unpause();
    }

    /// @dev A way to convert an array of strings into a hashed byte32 value.
    ///      We append using encodePacked, which is the equivalent of hexlifying each
    ///      hashed string and concatenating them.
    function convertStringArraytoByte32(string[] memory inputArray)
        internal
        pure
        returns (bytes32)
    {
        bytes memory packedBytes;
        for (uint256 i = 0; i < inputArray.length; i++) {
            packedBytes = abi.encodePacked(
                packedBytes,
                keccak256(bytes(inputArray[i]))
            );
        }
        return keccak256(packedBytes);
    }

    function compareStringsbyBytes(string memory s1, string memory s2) private pure returns(bool){
        return keccak256(abi.encodePacked(s1)) == keccak256(abi.encodePacked(s2));
    }

    function generateAddressMerkleLeaf(address account) internal pure returns(bytes32) {
        return keccak256(abi.encodePacked(account));
    }

    function generateStringMerkleLeaf(string memory account) internal pure returns(bytes32) {
        return keccak256(abi.encodePacked(account));
    }
}

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

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Context_init_unchained();
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
    uint256[49] private __gap;
}

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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProofUpgradeable {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash;
    }
}

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

pragma solidity ^0.8.0;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";

contract ERC1155NonTransferableUpgradeable is
    ERC1155Upgradeable,
    ERC1155SupplyUpgradeable
{
    /// @dev Override of the token transfer hook that blocks all transfers BUT the mint.
    ///        This is a precursor to non-transferable tokens.
    ///        We may adopt something like ERC1238 in the future.
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal override(ERC1155Upgradeable, ERC1155SupplyUpgradeable) {
        require(
            (from == address(0) && to != address(0)),
            "Only mint transfers are allowed"
        );
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

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

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (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 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);
            }
        }
    }
}

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

pragma solidity ^0.8.0;

import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
    using AddressUpgradeable for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

    // Mapping from account to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    function __ERC1155_init(string memory uri_) internal onlyInitializing {
        __Context_init_unchained();
        __ERC165_init_unchained();
        __ERC1155_init_unchained(uri_);
    }

    function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
        _setURI(uri_);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
        return
            interfaceId == type(IERC1155Upgradeable).interfaceId ||
            interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    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");

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

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC1155-isApprovedForAll}.
     */
    function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[account][operator];
    }

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

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

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

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

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);
    }

    /**
     * @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, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
    uint256[47] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.0;

import "../ERC1155Upgradeable.sol";
import "../../../proxy/utils/Initializable.sol";

/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155SupplyUpgradeable is Initializable, ERC1155Upgradeable {
    function __ERC1155Supply_init() internal onlyInitializing {
        __Context_init_unchained();
        __ERC165_init_unchained();
        __ERC1155Supply_init_unchained();
    }

    function __ERC1155Supply_init_unchained() internal onlyInitializing {
    }
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155SupplyUpgradeable.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_beforeTokenTransfer}.
     */
    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 == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] -= amounts[i];
            }
        }
    }
    uint256[49] private __gap;
}

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

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155Upgradeable is IERC165Upgradeable {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

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

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

import "../IERC1155Upgradeable.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

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

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal onlyInitializing {
        __ERC165_init_unchained();
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }
    uint256[50] private __gap;
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165Upgradeable {
    /**
     * @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);
}

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

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"creator","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"RegisteredKudos","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":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ADD_ALLOWLISTED_ADDRESSES_TYPE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CLAIM_TYPE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CONTRACT_NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CONTRACT_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"DEPRECATED_tokenIdToContributors","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"KUDOS_TYPE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"components":[{"internalType":"bytes32","name":"stringContributorsMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"addressContributorsMerkleRoot","type":"bytes32"}],"internalType":"struct KudosV7.KudosContributorsInputContainer","name":"allowlistedContributorRoots","type":"tuple"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"addAllowlistedAddressesBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"components":[{"internalType":"bytes32","name":"stringContributorsMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"addressContributorsMerkleRoot","type":"bytes32"}],"internalType":"struct KudosV7.KudosContributorsInputContainer","name":"allowlistedContributorRoots","type":"tuple"}],"name":"backdoorUpdateContributors","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"claimingAddress","type":"address"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"communityRegistryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getAllowlistedContributors","outputs":[{"components":[{"internalType":"string[]","name":"DEPRECATED_stringContributors","type":"string[]"},{"internalType":"address[]","name":"DEPRECATED_addressContributors","type":"address[]"},{"internalType":"bytes32","name":"stringContributorsMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"addressContributorsMerkleRoot","type":"bytes32"}],"internalType":"struct KudosV7.KudosContributorsContainer","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getKudosMetadata","outputs":[{"components":[{"internalType":"string","name":"headline","type":"string"},{"internalType":"string","name":"description","type":"string"},{"internalType":"uint256","name":"startDateTimestamp","type":"uint256"},{"internalType":"uint256","name":"endDateTimestamp","type":"uint256"},{"internalType":"string[]","name":"links","type":"string[]"},{"internalType":"string","name":"DEPRECATED_communityDiscordId","type":"string"},{"internalType":"string","name":"DEPRECATED_communityName","type":"string"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"uint256","name":"registeredTimestamp","type":"uint256"},{"internalType":"string","name":"communityUniqId","type":"string"},{"components":[{"internalType":"bool","name":"isSignatureRequired","type":"bool"},{"internalType":"bool","name":"isAllowlistRequired","type":"bool"},{"internalType":"int256","name":"totalClaimCount","type":"int256"},{"internalType":"uint256","name":"remainingClaimCount","type":"uint256"},{"internalType":"uint256","name":"expirationTimestamp","type":"uint256"}],"internalType":"struct KudosV7.KudosClaimabilityAttributesContainer","name":"claimabilityAttributes","type":"tuple"}],"internalType":"struct KudosV7.KudosContainer","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_latestUnusedTokenId","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","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":[],"name":"latestUnusedTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"int256","name":"totalClaimCount","type":"int256"},{"internalType":"uint256","name":"expirationTimestamp","type":"uint256"},{"internalType":"bool","name":"isSignatureRequired","type":"bool"},{"internalType":"bool","name":"isAllowlistRequired","type":"bool"}],"name":"modifyKudosClaimAttributes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"creator","type":"address"},{"components":[{"internalType":"string","name":"headline","type":"string"},{"internalType":"string","name":"description","type":"string"},{"internalType":"uint256","name":"startDateTimestamp","type":"uint256"},{"internalType":"uint256","name":"endDateTimestamp","type":"uint256"},{"internalType":"string[]","name":"links","type":"string[]"},{"internalType":"string","name":"communityUniqId","type":"string"},{"components":[{"internalType":"bytes32","name":"stringContributorsMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"addressContributorsMerkleRoot","type":"bytes32"}],"internalType":"struct KudosV7.KudosContributorsInputContainer","name":"contributorMerkleRoots","type":"tuple"},{"components":[{"internalType":"bool","name":"isSignatureRequired","type":"bool"},{"internalType":"bool","name":"isAllowlistRequired","type":"bool"},{"internalType":"int256","name":"totalClaimCount","type":"int256"},{"internalType":"uint256","name":"expirationTimestamp","type":"uint256"}],"internalType":"struct KudosV7.KudosClaimabilityAttributesInputContainer","name":"claimabilityAttributes","type":"tuple"}],"internalType":"struct KudosV7.KudosInputContainer","name":"metadata","type":"tuple"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"registerBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_communityRegistryAddress","type":"address"}],"name":"setCommunityRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_latestUnusedTokenId","type":"uint256"}],"name":"setLatestUnusedTokenId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","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":"uint256","name":"","type":"uint256"}],"name":"tokenIdToKudosContainer","outputs":[{"internalType":"string","name":"headline","type":"string"},{"internalType":"string","name":"description","type":"string"},{"internalType":"uint256","name":"startDateTimestamp","type":"uint256"},{"internalType":"uint256","name":"endDateTimestamp","type":"uint256"},{"internalType":"string","name":"DEPRECATED_communityDiscordId","type":"string"},{"internalType":"string","name":"DEPRECATED_communityName","type":"string"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"uint256","name":"registeredTimestamp","type":"uint256"},{"internalType":"string","name":"communityUniqId","type":"string"},{"components":[{"internalType":"bool","name":"isSignatureRequired","type":"bool"},{"internalType":"bool","name":"isAllowlistRequired","type":"bool"},{"internalType":"int256","name":"totalClaimCount","type":"int256"},{"internalType":"uint256","name":"remainingClaimCount","type":"uint256"},{"internalType":"uint256","name":"expirationTimestamp","type":"uint256"}],"internalType":"struct KudosV7.KudosClaimabilityAttributesContainer","name":"claimabilityAttributes","type":"tuple"}],"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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"components":[{"internalType":"bytes32","name":"stringContributorsMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"addressContributorsMerkleRoot","type":"bytes32"}],"internalType":"struct KudosV7.KudosContributorsInputContainer","name":"allowlistedContributorRoots","type":"tuple"}],"name":"unsafeAddAllowlistedContributors","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"claimingAddress","type":"address"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"string","name":"contributor","type":"string"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"unsafeClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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