Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

import "../Traits/interfaces/IECRegistry.sol";

import "../@galaxis/registries/contracts/ICommunityList.sol";
import "../@galaxis/registries/contracts/CommunityRegistry.sol";
import "../@galaxis/registries/contracts/UsesGalaxisRegistry.sol";

import "../GLP/GLP.sol";
import "../GLP/GLXToGLPConverter.sol";

import "../ActionHub/IActionHub.sol";
import "../Traits/Implementers/Generic/IGenericTrait.sol";
import "../TraitConsumers/IGenericTraitConsumer.sol";
import "../TokenDepositor/TokenDepositor.sol";

import "hardhat/console.sol";


interface IPaymentMatrix {
    function getArtistIDAndAmountForCollection(uint32 _communityId, uint32 _collectionId) external view returns(uint256 artistId, uint256 amount);
}


contract ActionHub is IActionHub, IERC1155Receiver, UsesGalaxisRegistry {
    using Strings for uint256;

    function version() public pure returns (uint256) {
        return 2024060701; 
    }

    IERC20          public GLXContractInstance;
    GLP             public GLPContractInstance;
    address         public GLX_TO_GLP_CONVERTER;
    IPaymentMatrix  public PaymentMatrixContractInstance;
    TokenDepositor  public TokenDepositorContractInstance;
    uint256         public TokenMembershipTier1;

    error RegistryNotLoaded();
    error CommunityListNotLoaded(address);
    error TraitRegistryNotLoaded(uint32,string,address);
    error CommunityRegistryNotLoaded(address);

    constructor(address _galaxisRegistry) UsesGalaxisRegistry(_galaxisRegistry){
        refreshRegistries();
    }

    function refreshRegistries() public {
        GLXContractInstance             = IERC20(galaxisRegistry.getRegistryAddress("GALAXIS_TOKEN"));
        TokenDepositorContractInstance  = TokenDepositor(galaxisRegistry.getRegistryAddress("GALAXIS_DEPOSIT"));
        TokenMembershipTier1           =  galaxisRegistry.getRegistryUINT("MEMBERSHIP_TIER_1");

        GLPContractInstance             = GLP(galaxisRegistry.getRegistryAddress("GLP"));
        GLX_TO_GLP_CONVERTER            = galaxisRegistry.getRegistryAddress("GLX_TO_GLP_CONVERTER");
        PaymentMatrixContractInstance   = IPaymentMatrix(galaxisRegistry.getRegistryAddress("PAYMENT_MATRIX"));

        require(address(GLXContractInstance) != address(0), "ActionHub: Key GALAXIS_TOKEN needs to be != address(0)");
        require(address(TokenDepositorContractInstance) != address(0), "ActionHub: Key GALAXIS_DEPOSIT needs to be != address(0)");
        require(TokenMembershipTier1 > 0, "ActionHub: Key MEMBERSHIP_TIER_1 needs to be higher than 1");

        // require(address(GLPContractInstance) != address(0), "ActionHub: Key GLP needs to be != address(0)");
    }

    function takeMyGLX(uint256 amount, bytes calldata userData) external {
        if(userData.length == 0) {
            revert("ActionHub: userData is required.");
        }

        // userData needs to specify which 721 Id we're depositing for.
        (
            uint32 communityId,
            uint32 collectionId,
            uint32 tokenId
        ) = abi.decode(userData, (uint32,uint32,uint32));

        // validate userData
        require(communityId > 0,     "ActionHub: userData communityId must be higher than 0");
        require(collectionId > 0,    "ActionHub: userData collectionId must be higher than 0");
        require(tokenId > 0,         "ActionHub: userData tokenId must be higher than 0");

        uint256 GLPAmount = GLXToGLPConverter(GLX_TO_GLP_CONVERTER).getGLXToGLPConvertedAmount(amount);
        // allocate GLP to a token id
        GLPContractInstance.addToCLevelBalance(GLP.CommunityLevelBalanceType.TOKEN, communityId, collectionId, tokenId, GLPAmount);

        // whole thing should just fail if we don't have enough balance anyway.. no need to check allowance or balances..
        address GLXVault = galaxisRegistry.getRegistryAddress("GLX_VAULT");
        GLXContractInstance.transferFrom(msg.sender, GLXVault, amount);
    }

    function getExpandedTokenContracts(
        uint32 _communityId,
        uint32 _collectionId,
        uint16 _traitId
    ) internal view returns (ExpandedTokenContracts memory) {
        ICommunityList COMMUNITY_LIST = ICommunityList(galaxisRegistry.getRegistryAddress("COMMUNITY_LIST"));
        (,address _communityRegistryContract,) = COMMUNITY_LIST.communities(_communityId);
        if (_communityRegistryContract.code.length == 0) {
            revert CommunityRegistryNotLoaded(_communityRegistryContract);
        }

        string memory TOKEN_NUMBER_KEY = string.concat("TOKEN_",uint256(_collectionId).toString());
        string memory TRAIT_REGISTRY_KEY = string.concat("TRAIT_REGISTRY_",uint256(_collectionId).toString());

        CommunityRegistry _tokenCommunityRegistry  = CommunityRegistry(_communityRegistryContract);
        address _tokenContract = _tokenCommunityRegistry.getRegistryAddress(TOKEN_NUMBER_KEY);
        address _traitRegistryContract = _tokenCommunityRegistry.getRegistryAddress(TRAIT_REGISTRY_KEY);

        IECRegistry TR = IECRegistry(_traitRegistryContract);
        address _traitImplementerContract = TR.getImplementer(_traitId);

        // implementer of first trait so we can check owner
        address _traitImplementerContractFirstTrait = TR.getImplementer(0);

        // get membership token contract
        address _membershipTokenContract;
        if(_tokenCommunityRegistry.getRegistryBool("IS_HOME_CHAIN")) {
            _membershipTokenContract = _tokenCommunityRegistry.getRegistryAddress("TOKEN_1");
        } else {
            _membershipTokenContract = _tokenCommunityRegistry.getRegistryAddress("CHILD_TOKEN_1");
        }

        return ExpandedTokenContracts(
            _communityRegistryContract,
            _tokenContract,
            _traitRegistryContract,
            _traitImplementerContract,
            _traitImplementerContractFirstTrait,
            _membershipTokenContract,
            address(TokenDepositorContractInstance)
        ); 
    }

    function payTraitUsageCost(IGenericTrait _Trait, UserAction memory _msg) internal {

        bytes32[] memory propNames = new bytes32[](3);
        propNames[0] = "royalty_id";
        propNames[1] = "royalty_amount";
        propNames[2] = "status";

        bytes[] memory props = _Trait.getProperties(_msg.tokenId, propNames);

        uint256 royalty_id      = uint256(bytes32(props[0]));
        uint256 royalty_amount  = uint256(bytes32(props[1]));
        uint8 status            = abi.decode(props[2], (uint8));

        // TraitStatus.ACTIVE
        require(status == 1, "ActionHub: Trait status != TraitStatus.ACTIVE");

        uint256 tokenGLPBalance = GLPContractInstance.getTokenBalancesFor(
            _msg.communityId,
            _msg.collectionId,
            _msg.tokenId
        );

        require(tokenGLPBalance >= royalty_amount, "ActionHub: GLP balance lower than trait usage cost");

        // subtract usage cost from token's balance
        GLPContractInstance.subFromCLevelBalance(GLP.CommunityLevelBalanceType.TOKEN, _msg.communityId, _msg.collectionId, _msg.tokenId, royalty_amount); 

        // do payment splitting
        uint256 amountRemaining = _processPaymentInternals(royalty_amount, _msg.communityId);

        // send remaining payment to Dev
        GLPContractInstance.addToGTypeBalance(GLP.GlobalBalanceType.DEV_ID, royalty_id, amountRemaining);
    }

    function _processPaymentInternals(uint256 royalty_amount, uint256 _communityId) internal returns(uint256) {
        // TODO: maybe use fractions so we don't loose too much precision?
        uint256 amountRemaining = royalty_amount;

        // we burn 10%
        uint256 GLP_BURN_PERCENTAGE = galaxisRegistry.getRegistryUINT("GLP_BURN_PERCENTAGE");   // in millis
        // sub burned amount
        amountRemaining -= (royalty_amount / 1000) * GLP_BURN_PERCENTAGE;

        // GLAXIS gets 10%
        // uint256 GLP_GALAXIS_TAKE_PERCENTAGE = galaxisRegistry.getRegistryUINT("GLP_GALAXIS_TAKE_PERCENTAGE");
        // if(GLP_GALAXIS_TAKE_PERCENTAGE > 0) {
        //     uint256 galaxisTenPercent = (royalty_amount / 100) * GLP_GALAXIS_TAKE_PERCENTAGE;
        //     amountRemaining -= galaxisTenPercent;
        //     GLPContractInstance.addToTypeBalance(GLP.BalanceType.DEV_ID, 1, galaxisTenPercent);
        // }

        // first look at per community setting
        uint256 GLP_COMMUNITY_TAKE_PERCENTAGE = galaxisRegistry.getRegistryUINT(
            string.concat("GLP_COMMUNITY_TAKE_PERCENTAGE_",uint256(_communityId).toString())
        );
        if(GLP_COMMUNITY_TAKE_PERCENTAGE == 0) {
            // default fallback
            GLP_COMMUNITY_TAKE_PERCENTAGE = galaxisRegistry.getRegistryUINT("GLP_COMMUNITY_TAKE_PERCENTAGE");
        }
        uint256 CommunityBalance = (royalty_amount / 1000) * GLP_COMMUNITY_TAKE_PERCENTAGE; // in millis

        uint256 GLP_COMMUNITY_DISCOUNT_POOL_P = galaxisRegistry.getRegistryUINT(
            string.concat("GLP_COMMUNITY_DISCOUNT_POOL_P")
        );
        uint256 CommunityDiscountAmount = (CommunityBalance / 1000) * GLP_COMMUNITY_DISCOUNT_POOL_P; // in millis 

        // sub community cut
        amountRemaining -= CommunityBalance;

        // add to the community discount pool balance
        GLPContractInstance.addToGTypeBalance(GLP.GlobalBalanceType.COMMUNITY_ID_DISCOUNT_POOL, _communityId, CommunityDiscountAmount);

        // add to the community balance
        GLPContractInstance.addToGTypeBalance(GLP.GlobalBalanceType.COMMUNITY_ID, _communityId, (CommunityBalance - CommunityDiscountAmount) );

        return amountRemaining;
    }


    function royaltiesPaid(
        uint32 _communityId,
        uint32 _collectionId,
        uint32 _tokenId
    ) external view returns (bool) {
        ExpandedTokenContracts memory etc = getExpandedTokenContracts(
            _communityId,
            _collectionId,
            0   // first trait
        );
        return _royaltiesPaid(etc._traitImplementerContractFirstTrait, _tokenId);
    }

    function _royaltiesPaid(
        address _traitImplementerContract,
        uint32 _tokenId
    ) internal view returns (bool) {

        require(_traitImplementerContract != address(0), "ActionHub: trait implementer cannot be address(0)");
        IGenericTrait Trait = IGenericTrait(_traitImplementerContract);

        bytes32[] memory propNames = new bytes32[](4);
        propNames[0] = "movement_permission";
        propNames[1] = "owner_stored";
        propNames[2] = "owner_current";
        propNames[3] = "status";

        bytes[] memory props = Trait.getProperties(_tokenId, propNames);
        uint8   movement_permission = abi.decode(props[0], (uint8));
        address owner_stored        = abi.decode(props[1], (address));
        address owner_current       = abi.decode(props[2], (address));
        uint8   status              = abi.decode(props[3], (uint8));

        //  MovementPermission.LOCKED
        require(movement_permission == 2, "ActionHub: first trait implementer has to have MovementPermission.LOCKED!");

        // TraitStatus.ACTIVE
        require(status == 1, "ActionHub: Trait status != TraitStatus.ACTIVE");

        if(owner_stored == address(0)) {
            return true;
        }

        if(owner_stored == owner_current) {
            return true;
        }

        return false;

    }

    function payRoyalties(
        uint32 _communityId,
        uint32 _collectionId,
        uint32 _tokenId,
        address _traitImplementerContract
    ) internal {

        // get how much we need to pay
        (uint256 royalty_id, uint256 royalty_amount) = PaymentMatrixContractInstance.getArtistIDAndAmountForCollection(_communityId, _collectionId);

        IGenericTrait _Trait = IGenericTrait(_traitImplementerContract);
        uint8 status            = abi.decode( _Trait.getProperty("status", _tokenId), (uint8));

        // TraitStatus.ACTIVE
        require(status == 1, "ActionHub: Trait status != TraitStatus.ACTIVE");

        if(royalty_amount > 0) {

            uint256 tokenGLPBalance = GLPContractInstance.getTokenBalancesFor(
                _communityId,
                _collectionId,
                _tokenId
            );

            require(tokenGLPBalance >= royalty_amount, "ActionHub: GLP balance lower than trait usage cost");

            // subtract usage cost from token's balance
            GLPContractInstance.subFromCLevelBalance(GLP.CommunityLevelBalanceType.TOKEN, _communityId, _collectionId, _tokenId, royalty_amount); 

            // do payment splitting
            uint256 amountRemaining = _processPaymentInternals(royalty_amount, _communityId);

            // send remaining payment to Dev
            GLPContractInstance.addToGTypeBalance(GLP.GlobalBalanceType.ARTIST_ID, royalty_id, amountRemaining);
        }

        // we increment the counter each time royalties are paid, this also updates current owner of the token
        _Trait.incrementCounter(_tokenId);
    }

    function doAction(UserAction[] memory messages) public {

        require(galaxisRegistry.getRegistryAddress("ACTION_HUB") == address(this), "ActionHub: Not current Action Hub.");

        require(messages.length > 0, "ActionHub: messages.length at least 1");
        for(uint8 i = 0; i < messages.length; i++) {
            UserAction memory _msg = messages[i];

            ExpandedTokenContracts memory etc = getExpandedTokenContracts(
                _msg.communityId,
                _msg.collectionId,
                _msg.traitId
            );

            // royalties DISABLED in favour of membershipCardBalance
            // if(!_royaltiesPaid(etc._traitImplementerContractFirstTrait, _msg.tokenId)) {
            //     // try to pay them
            //     payRoyalties(
            //         _msg.communityId,
            //         _msg.collectionId,
            //         _msg.tokenId,
            //         etc._traitImplementerContractFirstTrait
            //     );
            // }

            require(IERC721(etc._membershipTokenContract).ownerOf(_msg.membershipCardId) == msg.sender, "ActionHub: Membership Card not owned by msg.sender");
            uint256 membershipCardBalance = TokenDepositorContractInstance.balances(etc._membershipTokenContract, _msg.membershipCardId);
            require(membershipCardBalance >= TokenMembershipTier1, "ActionHub: Membership Card balance too low");

            // load this tokens' and traits' contract addresses
            require(IERC721(etc._tokenContract).ownerOf(_msg.tokenId) == msg.sender, "ActionHub: Token not owned by msg.sender");
            require(etc._traitImplementerContract != address(0), "ActionHub: trait implementer cannot be address(0)");
            IGenericTrait Trait = IGenericTrait(etc._traitImplementerContract);

            require(Trait.hasTrait(_msg.tokenId), "ActionHub: Token does not have specified trait");

            // if(_msg._type == ActionType.USE_TRAIT ) {
            //     payTraitUsageCost(Trait, _msg);
            // }

            IGenericTraitConsumer(_msg.consumer).doAction(msg.sender, etc, _msg);
        }
    }


    function handle1155Received(
        address from,
        uint256 received1155TokenId,
        uint256 messageIndex,
        bytes calldata userData
    ) internal {
        
        // do trait extraction ( in dave's branch )
    }

    /**
     * @dev Receive any ERC1155 using safeTransfer
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata userData
    ) external returns (bytes4) {
        if(userData.length == 0) {
            // just store tokens.. do nothing
        } else {
            require(operator == address(0), "ActionHub: no operator allowed");
            require(value == 1, "ActionHub: Can only transfer one per tokenId!");
            // should we only accept ERC1155 TeleportToken ( communityTeleportAddress ) for this community ??
            handle1155Received(from, id, 0, userData);
        }
        return this.onERC1155Received.selector;
    }

    /**
     * @dev Receive any ERC1155 Batch using safeTransfer
     */
    function onERC1155BatchReceived(
        address operator, 
        address from, 
        uint256[] calldata ids, 
        uint256[] calldata values, 
        bytes calldata userData
    ) external returns (bytes4) {
        if(userData.length == 0) {
            // just store tokens.. do nothing
        } else {
            require(operator == address(0), "ActionHub: no operator allowed");
            for (uint256 idpos = 0; idpos < ids.length; idpos++) {
                uint256 value = values[idpos];
                require(value == 1, "ActionHub: Can only transfer one per tokenId!");
                handle1155Received(from, ids[idpos], idpos, userData);
            }
        }
        return this.onERC1155BatchReceived.selector;
    }

    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
        return (
            interfaceId == type(IERC1155Receiver).interfaceId ||
            interfaceId == type(IERC721Receiver).interfaceId ||
            interfaceId == type(IERC165).interfaceId
        );
    }

}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;

import "./IAccessControlEnumerable.sol";
import "./AccessControl.sol";
import "../utils/structs/EnumerableSet.sol";

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

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

pragma solidity ^0.8.0;

import "./IAccessControl.sol";

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

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

pragma solidity ^0.8.0;

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

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @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.
     *
     * NOTE: 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.
     *
     * NOTE: 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 (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

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

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC777/IERC777.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC777Token standard as defined in the EIP.
 *
 * This contract uses the
 * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 registry standard] to let
 * token holders and recipients react to token movements by using setting implementers
 * for the associated interfaces in said registry. See {IERC1820Registry} and
 * {ERC1820Implementer}.
 */
interface IERC777 {
    /**
     * @dev Emitted when `amount` tokens are created by `operator` and assigned to `to`.
     *
     * Note that some additional user `data` and `operatorData` can be logged in the event.
     */
    event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);

    /**
     * @dev Emitted when `operator` destroys `amount` tokens from `account`.
     *
     * Note that some additional user `data` and `operatorData` can be logged in the event.
     */
    event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);

    /**
     * @dev Emitted when `operator` is made operator for `tokenHolder`
     */
    event AuthorizedOperator(address indexed operator, address indexed tokenHolder);

    /**
     * @dev Emitted when `operator` is revoked its operator status for `tokenHolder`
     */
    event RevokedOperator(address indexed operator, address indexed tokenHolder);

    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the smallest part of the token that is not divisible. This
     * means all token operations (creation, movement and destruction) must have
     * amounts that are a multiple of this number.
     *
     * For most token contracts, this value will equal 1.
     */
    function granularity() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * If send or receive hooks are registered for the caller and `recipient`,
     * the corresponding functions will be called with `data` and empty
     * `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
     *
     * Emits a {Sent} event.
     *
     * Requirements
     *
     * - the caller must have at least `amount` tokens.
     * - `recipient` cannot be the zero address.
     * - if `recipient` is a contract, it must implement the {IERC777Recipient}
     * interface.
     */
    function send(
        address recipient,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev Destroys `amount` tokens from the caller's account, reducing the
     * total supply.
     *
     * If a send hook is registered for the caller, the corresponding function
     * will be called with `data` and empty `operatorData`. See {IERC777Sender}.
     *
     * Emits a {Burned} event.
     *
     * Requirements
     *
     * - the caller must have at least `amount` tokens.
     */
    function burn(uint256 amount, bytes calldata data) external;

    /**
     * @dev Returns true if an account is an operator of `tokenHolder`.
     * Operators can send and burn tokens on behalf of their owners. All
     * accounts are their own operator.
     *
     * See {operatorSend} and {operatorBurn}.
     */
    function isOperatorFor(address operator, address tokenHolder) external view returns (bool);

    /**
     * @dev Make an account an operator of the caller.
     *
     * See {isOperatorFor}.
     *
     * Emits an {AuthorizedOperator} event.
     *
     * Requirements
     *
     * - `operator` cannot be calling address.
     */
    function authorizeOperator(address operator) external;

    /**
     * @dev Revoke an account's operator status for the caller.
     *
     * See {isOperatorFor} and {defaultOperators}.
     *
     * Emits a {RevokedOperator} event.
     *
     * Requirements
     *
     * - `operator` cannot be calling address.
     */
    function revokeOperator(address operator) external;

    /**
     * @dev Returns the list of default operators. These accounts are operators
     * for all token holders, even if {authorizeOperator} was never called on
     * them.
     *
     * This list is immutable, but individual holders may revoke these via
     * {revokeOperator}, in which case {isOperatorFor} will return false.
     */
    function defaultOperators() external view returns (address[] memory);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient`. The caller must
     * be an operator of `sender`.
     *
     * If send or receive hooks are registered for `sender` and `recipient`,
     * the corresponding functions will be called with `data` and
     * `operatorData`. See {IERC777Sender} and {IERC777Recipient}.
     *
     * Emits a {Sent} event.
     *
     * Requirements
     *
     * - `sender` cannot be the zero address.
     * - `sender` must have at least `amount` tokens.
     * - the caller must be an operator for `sender`.
     * - `recipient` cannot be the zero address.
     * - if `recipient` is a contract, it must implement the {IERC777Recipient}
     * interface.
     */
    function operatorSend(
        address sender,
        address recipient,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the total supply.
     * The caller must be an operator of `account`.
     *
     * If a send hook is registered for `account`, the corresponding function
     * will be called with `data` and `operatorData`. See {IERC777Sender}.
     *
     * Emits a {Burned} event.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     * - the caller must be an operator for `account`.
     */
    function operatorBurn(
        address account,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    event Sent(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
 *
 * Accounts can be notified of {IERC777} tokens being sent to them by having a
 * contract implement this interface (contract holders can be their own
 * implementer) and registering it on the
 * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
 *
 * See {IERC1820Registry} and {ERC1820Implementer}.
 */
interface IERC777Recipient {
    /**
     * @dev Called by an {IERC777} token contract whenever tokens are being
     * moved or created into a registered account (`to`). The type of operation
     * is conveyed by `from` being the zero address or not.
     *
     * This call occurs _after_ the token contract's state is updated, so
     * {IERC777-balanceOf}, etc., can be used to query the post-operation state.
     *
     * This function may revert to prevent the operation from being executed.
     */
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external;
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-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 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.3) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.1) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../Address.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        if (error == ECDSA.RecoverError.NoError && recovered == signer) {
            return true;
        }

        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length == 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// 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 IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
 *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "./Versionable/IVersionable.sol";

contract CommunityList is AccessControlEnumerable, IVersionable { 

    function version() external pure returns (uint256) {
        return 2024040301;
    }

    bytes32 public constant CONTRACT_ADMIN = keccak256("CONTRACT_ADMIN");


    uint256                              public numberOfEntries;

    struct community_entry {
        string      name;
        address     registry;
        uint32      id;
    }
    
    mapping(uint32 => community_entry)  public communities;   // community_id => record
    mapping(uint256 => uint32)           public index;         // entryNumber => community_id for enumeration

    event CommunityAdded(uint256 pos, string community_name, address community_registry, uint32 community_id);

    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(CONTRACT_ADMIN,msg.sender);
    }

    function addCommunity(uint32 community_id, string memory community_name, address community_registry) external onlyRole(CONTRACT_ADMIN) {
        uint256 pos = numberOfEntries++;
        index[pos]  = community_id;
        communities[community_id] = community_entry(community_name, community_registry, community_id);
        emit CommunityAdded(pos, community_name, community_registry, community_id);
    }

}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./Versionable/IVersionable.sol";
import "./UsesGalaxisRegistry.sol";

contract CommunityRegistry is AccessControlEnumerable, UsesGalaxisRegistry, IVersionable  {

    function version() virtual external pure returns(uint256) {
        return 2024040401;
    }

    bytes32 public constant COMMUNITY_REGISTRY_ADMIN = keccak256("COMMUNITY_REGISTRY_ADMIN");

    uint32                      public  community_id;
    string                      public  community_name;
    

    mapping(bytes32 => address)         addresses;
    mapping(bytes32 => uint256)         uints;
    mapping(bytes32 => bool)            booleans;
    mapping(bytes32 => string)          strings;

    mapping (uint => string)    public  addressEntries;
    mapping (uint => string)    public  uintEntries;
    mapping (uint => string)    public  boolEntries;
    mapping (uint => string)    public  stringEntries;
    uint                        public  numberOfAddresses;
    uint                        public  numberOfUINTs;
    uint                        public  numberOfBooleans;
    uint                        public  numberOfStrings;

    bool                                initialised;

    bool                        public  independant;

    event IndependanceDay(bool gain_independance);

    modifier onlyAdmin() {
        require(
            isUserCommunityAdmin(COMMUNITY_REGISTRY_ADMIN,msg.sender)
            ,"CommunityRegistry : Unauthorised");
        _;
    }

    modifier onlyPropertyAdmin() {
        require(
            isUserCommunityAdmin(COMMUNITY_REGISTRY_ADMIN,msg.sender) ||
            hasRole(COMMUNITY_REGISTRY_ADMIN,msg.sender)
            ,"CommunityRegistry : Unauthorised");
        _;
    }



    function isUserCommunityAdmin(bytes32 role, address user) public view returns (bool) {
        if (hasRole(DEFAULT_ADMIN_ROLE,user) ) return true; // community_admin can do anything
        if (independant){        
            return(
                hasRole(role,user)
            );
        } else { // for Factories
           return(roleManager().hasRole(role,user));
        }
    }

    function roleManager() internal view returns (IAccessControlEnumerable) {
        address addr = galaxisRegistry.getRegistryAddress("ROLE_MANAGER"); // universal
        if (addr != address(0)) return IAccessControlEnumerable(addr);
        addr = galaxisRegistry.getRegistryAddress("MAINNET_CHAIN_IMPLEMENTER"); // mainnet
        if (addr != address(0)) return IAccessControlEnumerable(addr);
        addr = galaxisRegistry.getRegistryAddress("L2_RECEIVER"); // mainnet
        require(addr != address(0),"CommunityRegistry : no higher authority found");
        return IAccessControlEnumerable(addr);
    }

    function grantRole(bytes32 key, address user) public override(AccessControl,IAccessControl) onlyAdmin {
        _grantRole(key,user); // need to be able to grant it
    }


 
    constructor (
        address _galaxisRegistry,
        uint32  _community_id, 
        address _community_admin, 
        string memory _community_name
    ) UsesGalaxisRegistry(_galaxisRegistry){
        _init(_community_id,_community_admin,_community_name);
    }

    
    function init(
        uint32  _community_id, 
        address _community_admin, 
        string memory _community_name
    ) external {
        _init(_community_id,_community_admin,_community_name);
    }

    function _init(
        uint32  _community_id, 
        address _community_admin, 
        string memory _community_name
    ) internal {
        require(!initialised,"This can only be called once");
        initialised = true;
        community_id = _community_id;
        community_name  = _community_name;
        _setupRole(DEFAULT_ADMIN_ROLE, _community_admin); // default admin = launchpad
    }



    event AdminUpdated(address user, bool isAdmin);
    event AppAdminChanged(address app,address user,bool state);
    //===
    event AddressChanged(string key, address value);
    event UintChanged(string key, uint256 value);
    event BooleanChanged(string key, bool value);
    event StringChanged(string key, string value);

    function setIndependant(bool gain_independance) external onlyAdmin {
        if (independant != gain_independance) {
                independant = gain_independance;
                emit IndependanceDay(gain_independance);
        }
    }


    function setAdmin(address user,bool status ) external onlyAdmin {
        if (status)
            _grantRole(COMMUNITY_REGISTRY_ADMIN,user);
        else
            _revokeRole(COMMUNITY_REGISTRY_ADMIN,user);
    }

    function hash(string memory field) internal pure returns (bytes32) {
        return keccak256(abi.encode(field));
    }

    function setRegistryAddress(string memory fn, address value) external onlyPropertyAdmin {
        bytes32 hf = hash(fn);
        addresses[hf] = value;
        addressEntries[numberOfAddresses++] = fn;
        emit AddressChanged(fn,value);
    }

    function setRegistryBool(string memory fn, bool value) external onlyPropertyAdmin {
        bytes32 hf = hash(fn);
        booleans[hf] = value;
        boolEntries[numberOfBooleans++] = fn;
        emit BooleanChanged(fn,value);
    }

    function setRegistryString(string memory fn, string memory value) external onlyPropertyAdmin {
        bytes32 hf = hash(fn);
        strings[hf] = value;
        stringEntries[numberOfStrings++] = fn;
        emit StringChanged(fn,value);
    }

    function setRegistryUINT(string memory fn, uint value) external onlyPropertyAdmin {
        bytes32 hf = hash(fn);
        uints[hf] = value;
        uintEntries[numberOfUINTs++] = fn;
        emit UintChanged(fn,value);
    }

    function getRegistryAddress(string memory key) external view returns (address) {
        return addresses[hash(key)];
    }

    function getRegistryBool(string memory key) external view returns (bool) {
        return booleans[hash(key)];
    }

    function getRegistryUINT(string memory key) external view returns (uint256) {
        return uints[hash(key)];
    }

    function getRegistryString(string memory key) external view returns (string memory) {
        return strings[hash(key)];
    }

}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

interface ICommunityList {
    // struct community_entry {
    //     string      name;
    //     address     registry;
    //     uint32      id;
    // }
    // mapping(uint32 => community_entry)  public communities;   // community_id => record

    // function communities(uint32) external returns (struct community_entry memory);
    function communities(uint32) external view returns (string memory, address, uint32);
    function addCommunity(uint32, string memory, address community_registry) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

interface IRegistry {
    function setRegistryAddress(string memory fn, address value) external ;
    function setRegistryBool(string memory fn, bool value) external ;
    function setRegistryUINT(string memory key) external returns (uint256) ;
    function setRegistryString(string memory fn, string memory value) external ;
    function setAdmin(address user,bool status ) external;
    function setAppAdmin(address app, address user, bool state) external;

    function getRegistryAddress(string memory key) external view returns (address) ;
    function getRegistryBool(string memory key) external view returns (bool);
    function getRegistryUINT(string memory key) external view returns (uint256) ;
    function getRegistryString(string memory key) external view returns (string memory) ;
    function isAdmin(address user) external view returns (bool) ;
    function isAppAdmin(address app, address user) external view returns (bool);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

import "./IRegistry.sol";

contract UsesGalaxisRegistry {

    IRegistry   immutable   public   galaxisRegistry;

    constructor(address _galaxisRegistry) {
        galaxisRegistry = IRegistry(_galaxisRegistry);
    }

}

//SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.25;

import "./IVersionable.sol";

/**
 * @title IGenericVersionable
 * @dev Interface for generic versionable contracts extending IVersionable.
 */
interface IGenericVersionable is IVersionable {
    /**
     * @notice Get the base version of the contract.
     * @return The base version.
     */
    function baseVersion() external pure returns (uint256);
}

//SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.25;

/**
 * @title IVersionable
 * @dev Interface for versionable contracts.
 */
interface IVersionable {
    /**
     * @notice Get the current version of the contract.
     * @return The current version.
     */
    function version() external pure returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;

interface IActionHub {

    struct ExpandedTokenContracts {
        address _communityRegistryContract;
        address _tokenContract;
        address _traitRegistryContract;
        address _traitImplementerContract;
        address _traitImplementerContractFirstTrait;
        address _membershipTokenContract;
        address _tokenDepositorContract;
    }

    enum ActionType {
        NONE,
        PAY_ROYALTIES,
        USE_TRAIT,
        FORWARD_TO
    }

    struct UserAction {
        ActionType _type;
        uint32 membershipCardId;
        uint32 communityId;
        uint32 collectionId;
        uint32 tokenId;
        uint16 traitId;
        address consumer;
        bytes userData;
    }

    function refreshRegistries() external;
    function doAction(UserAction[] memory messages) external;
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

import "../Traits/extras/recovery/BlackHolePrevention.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/*
    GLP Balance in the sky contract

    -- 18 decimals
*/
contract GLP is Ownable, BlackHolePrevention {
    
    enum GlobalBalanceType {
        NONE,
        DEV_ID,
        ARTIST_ID,
        EXIT_ID,
        COMMUNITY_ID,
        COMMUNITY_ID_DISCOUNT_POOL
    }

    enum CommunityLevelBalanceType {
        NONE,
        TOKEN,
        SPLITTER,
        VAULT
    }

    string      public name = "GLP";
    string      public symbol = "GLP";
    uint256     public decimals = 18;
    uint256     public totalSupply = 0;

    // balance type =>  uid => uint value
    mapping(GlobalBalanceType => mapping( uint256 => uint256) ) balance;

    //                   TYPE         =>     communityId =>         collectionId     => tokenId  => value
    //                   TYPE         =>     communityId =>         zero             => entityId => value
    mapping(CommunityLevelBalanceType => mapping(uint256 => mapping( uint256 => mapping( uint256 => uint256)))) communityLevelBalanceType;

    event TotalSupplyChangedTo(uint256 indexed _amount);
    event CommunityLevelBalanceChange(CommunityLevelBalanceType _type, uint256 _communityId, uint256 _entityA, uint256 _id, uint256 _newAmount);
    event GlobalTypeBalanceChange(GlobalBalanceType _type, uint256 _id, uint256 _newAmount);

    function UpdateTotal(bool add, uint256 _amount) internal {
        if(add) {
            totalSupply+=_amount;
        } else {
            totalSupply-=_amount;
        }
        emit TotalSupplyChangedTo(totalSupply);
    }

    function addToCLevelBalance(CommunityLevelBalanceType _type, uint256 communityId, uint256 entityA, uint256 _id, uint256 _amount) public onlyRole {
        communityLevelBalanceType[_type][communityId][entityA][_id]+=_amount;
        emit CommunityLevelBalanceChange(_type, communityId, entityA, _id, communityLevelBalanceType[_type][communityId][entityA][_id]);
        UpdateTotal(true, _amount);
    }

    function subFromCLevelBalance(CommunityLevelBalanceType _type, uint256 communityId, uint256 entityA, uint256 _id, uint256 _amount) public onlyRole {
        communityLevelBalanceType[_type][communityId][entityA][_id]-=_amount;
        emit CommunityLevelBalanceChange(_type, communityId, entityA, _id, communityLevelBalanceType[_type][communityId][entityA][_id]);
        UpdateTotal(false, _amount);
    }

    function addToGTypeBalance(GlobalBalanceType _type, uint256 _id, uint256 _amount) public onlyRole {
        balance[_type][_id]+=_amount;
        emit GlobalTypeBalanceChange(_type, _id, balance[_type][_id]);
        UpdateTotal(true, _amount);
    }

    function subFromGTypeBalance(GlobalBalanceType _type, uint256 _id, uint256 _amount) public onlyRole {
        balance[_type][_id]-=_amount;
        emit GlobalTypeBalanceChange(_type, _id, balance[_type][_id]);
        UpdateTotal(false, _amount);
    }

    // views

    function getTokenBalancesFor(uint256 communityId, uint256 collectionId, uint256 tokenId) public view returns ( uint256 result) {
        return communityLevelBalanceType[CommunityLevelBalanceType.TOKEN][communityId][collectionId][tokenId];
    }

    function getCLevelBalancesFor(
        CommunityLevelBalanceType[] memory _type,
        uint256[] memory communityId,
        uint256[] memory entityA,
        uint256[] memory ids
    ) public view returns ( uint256[] memory results) {
        results = new uint256[](ids.length);
        for(uint256 i = 0; i < ids.length; i++ ) {
            results[i] = 
            communityLevelBalanceType[_type[i]][communityId[i]][entityA[i]][ids[i]];
        }
    }

    function getGTypeBalancesFor(GlobalBalanceType[] memory _type, uint256[] memory ids) public view returns ( uint256[] memory results) {
        results = new uint256[](ids.length);
        for(uint256 i = 0; i < ids.length; i++ ) {
            results[i] = balance[ _type[i] ][ ids[i] ];
        }
    }

    modifier onlyRole() {
        // check role
        _;
    }
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

import "../Traits/extras/recovery/BlackHolePrevention.sol";
import "../@galaxis/registries/contracts/UsesGalaxisRegistry.sol";

import "@openzeppelin/contracts/access/Ownable.sol";

/*
    ActionHub Flow:
    - calls getGLXToGLPConvertedAmount() to get how much it needs to store in GLP balance
*/
contract GLXToGLPConverter is Ownable, BlackHolePrevention, UsesGalaxisRegistry {


    constructor(address _galaxisRegistry) UsesGalaxisRegistry(_galaxisRegistry) {

    }

    function getGLXToGLPConvertedAmount(uint256 _GLXAmount) public virtual view returns (uint256) {
        return _GLXAmount;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.25;
import "../@galaxis/registries/contracts/UsesGalaxisRegistry.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../@galaxis/registries/contracts/CommunityList.sol";
import "../@galaxis/registries/contracts/CommunityRegistry.sol";

/**
* @title TokenDepositor
* @author galaxis.xyz
* @notice This contract allows users to deposite GALAXIS tokens into their community cards.
* @notice The GALAXIS tokens deposited belong to the card after deposite and therefore to the ower of said card.
*/
contract TokenDepositor is UsesGalaxisRegistry {
    /// @dev Address of GALAXIS token
    IERC20 public immutable galaxisToken; 

    /// @dev mapping of deposited ballances: tokenContract -> tokenId -> currentBalance of deposited GALAXIS
    mapping(address => mapping(uint256 => uint256)) public balances;

    /// @dev Event emitited when GALAXIS is deposited to a card
    event GalaxisTokensDeposited(address tokenAddress, uint256 tokenId, uint256 amount);
    /// @dev Event emitited when GALAXIS is withdrawn from a card
    event GalaxisTokensWithdrawn(address tokenAddress, uint256 tokenId, uint256 amount);

    /**
    * @dev Sets up the required addresses.
    * @param galaxisRegistry Address of galaxis master registry
    */
    constructor(
        address galaxisRegistry
    ) UsesGalaxisRegistry(galaxisRegistry){

        // Read and set GALAXIS token address from galaxis registry (at the time of deployment!)
        galaxisToken = IERC20(IRegistry(galaxisRegistry).getRegistryAddress("GALAXIS_TOKEN"));
    }

    /**
    * @dev The user may deposit any amount GALAXIS they own to a card they own that belongs to the galaxis ecosystem
    * @param communityId Community ID
    * @param specificTokenAddress ERC271 token contract that belongs to the community
    * @param tokenId Token ID from specified token cotnract
    * @param amount Amount of GALAXIS to deposit
    */
    function depositGalaxisToken(uint32 communityId, address specificTokenAddress, uint256 tokenId, uint256 amount) public {
        require(galaxisToken.allowance(msg.sender, address(this)) >= amount, "TokenDepositor: Insuffiecient GALAXIS allowance");
        require(specificTokenAddress != address(0), "TokenDepositor: Invalid token contract address");

        IERC721Enumerable tokenContract = IERC721Enumerable(specificTokenAddress);
        require(tokenContract.ownerOf(tokenId)==msg.sender, "TokenDepositor: Not owner of token");

        CommunityList communityList = CommunityList(galaxisRegistry.getRegistryAddress("COMMUNITY_LIST"));
        (, address crAddr, ) = communityList.communities(communityId);
        require(crAddr != address(0), "TokenDepositor: Invalid community id");
        CommunityRegistry communityRegistry = CommunityRegistry(crAddr);

        uint256 numberOfTokenContracts = communityRegistry.getRegistryUINT("TOKEN_COUNT");
        require(numberOfTokenContracts > 0, "TokenDepositor: No token contracts for given community");

        // TOKEN_{N}
        for(uint256 i = 1; i <= numberOfTokenContracts; i++){
            address tokenAddress = communityRegistry.getRegistryAddress(
                string.concat("TOKEN_", Strings.toString(i))
            );
            if(specificTokenAddress == tokenAddress){
                _deposit(tokenAddress, tokenId, amount);
                return;
            }
        }

        // CHILD_TOKEN_{N}
        for(uint256 i = 1; i <= numberOfTokenContracts; i++){
            address tokenAddress = communityRegistry.getRegistryAddress(
                string.concat("CHILD_TOKEN_", Strings.toString(i))
            );
            if(specificTokenAddress == tokenAddress){
                _deposit(tokenAddress, tokenId, amount);
                return;
            }
        }
        revert("TokenDepositor: Community does not have token contract for given address");
    }

    /**
    * @dev Tokens are transfered to the TokenDepositor contract and balance of the given card increased with specified amount
    * @param tokenAddress  ERC271 token contract that belongs to the community
    * @param tokenId Token ID from specified token cotnract
    * @param amount Amount of GALAXIS to deposit
    */
    function _deposit(address tokenAddress, uint256 tokenId, uint256 amount) internal {
        galaxisToken.transferFrom(
            msg.sender,
            address(this),
            amount
        );
        balances[tokenAddress][tokenId] += amount;
        emit GalaxisTokensDeposited(tokenAddress, tokenId, amount);
    }

    /**
    * @dev Calls `depositGalaxisToken` for every provided tokenId and amount
    * @dev Token ids and amounts are paired such as tokenIds[0] and amounts[0]
    * @param communityId Community ID
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenIds Token IDs from specified token cotnract
    * @param amounts Amounts of GALAXIS to deposit
    */
    function depositToMultipleCards(uint32 communityId, address tokenAddress, uint256[] memory tokenIds, uint256[] memory amounts) external {
        require(tokenIds.length == amounts.length, "TokenDepositor: Invalid array lengths");
        for(uint32 i = 0; i < tokenIds.length; i++){
            depositGalaxisToken(communityId, tokenAddress, tokenIds[i], amounts[i]);
        }
    }

    /**
    * @dev Withdraw GALAXIS from a given card
    * @dev Caller must be owner of given card
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenId Token ID from specified token cotnract
    * @param amount Amount of GALAXIS to deposit
    */
    function withdrawGalaxisToken(address tokenAddress, uint256 tokenId, uint256 amount) public {
        IERC721Enumerable tokenContract = IERC721Enumerable(tokenAddress);
        require(tokenContract.ownerOf(tokenId)==msg.sender, "TokenDepositor: Not owner of token");
        require(balances[tokenAddress][tokenId] >= amount, "TokenDepositor: Not enough funds deposited");
        _withdraw(tokenAddress, tokenId, amount);
    }

    /**
    * @dev Calls `withdrawGalaxisToken` with maximum amount to withdraw possible
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenId Token ID from specified token cotnract
    */
    function withdrawAllFromCard(address tokenAddress, uint256 tokenId) public {
        uint256 amountToWithdraw = balances[tokenAddress][tokenId];
        withdrawGalaxisToken(tokenAddress, tokenId, amountToWithdraw);
    }

    /**
    * @dev Calls `withdrawGalaxisToken` for every provided tokenId and amount
    * @dev Token ids and amounts are paired such as tokenIds[0] and amounts[0] 
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenIds Token ID from specified token cotnract
    * @param amounts Amount of GALAXIS to deposit
    */
    function withdrawFromMultipleCards(address tokenAddress, uint256[] memory tokenIds, uint256[] memory amounts) external {
        require(tokenIds.length == amounts.length, "TokenDepositor: Invalid array lengths");
        for(uint32 i = 0; i < tokenIds.length; i++){
            withdrawGalaxisToken(tokenAddress, tokenIds[i], amounts[i]);
        }
    }
    
    /**
    * @dev Balance of card decreased and tokens are transfered to caller 
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenId Token ID from specified token cotnract
    * @param amount Amount of GALAXIS to deposit
    */
    function _withdraw(address tokenAddress, uint256 tokenId, uint256 amount) internal {
        balances[tokenAddress][tokenId] -= amount;
        galaxisToken.transfer(
            msg.sender,
            amount
        );
        emit GalaxisTokensWithdrawn(tokenAddress, tokenId, amount);(tokenAddress, tokenId, amount);
    }

    /**
    * @dev Returns the total amount of currently deposited GALAXIS tokens from a given token address and array of token IDs
    * @param tokenAddress ERC271 token contract that belongs to the community
    * @param tokenIds Token IDs from specified token cotnract
    */
    function getDepositedBalancesForMultiple(address tokenAddress, uint256[] memory tokenIds) external view returns(uint256){
        uint256 totalAmount = 0;
        for(uint32 i = 0; i< tokenIds.length; i++){
            totalAmount += balances[tokenAddress][tokenIds[i]];
        }
        return totalAmount;
    }


    function getTotalDepositedBalances(address tokenAddress, address wallet) external view returns(uint256){
        uint256 totalAmount = 0;
        IERC721Enumerable tokenContract = IERC721Enumerable(tokenAddress);
        uint256 numberOfTokens = tokenContract.balanceOf(wallet);
        for(uint256 i = 0; i < numberOfTokens; i++){
            uint256 tokenId = tokenContract.tokenOfOwnerByIndex(wallet, i);
            totalAmount += balances[tokenAddress][tokenId];
        }
        return totalAmount;
    }
    
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

import "../ActionHub/IActionHub.sol";
import "../@galaxis/registries/contracts/Versionable/IGenericVersionable.sol";

interface IGenericTraitConsumer is IGenericVersionable {
    function doAction(
        address from,
        IActionHub.ExpandedTokenContracts calldata etc,
        IActionHub.UserAction calldata action
    ) external;
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract BlackHolePrevention is Ownable {
    // blackhole prevention methods
    function retrieveETH() external onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }
    
    function retrieveERC20(address _tracker, uint256 amount) external onlyOwner {
        IERC20(_tracker).transfer(msg.sender, amount);
    }

    function retrieve721(address _tracker, uint256 id) external onlyOwner {
        IERC721(_tracker).transferFrom(address(this), msg.sender, id);
    }
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

interface IGenericTrait {

    function addTrait(uint32[] memory _tokenIds) external;
    
    function hasTrait(uint32 _tokenId) external view returns (bool result);
    function isInitialized(uint32 _tokenId) external view returns (bool result);
 
    function getProperty(bytes32 _name, uint32 _tokenId) external view returns (bytes memory);
    function getProperties(uint32 _tokenId, bytes32[] memory _names) external  view returns(bytes[] memory);

    function setProperty(bytes32 _name, uint32 _tokenId, bytes memory input) external;
    function setProperties(uint32 _tokenId, bytes32[] memory _names, bytes[] memory inputs) external;

    function incrementCounter(uint32 _tokenId) external;
    function decrementCounter(uint32 _tokenId) external;
}

// SPDX-License-Identifier: UNLICENCED
pragma solidity 0.8.25;

interface IECRegistry {
    function addTrait(traitStruct[] memory) external; 
    function getImplementer(uint16 traitID) external view returns (address);
    function addressCanModifyTrait(address, uint16) external view returns (bool);
    function addressCanModifyTraits(address, uint16[] memory) external view returns (bool);
    function hasTrait(uint16 traitID, uint16 tokenID) external view returns (bool);
    function setTrait(uint16 traitID, uint16 tokenID, bool) external returns (bool);
    function setTraitUnchecked(uint16 traitID, uint16 tokenId, bool _value) external;
    function setTraitOnMultiple(uint16 traitID, uint16[] memory tokenIds, bool _value) external returns(uint16 changes);
    function setTraitOnMultipleUnchecked(uint16 traitID, uint16[] memory tokenIds, bool[] memory _value) external;
    function getTrait(uint16 id) external view returns (traitStruct memory);
    function getTraits() external view returns (traitStruct[] memory);
    function owner() external view returns (address);
    function contractController(address) external view returns (bool);
    function getDefaultTraitControllerByType(uint8) external view returns (address);
    function setDefaultTraitControllerType(address, uint8) external;
    function setTraitControllerAccess(address, uint16, bool) external;
    function traitCount() external view returns (uint16);

    struct traitStruct {
        uint16  id;
        uint8   traitType;              // 0 normal (1bit), 1 range, 2 inverted range, >=3 with storageImplementer
        uint16  start;
        uint16  end;
        bool    enabled;
        address storageImplementer;     // address of the smart contract that will implement the storage for the trait
        string  ipfsHash;
        string  name;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

library console {
    address constant CONSOLE_ADDRESS =
        0x000000000000000000636F6e736F6c652e6c6f67;

    function _sendLogPayloadImplementation(bytes memory payload) internal view {
        address consoleAddress = CONSOLE_ADDRESS;
        /// @solidity memory-safe-assembly
        assembly {
            pop(
                staticcall(
                    gas(),
                    consoleAddress,
                    add(payload, 32),
                    mload(payload),
                    0,
                    0
                )
            )
        }
    }

    function _castToPure(
      function(bytes memory) internal view fnIn
    ) internal pure returns (function(bytes memory) pure fnOut) {
        assembly {
            fnOut := fnIn
        }
    }

    function _sendLogPayload(bytes memory payload) internal pure {
        _castToPure(_sendLogPayloadImplementation)(payload);
    }

    function log() internal pure {
        _sendLogPayload(abi.encodeWithSignature("log()"));
    }
    function logInt(int256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    }

    function logUint(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function logString(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function logBool(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function logAddress(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function logBytes(bytes memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    }

    function logBytes1(bytes1 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    }

    function logBytes2(bytes2 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    }

    function logBytes3(bytes3 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    }

    function logBytes4(bytes4 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    }

    function logBytes5(bytes5 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    }

    function logBytes6(bytes6 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    }

    function logBytes7(bytes7 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    }

    function logBytes8(bytes8 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    }

    function logBytes9(bytes9 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    }

    function logBytes10(bytes10 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    }

    function logBytes11(bytes11 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    }

    function logBytes12(bytes12 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    }

    function logBytes13(bytes13 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    }

    function logBytes14(bytes14 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    }

    function logBytes15(bytes15 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    }

    function logBytes16(bytes16 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    }

    function logBytes17(bytes17 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    }

    function logBytes18(bytes18 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    }

    function logBytes19(bytes19 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    }

    function logBytes20(bytes20 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    }

    function logBytes21(bytes21 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    }

    function logBytes22(bytes22 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    }

    function logBytes23(bytes23 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    }

    function logBytes24(bytes24 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    }

    function logBytes25(bytes25 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    }

    function logBytes26(bytes26 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    }

    function logBytes27(bytes27 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    }

    function logBytes28(bytes28 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    }

    function logBytes29(bytes29 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    }

    function logBytes30(bytes30 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    }

    function logBytes31(bytes31 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    }

    function logBytes32(bytes32 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    }

    function log(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

    function log(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function log(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function log(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function log(uint256 p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    }

    function log(uint256 p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    }

    function log(uint256 p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    }

    function log(uint256 p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    }

    function log(string memory p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    }

    function log(string memory p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    }

    function log(string memory p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    }

    function log(string memory p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    }

    function log(bool p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    }

    function log(bool p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    }

    function log(bool p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    }

    function log(bool p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    }

    function log(address p0, uint256 p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    }

    function log(address p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    }

    function log(address p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    }

    function log(address p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    }

    function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    }

    function log(uint256 p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    }

    function log(uint256 p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    }

    function log(uint256 p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    }

    function log(string memory p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    }

    function log(string memory p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    }

    function log(string memory p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    }

    function log(string memory p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    }

    function log(string memory p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    }

    function log(bool p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    }

    function log(bool p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    }

    function log(bool p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    }

    function log(bool p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    }

    function log(bool p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    }

    function log(bool p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    }

    function log(bool p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    }

    function log(bool p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    }

    function log(bool p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    }

    function log(address p0, uint256 p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    }

    function log(address p0, string memory p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    }

    function log(address p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    }

    function log(address p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    }

    function log(address p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    }

    function log(address p0, bool p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    }

    function log(address p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    }

    function log(address p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    }

    function log(address p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    }

    function log(address p0, address p1, uint256 p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    }

    function log(address p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    }

    function log(address p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    }

    function log(address p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    }

    function log(uint256 p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint256 p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint256 p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, uint256 p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    }

}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_galaxisRegistry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"CommunityListNotLoaded","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"CommunityRegistryNotLoaded","type":"error"},{"inputs":[],"name":"RegistryNotLoaded","type":"error"},{"inputs":[{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"string","name":"","type":"string"},{"internalType":"address","name":"","type":"address"}],"name":"TraitRegistryNotLoaded","type":"error"},{"inputs":[],"name":"GLPContractInstance","outputs":[{"internalType":"contract GLP","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GLXContractInstance","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GLX_TO_GLP_CONVERTER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PaymentMatrixContractInstance","outputs":[{"internalType":"contract IPaymentMatrix","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TokenDepositorContractInstance","outputs":[{"internalType":"contract TokenDepositor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TokenMembershipTier1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"enum IActionHub.ActionType","name":"_type","type":"uint8"},{"internalType":"uint32","name":"membershipCardId","type":"uint32"},{"internalType":"uint32","name":"communityId","type":"uint32"},{"internalType":"uint32","name":"collectionId","type":"uint32"},{"internalType":"uint32","name":"tokenId","type":"uint32"},{"internalType":"uint16","name":"traitId","type":"uint16"},{"internalType":"address","name":"consumer","type":"address"},{"internalType":"bytes","name":"userData","type":"bytes"}],"internalType":"struct IActionHub.UserAction[]","name":"messages","type":"tuple[]"}],"name":"doAction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"galaxisRegistry","outputs":[{"internalType":"contract IRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"refreshRegistries","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_communityId","type":"uint32"},{"internalType":"uint32","name":"_collectionId","type":"uint32"},{"internalType":"uint32","name":"_tokenId","type":"uint32"}],"name":"royaltiesPaid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"takeMyGLX","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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

000000000000000000000000dbd9608fbca959828c1615d29aeb3dc872d40ae2

-----Decoded View---------------
Arg [0] : _galaxisRegistry (address): 0xdBD9608fBcA959828C1615d29AEb3dc872d40Ae2

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000dbd9608fbca959828c1615d29aeb3dc872d40ae2