// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
pragma solidity ^0.8.4;

import "../access/OwnablePermissions.sol";

/**
 * @title AutomaticValidatorTransferApproval
 * @author Limit Break, Inc.
 * @notice Base contract mix-in that provides boilerplate code giving the contract owner the
 *         option to automatically approve a 721-C transfer validator implementation for transfers.
 */
abstract contract AutomaticValidatorTransferApproval is OwnablePermissions {

    /// @dev Emitted when the automatic approval flag is modified by the creator.
    event AutomaticApprovalOfTransferValidatorSet(bool autoApproved);

    /// @dev If true, the collection's transfer validator is automatically approved to transfer holder's tokens.
    bool public autoApproveTransfersFromValidator;

    /**
     * @notice Sets if the transfer validator is automatically approved as an operator for all token owners.
     * 
     * @dev    Throws when the caller is not the contract owner.
     * 
     * @param autoApprove If true, the collection's transfer validator will be automatically approved to
     *                    transfer holder's tokens.
     */
    function setAutomaticApprovalOfTransfersFromValidator(bool autoApprove) external {
        _requireCallerIsContractOwner();
        autoApproveTransfersFromValidator = autoApprove;
        emit AutomaticApprovalOfTransferValidatorSet(autoApprove);
    }
}

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

import "@openzeppelin/contracts/token/common/ERC2981.sol";

/**
 * @title BasicRoyaltiesBase
 * @author Limit Break, Inc.
 * @dev Base functionality of an NFT mix-in contract implementing the most basic form of programmable royalties.
 */
abstract contract BasicRoyaltiesBase is ERC2981 {

    event DefaultRoyaltySet(address indexed receiver, uint96 feeNumerator);
    event TokenRoyaltySet(uint256 indexed tokenId, address indexed receiver, uint96 feeNumerator);

    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual override {
        super._setDefaultRoyalty(receiver, feeNumerator);
        emit DefaultRoyaltySet(receiver, feeNumerator);
    }

    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual override {
        super._setTokenRoyalty(tokenId, receiver, feeNumerator);
        emit TokenRoyaltySet(tokenId, receiver, feeNumerator);
    }
}

/**
 * @title BasicRoyalties
 * @author Limit Break, Inc.
 * @notice Constructable BasicRoyalties Contract implementation.
 */
abstract contract BasicRoyalties is BasicRoyaltiesBase {
    constructor(address receiver, uint96 feeNumerator) {
        _setDefaultRoyalty(receiver, feeNumerator);
    }
}

/**
 * @title BasicRoyaltiesInitializable
 * @author Limit Break, Inc.
 * @notice Initializable BasicRoyalties Contract implementation to allow for EIP-1167 clones. 
 */
abstract contract BasicRoyaltiesInitializable is BasicRoyaltiesBase {}

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

import "@limitbreak/creator-token-standards/src/access/OwnableBasic.sol";
import "@limitbreak/creator-token-standards/src/erc1155c/ERC1155C.sol";
import "@limitbreak/creator-token-standards/src/programmable-royalties/BasicRoyalties.sol";

import "@openzeppelin/contracts/utils/Strings.sol";
import "./Drifter.sol";

contract BioCanvas is ERC1155C, BasicRoyalties, OwnableBasic {
	using Strings for uint256;

	uint96 public constant ROYALTY_FEE_NUMERATOR = 500; // 5% royalty

	uint256 public minted;
	string public baseURI = "https://m.cyberbrokers.com/base/biocanvas/";
	address public DRIFTER_ADDRESS;
	address[] public BIO_CANVAS_MINTER_ADDRESSES;

	modifier onlyBioCanvasMinters() {
		bool isMinter = false;
		for (uint256 i = 0; i < BIO_CANVAS_MINTER_ADDRESSES.length; i++) {
			if (BIO_CANVAS_MINTER_ADDRESSES[i] == msg.sender) {
				isMinter = true;
				break;
			}
		}
		require(isMinter, "Caller is not a BioCanvas minter");
		_;
	}

	modifier onlyDrifterAddress() {
		require(msg.sender == DRIFTER_ADDRESS, "Caller is not the Drifter contract");
		_;
	}

	function name() public pure returns (string memory) {
		return "Drifter BioCanvases";
	}

	function symbol() public pure returns (string memory) {
		return "DRIFTERBIOCANVAS";
	}

	// Required to use ERC1155OpenZeppelin instead of ERC1155C due to a fuckup from LimitBreak
	constructor(string memory uri_, address _royaltyReceiver) ERC1155OpenZeppelin(uri_) BasicRoyalties(_royaltyReceiver, ROYALTY_FEE_NUMERATOR) OwnableBasic() {
		baseURI = uri_;
	}

	function setBaseURI(string memory _baseURI) external onlyOwner {
		baseURI = _baseURI;
	}

	function addBioCanvasMinter(address minterAddress) external onlyOwner {
		require(minterAddress != address(0), "Invalid minter address");

		// Make sure the minter address is not already in the array
		for (uint256 i = 0; i < BIO_CANVAS_MINTER_ADDRESSES.length; i++) {
			if (BIO_CANVAS_MINTER_ADDRESSES[i] == minterAddress) {
				return;
			}
		}

		BIO_CANVAS_MINTER_ADDRESSES.push(minterAddress);
	}

	function removeBioCanvasMinter(address minterAddress) external onlyOwner {
		for (uint256 i = 0; i < BIO_CANVAS_MINTER_ADDRESSES.length; i++) {
			if (BIO_CANVAS_MINTER_ADDRESSES[i] == minterAddress) {
				BIO_CANVAS_MINTER_ADDRESSES[i] = BIO_CANVAS_MINTER_ADDRESSES[BIO_CANVAS_MINTER_ADDRESSES.length - 1];
				BIO_CANVAS_MINTER_ADDRESSES.pop();
				break;
			}
		}
	}

	function setDrifterAddress(address drifterAddress) external onlyOwner {
		DRIFTER_ADDRESS = drifterAddress;
	}

	function mint(address to, uint256 tokenId, uint256 amount) external onlyBioCanvasMinters {
		_mint(to, tokenId, amount, "");
		minted += amount;
	}

	function convertToDrifter(uint256 id, uint256 value, address to) external onlyDrifterAddress returns (bool) {
		// Require that the caller owns the BioCanvas token
		require(balanceOf(to, id) >= value, "Caller does not own enough BioCanvas tokens");

		_burn(to, id, value);

		return true;
	}

	function totalSupply() public view returns (uint256) {
		return minted;
	}

	function uri(uint256 tokenId) public view virtual override returns (string memory) {
		return string(abi.encodePacked(baseURI, tokenId.toString()));
	}

	function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155C, ERC2981) returns (bool) {
		return super.supportsInterface(interfaceId);
	}

	function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
		_setDefaultRoyalty(receiver, feeNumerator);
	}

	function setTokenRoyalty(address receiver, uint256 tokenId, uint96 feeNumerator) external onlyOwner {
		_setTokenRoyalty(tokenId, receiver, feeNumerator);
	}

	// Reject direct ETH transfers
	receive() external payable {
		revert("Direct ETH transfers not allowed");
	}
}

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

/// @dev Constant bytes32 value of 0x000...000
bytes32 constant ZERO_BYTES32 = bytes32(0);

/// @dev Constant value of 0
uint256 constant ZERO = 0;
/// @dev Constant value of 1
uint256 constant ONE = 1;

/// @dev Constant value representing an open order in storage
uint8 constant ORDER_STATE_OPEN = 0;
/// @dev Constant value representing a filled order in storage
uint8 constant ORDER_STATE_FILLED = 1;
/// @dev Constant value representing a cancelled order in storage
uint8 constant ORDER_STATE_CANCELLED = 2;

/// @dev Constant value representing the ERC721 token type for signatures and transfer hooks
uint256 constant TOKEN_TYPE_ERC721 = 721;
/// @dev Constant value representing the ERC1155 token type for signatures and transfer hooks
uint256 constant TOKEN_TYPE_ERC1155 = 1155;
/// @dev Constant value representing the ERC20 token type for signatures and transfer hooks
uint256 constant TOKEN_TYPE_ERC20 = 20;

/// @dev Constant value to mask the upper bits of a signature that uses a packed `vs` value to extract `s`
bytes32 constant UPPER_BIT_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

/// @dev EIP-712 typehash used for validating signature based stored approvals
bytes32 constant UPDATE_APPROVAL_TYPEHASH =
    keccak256("UpdateApprovalBySignature(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 approvalExpiration,uint256 sigDeadline,uint256 masterNonce)");

/// @dev EIP-712 typehash used for validating a single use permit without additional data
bytes32 constant SINGLE_USE_PERMIT_TYPEHASH =
    keccak256("PermitTransferFrom(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 expiration,uint256 masterNonce)");

/// @dev EIP-712 typehash used for validating a single use permit with additional data
string constant SINGLE_USE_PERMIT_TRANSFER_ADVANCED_TYPEHASH_STUB =
    "PermitTransferFromWithAdditionalData(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 expiration,uint256 masterNonce,";

/// @dev EIP-712 typehash used for validating an order permit that updates storage as it fills
string constant PERMIT_ORDER_ADVANCED_TYPEHASH_STUB =
    "PermitOrderWithAdditionalData(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 salt,address operator,uint256 expiration,uint256 masterNonce,";

/// @dev Pausable flag for stored approval transfers of ERC721 assets
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC721 = 1 << 0;
/// @dev Pausable flag for stored approval transfers of ERC1155 assets
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC1155 = 1 << 1;
/// @dev Pausable flag for stored approval transfers of ERC20 assets
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC20 = 1 << 2;

/// @dev Pausable flag for single use permit transfers of ERC721 assets
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC721 = 1 << 3;
/// @dev Pausable flag for single use permit transfers of ERC1155 assets
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC1155 = 1 << 4;
/// @dev Pausable flag for single use permit transfers of ERC20 assets
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC20 = 1 << 5;

/// @dev Pausable flag for order fill transfers of ERC1155 assets
uint256 constant PAUSABLE_ORDER_TRANSFER_FROM_ERC1155 = 1 << 6;
/// @dev Pausable flag for order fill transfers of ERC20 assets
uint256 constant PAUSABLE_ORDER_TRANSFER_FROM_ERC20 = 1 << 7;

// 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
pragma solidity ^0.8.4;

import "../access/OwnablePermissions.sol";
import "../interfaces/ICreatorToken.sol";
import "../interfaces/ICreatorTokenLegacy.sol";
import "../interfaces/ITransferValidator.sol";
import "./TransferValidation.sol";
import "../interfaces/ITransferValidatorSetTokenType.sol";

/**
 * @title CreatorTokenBase
 * @author Limit Break, Inc.
 * @notice CreatorTokenBaseV3 is an abstract contract that provides basic functionality for managing token 
 * transfer policies through an implementation of ICreatorTokenTransferValidator/ICreatorTokenTransferValidatorV2/ICreatorTokenTransferValidatorV3. 
 * This contract is intended to be used as a base for creator-specific token contracts, enabling customizable transfer 
 * restrictions and security policies.
 *
 * <h4>Features:</h4>
 * <ul>Ownable: This contract can have an owner who can set and update the transfer validator.</ul>
 * <ul>TransferValidation: Implements the basic token transfer validation interface.</ul>
 *
 * <h4>Benefits:</h4>
 * <ul>Provides a flexible and modular way to implement custom token transfer restrictions and security policies.</ul>
 * <ul>Allows creators to enforce policies such as account and codehash blacklists, whitelists, and graylists.</ul>
 * <ul>Can be easily integrated into other token contracts as a base contract.</ul>
 *
 * <h4>Intended Usage:</h4>
 * <ul>Use as a base contract for creator token implementations that require advanced transfer restrictions and 
 *   security policies.</ul>
 * <ul>Set and update the ICreatorTokenTransferValidator implementation contract to enforce desired policies for the 
 *   creator token.</ul>
 *
 * <h4>Compatibility:</h4>
 * <ul>Backward and Forward Compatible - V1/V2/V3 Creator Token Base will work with V1/V2/V3 Transfer Validators.</ul>
 */
abstract contract CreatorTokenBase is OwnablePermissions, TransferValidation, ICreatorToken {

    /// @dev Thrown when setting a transfer validator address that has no deployed code.
    error CreatorTokenBase__InvalidTransferValidatorContract();

    /// @dev The default transfer validator that will be used if no transfer validator has been set by the creator.
    address public constant DEFAULT_TRANSFER_VALIDATOR = address(0x721C002B0059009a671D00aD1700c9748146cd1B);

    /// @dev Used to determine if the default transfer validator is applied.
    /// @dev Set to true when the creator sets a transfer validator address.
    bool private isValidatorInitialized;
    /// @dev Address of the transfer validator to apply to transactions.
    address private transferValidator;

    constructor() {
        _emitDefaultTransferValidator();
        _registerTokenType(DEFAULT_TRANSFER_VALIDATOR);
    }

    /**
     * @notice Sets the transfer validator for the token contract.
     *
     * @dev    Throws when provided validator contract is not the zero address and does not have code.
     * @dev    Throws when the caller is not the contract owner.
     *
     * @dev    <h4>Postconditions:</h4>
     *         1. The transferValidator address is updated.
     *         2. The `TransferValidatorUpdated` event is emitted.
     *
     * @param transferValidator_ The address of the transfer validator contract.
     */
    function setTransferValidator(address transferValidator_) public {
        _requireCallerIsContractOwner();

        bool isValidTransferValidator = transferValidator_.code.length > 0;

        if(transferValidator_ != address(0) && !isValidTransferValidator) {
            revert CreatorTokenBase__InvalidTransferValidatorContract();
        }

        emit TransferValidatorUpdated(address(getTransferValidator()), transferValidator_);

        isValidatorInitialized = true;
        transferValidator = transferValidator_;

        _registerTokenType(transferValidator_);
    }

    /**
     * @notice Returns the transfer validator contract address for this token contract.
     */
    function getTransferValidator() public view override returns (address validator) {
        validator = transferValidator;

        if (validator == address(0)) {
            if (!isValidatorInitialized) {
                validator = DEFAULT_TRANSFER_VALIDATOR;
            }
        }
    }

    /**
     * @dev Pre-validates a token transfer, reverting if the transfer is not allowed by this token's security policy.
     *      Inheriting contracts are responsible for overriding the _beforeTokenTransfer function, or its equivalent
     *      and calling _validateBeforeTransfer so that checks can be properly applied during token transfers.
     *
     * @dev Be aware that if the msg.sender is the transfer validator, the transfer is automatically permitted, as the
     *      transfer validator is expected to pre-validate the transfer.
     *
     * @dev Throws when the transfer doesn't comply with the collection's transfer policy, if the transferValidator is
     *      set to a non-zero address.
     *
     * @param caller  The address of the caller.
     * @param from    The address of the sender.
     * @param to      The address of the receiver.
     * @param tokenId The token id being transferred.
     */
    function _preValidateTransfer(
        address caller, 
        address from, 
        address to, 
        uint256 tokenId, 
        uint256 /*value*/) internal virtual override {
        address validator = getTransferValidator();

        if (validator != address(0)) {
            if (msg.sender == validator) {
                return;
            }

            ITransferValidator(validator).validateTransfer(caller, from, to, tokenId);
        }
    }

    /**
     * @dev Pre-validates a token transfer, reverting if the transfer is not allowed by this token's security policy.
     *      Inheriting contracts are responsible for overriding the _beforeTokenTransfer function, or its equivalent
     *      and calling _validateBeforeTransfer so that checks can be properly applied during token transfers.
     *
     * @dev Be aware that if the msg.sender is the transfer validator, the transfer is automatically permitted, as the
     *      transfer validator is expected to pre-validate the transfer.
     * 
     * @dev Used for ERC20 and ERC1155 token transfers which have an amount value to validate in the transfer validator.
     * @dev The `tokenId` for ERC20 tokens should be set to `0`.
     *
     * @dev Throws when the transfer doesn't comply with the collection's transfer policy, if the transferValidator is
     *      set to a non-zero address.
     *
     * @param caller  The address of the caller.
     * @param from    The address of the sender.
     * @param to      The address of the receiver.
     * @param tokenId The token id being transferred.
     * @param amount  The amount of token being transferred.
     */
    function _preValidateTransfer(
        address caller, 
        address from, 
        address to, 
        uint256 tokenId, 
        uint256 amount,
        uint256 /*value*/) internal virtual override {
        address validator = getTransferValidator();

        if (validator != address(0)) {
            if (msg.sender == validator) {
                return;
            }

            ITransferValidator(validator).validateTransfer(caller, from, to, tokenId, amount);
        }
    }

    function _tokenType() internal virtual pure returns(uint16);

    function _registerTokenType(address validator) internal {
        if (validator != address(0)) {
            uint256 validatorCodeSize;
            assembly {
                validatorCodeSize := extcodesize(validator)
            }
            if(validatorCodeSize > 0) {
                try ITransferValidatorSetTokenType(validator).setTokenTypeOfCollection(address(this), _tokenType()) {
                } catch { }
            }
        }
    }

    /**
     * @dev  Used during contract deployment for constructable and cloneable creator tokens
     * @dev  to emit the `TransferValidatorUpdated` event signaling the validator for the contract
     * @dev  is the default transfer validator.
     */
    function _emitDefaultTransferValidator() internal {
        emit TransferValidatorUpdated(address(0), DEFAULT_TRANSFER_VALIDATOR);
    }
}

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

import "@limitbreak/creator-token-standards/src/access/OwnableBasic.sol";
import "@limitbreak/creator-token-standards/src/erc721c/ERC721C.sol";
import "@limitbreak/creator-token-standards/src/programmable-royalties/BasicRoyalties.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DNACardReveal.sol";
import "./DNACardLib.sol";

contract DNACard is OwnableBasic, ERC721C, BasicRoyalties {
	using Address for address;
	using Strings for uint256;

	uint96 public constant ROYALTY_FEE_NUMERATOR = 500; // 5% royalty

	string public baseURI = "https://m.cyberbrokers.com/base/dnapack/";

	// Mapping from token ID to its type (1-9)
	mapping(uint256 => uint8) public cardSkins;

	uint256 public constant SMALL_SUPPLY = 2707;
	uint256 public constant MEDIUM_SUPPLY = 3907;
	uint256 public constant LARGE_SUPPLY = 1163;

	uint256 public smallMinted;
	uint256 public mediumMinted;
	uint256 public largeMinted;
	uint256 public totalRevealed;

	// Array-as-mapping from skin type (1-9) to its supply info
	// small pack is 1 * 2707, medium pack is 3 * 1303, large pack is 5 * 233
	uint256[] public cardSkinSupplies = [0, 2707, 1303, 1303, 1303, 233, 233, 233, 233, 233];

	address[] public DNA_CARD_MINTER_ADDRESSES;
	DNACardReveal public dnaCardRevealContract;

	// Mapping to store the card type for each token ID
	mapping(uint256 => DNACardLib.CardSize) public cardSizes;

	// Mapping of ownership of revealed dna cards
	mapping(uint256 => address) public revealedOwners;

	event DNACardRevealed(uint256 indexed tokenId, uint256[] gearIds);
	event DNACardHarvested(uint256 indexed tokenId, uint256[] harvestedGearIds);

	modifier onlyDnaCardMinters() {
		bool isMinter = false;
		for (uint256 i = 0; i < DNA_CARD_MINTER_ADDRESSES.length; i++) {
			if (DNA_CARD_MINTER_ADDRESSES[i] == msg.sender) {
				isMinter = true;
				break;
			}
		}
		require(isMinter, "Caller is not a DNA Card minter");
		_;
	}

	constructor(
		address royaltyReceiver_,
		string memory name_,
		string memory symbol_
	) ERC721OpenZeppelin(name_, symbol_) BasicRoyalties(royaltyReceiver_, ROYALTY_FEE_NUMERATOR) {}

	function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721C, ERC2981) returns (bool) {
		return super.supportsInterface(interfaceId);
	}

	function addDnaCardMinter(address minterAddress) external onlyOwner {
		require(minterAddress != address(0), "Invalid minter address");

		// Make sure the minter address is not already in the array
		for (uint256 i = 0; i < DNA_CARD_MINTER_ADDRESSES.length; i++) {
			if (DNA_CARD_MINTER_ADDRESSES[i] == minterAddress) {
				return;
			}
		}

		DNA_CARD_MINTER_ADDRESSES.push(minterAddress);
	}

	function removeDnaCardMinter(address minterAddress) external onlyOwner {
		for (uint256 i = 0; i < DNA_CARD_MINTER_ADDRESSES.length; i++) {
			if (DNA_CARD_MINTER_ADDRESSES[i] == minterAddress) {
				DNA_CARD_MINTER_ADDRESSES[i] = DNA_CARD_MINTER_ADDRESSES[DNA_CARD_MINTER_ADDRESSES.length - 1];
				DNA_CARD_MINTER_ADDRESSES.pop();
				break;
			}
		}
	}

	function setDnaCardRevealContract(address payable dnaCardRevealAddress) external onlyOwner {
		require(dnaCardRevealAddress != address(0), "Invalid DNA Card Reveal contract address");
		dnaCardRevealContract = DNACardReveal(dnaCardRevealAddress);
	}

	function reveal(uint256 tokenId) external {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");

		// Require that the token exists
		require(_exists(tokenId), "Token does not exist");

		// Require that the caller owns the token
		require(_isApprovedOrOwner(_msgSender(), tokenId), "Caller is not owner nor approved");

		// Require that the token is not already revealed
		require(revealedOwners[tokenId] == address(0), "Token already revealed");

		// Store the caller as the owner of the revealed DNA card
		revealedOwners[tokenId] = _msgSender();

		// Reveal the DNA card
		uint256[] memory selectedGear = dnaCardRevealContract.reveal(_msgSender(), tokenId, getCardSize(tokenId), getCardSkin(tokenId));

		// Burn the DNA card
		_burn(tokenId);
		totalRevealed++;

		emit DNACardRevealed(tokenId, selectedGear);
	}

	function harvestReveal(uint256 tokenId, uint256[] calldata selectedGearIds) external {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");

		// Require that the token is revealed by the caller
		require(revealedOwners[tokenId] != address(0), "DNA Card not revealed yet");
		require(revealedOwners[tokenId] == _msgSender(), "Only revealed owner can harvest");

		uint256[] memory harvestedGear = dnaCardRevealContract.harvestReveal(_msgSender(), tokenId, getCardSize(tokenId), selectedGearIds);

		emit DNACardHarvested(tokenId, harvestedGear);
	}

	function getRevealedGear(uint256 tokenId) external view returns (uint256[] memory) {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");
		return dnaCardRevealContract.getRevealedGear(tokenId);
	}

	function getRemainingSelectionTime(uint256 tokenId) external view returns (uint256) {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");
		return dnaCardRevealContract.getRemainingSelectionTime(tokenId);
	}

	function isRevealed(uint256 tokenId) external view returns (bool) {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");
		return dnaCardRevealContract.isRevealed(tokenId);
	}

	function isHarvested(uint256 tokenId) external view returns (bool) {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");
		return dnaCardRevealContract.isHarvested(tokenId);
	}

	function SELECTION_TIME_LIMIT() external view returns (uint256) {
		// Require that the DNA Card Reveal contract is set
		require(address(dnaCardRevealContract) != address(0), "DNA Card Reveal contract not set");
		return dnaCardRevealContract.SELECTION_TIME_LIMIT();
	}

	function _selectCardSkin(DNACardLib.CardSize cardSize) internal view returns (uint8) {
		if (cardSize == DNACardLib.CardSize.SMALL) {
			// Small pack - only type 1
			require(cardSkinSupplies[1] > 0, "Small pack type depleted");
			return 1;
		} else if (cardSize == DNACardLib.CardSize.MEDIUM) {
			// Medium pack - types 2-4
			uint256 totalRemaining = 0;
			for (uint8 i = 2; i <= 4; i++) {
				totalRemaining += cardSkinSupplies[i];
			}
			require(totalRemaining > 0, "Medium pack types depleted");

			// Generate random number
			uint256 randomNum = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, msg.sender))) % totalRemaining;

			// Select type based on weighted probabilities
			uint256 cumulative = 0;
			for (uint8 i = 2; i <= 4; i++) {
				cumulative += cardSkinSupplies[i];
				if (randomNum < cumulative) {
					return i;
				}
			}
			return 4; // Fallback to last type (shouldn't reach here)
		} else {
			// Large pack - types 5-9
			uint256 totalRemaining = 0;
			for (uint8 i = 5; i <= 9; i++) {
				totalRemaining += cardSkinSupplies[i];
			}
			require(totalRemaining > 0, "Large pack types depleted");

			// Generate random number
			uint256 randomNum = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, msg.sender))) % totalRemaining;

			// Select type based on weighted probabilities
			uint256 cumulative = 0;
			for (uint8 i = 5; i <= 9; i++) {
				cumulative += cardSkinSupplies[i];
				if (randomNum < cumulative) {
					return i;
				}
			}
			return 9; // Fallback to last type (shouldn't reach here)
		}
	}

	function mint(address to, uint8 cardSize) external onlyDnaCardMinters returns (uint256) {
		require(cardSize >= 0 && cardSize <= 2, "Invalid card type");

		// Select token type based on weighted probabilities
		uint8 cardSkin = _selectCardSkin(DNACardLib.CardSize(cardSize));
		require(cardSkinSupplies[cardSkin] > 0, "Type supply depleted");

		// Decrement the selected type's supply
		cardSkinSupplies[cardSkin]--;

		uint256 tokenId;
		// Validate and update card size tracking, calculate tokenId
		if (cardSize == 0) {
			require(smallMinted < SMALL_SUPPLY, "Small card supply exceeded");
			smallMinted++;
			tokenId = smallMinted;
		} else if (cardSize == 1) {
			require(mediumMinted < MEDIUM_SUPPLY, "Medium card supply exceeded");
			mediumMinted++;
			tokenId = SMALL_SUPPLY + mediumMinted;
		} else {
			require(largeMinted < LARGE_SUPPLY, "Large card supply exceeded");
			largeMinted++;
			tokenId = SMALL_SUPPLY + MEDIUM_SUPPLY + largeMinted;
		}

		_mint(to, tokenId);
		cardSizes[tokenId] = DNACardLib.CardSize(cardSize);
		cardSkins[tokenId] = cardSkin;

		return tokenId;
	}

	function totalSupply() public view returns (uint256) {
		return smallMinted + mediumMinted + largeMinted - totalRevealed;
	}

	function getCardSize(uint256 tokenId) public view returns (DNACardLib.CardSize) {
		return cardSizes[tokenId];
	}

	function getCardSkin(uint256 tokenId) public view returns (uint8) {
		return cardSkins[tokenId];
	}

	function setBaseURI(string memory newBaseURI) external onlyOwner {
		baseURI = newBaseURI;
	}

	function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
		require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
		return string(abi.encodePacked(baseURI, tokenId.toString()));
	}

	function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
		_setDefaultRoyalty(receiver, feeNumerator);
	}

	function setTokenRoyalty(address receiver, uint256 tokenId, uint96 feeNumerator) external onlyOwner {
		_setTokenRoyalty(tokenId, receiver, feeNumerator);
	}

	// Reject direct ETH transfers
	receive() external payable {
		revert("Direct ETH transfers not allowed");
	}
}

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

library DNACardLib {
	// Enum to represent DNA Card sizes
	enum CardSize {
		SMALL,
		MEDIUM,
		LARGE
	}
}

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

import "@limitbreak/creator-token-standards/src/access/OwnableBasic.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./DNACardLib.sol";
import "./GEAR.sol";

contract DNACardReveal is OwnableBasic {
	using Address for address;
	using Strings for uint256;

	// Initial supply limits for each rarity
	uint256 public constant COMMON_SUPPLY = 777;
	uint256 public constant UNCOMMON_SUPPLY = 550;
	uint256 public constant RARE_SUPPLY = 275;
	uint256 public constant EPIC_SUPPLY = 155;
	uint256 public constant LEGENDARY_SUPPLY = 34;

	// Mapping to track remaining supply for each gear token ID
	mapping(uint256 => uint256) public gearRemainingSupply;

	address public DNA_CARD_ADDRESS;
	GEAR public gearContract;

	// Time limit for manual gear selection (20 minutes)
	uint256 public constant SELECTION_TIME_LIMIT = 20 minutes;
	uint256 public constant SELECTION_TIME_LIMIT_BUFFER = 5 minutes;

	// Mapping to store reveal timestamps
	mapping(uint256 => uint256) public revealTimestamps;

	// Struct to track category requirements during reveal
	struct CategoryTracker {
		bool hasTopBodysuit;
		bool hasPantsSkirt;
		bool hasShoesBoots;
		bool hasHair;
		uint256 remainingItems;
	}

	// Mapping to store the card type for each token ID
	mapping(uint256 => DNACardLib.CardSize) public cardTypes;

	// Mapping to track if a token has been revealed
	mapping(uint256 => bool) public isRevealed;

	// Mapping to track if a token has been harvested
	mapping(uint256 => bool) public isHarvested;

	// Mapping to store revealed GEAR IDs for each DNA Card
	mapping(uint256 => uint256[]) public revealedGear;

	// Reveal configuration for different card sizes
	struct RevealConfig {
		uint256 legendaryCount;
		uint256 epicOrRareCount;
		uint256 uncommonCount;
		uint256 commonCount;
		uint256 colorCount;
		uint256 totalGearCount;
	}

	// Harvest configuration for different card sizes
	struct HarvestConfig {
		uint256 legendaryCount;
		uint256 rareOrEpicCount;
		uint256 uncommonCount;
		uint256 commonCount;
		uint256 totalHarvestCount;
	}

	struct SelectionParams {
		GEARMetadata.Rarity rarity;
		address to;
		uint256 tokenId;
		uint256 nonce;
		uint256[] alreadyRevealedGear;
		bool excludeSpecialCategories;
		CategoryTracker tracker;
	}

	struct ValidationParams {
		uint256 candidate;
		uint256[] alreadyRevealedGear;
		bool needsForcedCategories;
		string[] forcedCategories;
		bool excludeSpecialCategories;
		CategoryTracker tracker;
	}

	struct GearCounts {
		uint256 legendaryCount;
		uint256 epicCount;
		uint256 rareCount;
		uint256 uncommonCount;
		uint256 commonCount;
	}

	// Mapping of card sizes to their reveal configurations
	mapping(DNACardLib.CardSize => RevealConfig) public revealConfigs;

	// Mapping of card sizes to their harvest configurations
	mapping(DNACardLib.CardSize => HarvestConfig) public harvestConfigs;

	function setGearContract(address payable gearContractAddress) external onlyOwner {
		require(gearContractAddress != address(0), "Invalid gear contract address");
		gearContract = GEAR(gearContractAddress);
	}

	function setDnaCardAddress(address dnaCardAddress) external onlyOwner {
		require(dnaCardAddress != address(0), "Invalid DNA Card contract address");
		DNA_CARD_ADDRESS = dnaCardAddress;
	}

	modifier onlyDnaCard() {
		require(msg.sender == DNA_CARD_ADDRESS, "Caller is not the DNA Card contract");
		_;
	}

	constructor(address payable gearContractAddress_) {
		gearContract = GEAR(gearContractAddress_);

		resetGearRemainingSupply();

		// Initialize reveal configurations
		revealConfigs[DNACardLib.CardSize.SMALL] = RevealConfig({
			legendaryCount: 0,
			epicOrRareCount: 1,
			uncommonCount: 3,
			commonCount: 6,
			colorCount: 2,
			totalGearCount: 13 // 10 base + 1 skin + 2 colors
		});

		revealConfigs[DNACardLib.CardSize.MEDIUM] = RevealConfig({
			legendaryCount: 0,
			epicOrRareCount: 2,
			uncommonCount: 8,
			commonCount: 18,
			colorCount: 3,
			totalGearCount: 32 // 28 base + 1 skin + 3 colors
		});

		revealConfigs[DNACardLib.CardSize.LARGE] = RevealConfig({
			legendaryCount: 1,
			epicOrRareCount: 3,
			uncommonCount: 6,
			commonCount: 10,
			colorCount: 4,
			totalGearCount: 25 // 20 base + 1 skin + 4 colors
		});

		// Initialize harvest configurations
		harvestConfigs[DNACardLib.CardSize.SMALL] = HarvestConfig({
			legendaryCount: 0,
			rareOrEpicCount: 1,
			uncommonCount: 2,
			commonCount: 4,
			totalHarvestCount: 7
		});

		harvestConfigs[DNACardLib.CardSize.MEDIUM] = HarvestConfig({
			legendaryCount: 0,
			rareOrEpicCount: 1,
			uncommonCount: 6,
			commonCount: 12,
			totalHarvestCount: 19
		});

		harvestConfigs[DNACardLib.CardSize.LARGE] = HarvestConfig({
			legendaryCount: 1,
			rareOrEpicCount: 1,
			uncommonCount: 4,
			commonCount: 6,
			totalHarvestCount: 12
		});
	}

	function resetGearRemainingSupply() public onlyOwner {
		require(address(gearContract) != address(0), "Gear contract not set");
		uint256[] memory commonGear = gearContract.getRarityNFTAssetIds(GEARMetadata.Rarity.COMMON);
		uint256[] memory uncommonGear = gearContract.getRarityNFTAssetIds(GEARMetadata.Rarity.UNCOMMON);
		uint256[] memory rareGear = gearContract.getRarityNFTAssetIds(GEARMetadata.Rarity.RARE);
		uint256[] memory epicGear = gearContract.getRarityNFTAssetIds(GEARMetadata.Rarity.EPIC);
		uint256[] memory legendaryGear = gearContract.getRarityNFTAssetIds(GEARMetadata.Rarity.LEGENDARY);

		// Set initial supply for each gear token
		for (uint256 i = 0; i < commonGear.length; i++) {
			if (commonGear[i] != 0) {
				gearRemainingSupply[commonGear[i]] = COMMON_SUPPLY;
			}
		}
		for (uint256 i = 0; i < uncommonGear.length; i++) {
			if (uncommonGear[i] != 0) {
				gearRemainingSupply[uncommonGear[i]] = UNCOMMON_SUPPLY;
			}
		}
		for (uint256 i = 0; i < rareGear.length; i++) {
			if (rareGear[i] != 0) {
				gearRemainingSupply[rareGear[i]] = RARE_SUPPLY;
			}
		}
		for (uint256 i = 0; i < epicGear.length; i++) {
			if (epicGear[i] != 0) {
				gearRemainingSupply[epicGear[i]] = EPIC_SUPPLY;
			}
		}
		for (uint256 i = 0; i < legendaryGear.length; i++) {
			if (legendaryGear[i] != 0) {
				gearRemainingSupply[legendaryGear[i]] = LEGENDARY_SUPPLY;
			}
		}
	}

	function overrideGearCategoryRemainingSupply(string memory category, uint256 remainingSupply) external onlyOwner {
		require(address(gearContract) != address(0), "Gear contract not set");
		require(remainingSupply > 0, "Remaining supply must be greater than 0");
		uint256[] memory categoryGear = gearContract.getCategoryNFTAssetIds(category);

		// Set initial supply for each gear token
		for (uint256 i = 0; i < categoryGear.length; i++) {
			if (categoryGear[i] != 0) {
				gearRemainingSupply[categoryGear[i]] = remainingSupply;
			}
		}
	}

	function overrideGearRemainingSupply(uint256 tokenId, uint256 remainingSupply) external onlyOwner {
		require(remainingSupply > 0, "Remaining supply must be greater than 0");
		gearRemainingSupply[tokenId] = remainingSupply;
	}

	function reveal(address to, uint256 tokenId, DNACardLib.CardSize cardSize, uint8 cardSkin) public onlyDnaCard returns (uint256[] memory) {
		require(address(gearContract) != address(0), "Gear contract not set");
		require(!isRevealed[tokenId], "DNA Card already revealed");

		RevealConfig memory config = revealConfigs[cardSize];
		uint256[] memory selectedGear = new uint256[](config.totalGearCount);
		uint256 selectedCount = 0;
		uint256 nonce = 0;

		// Store reveal timestamp
		revealTimestamps[tokenId] = block.timestamp;

		// Initialize category tracker in memory
		CategoryTracker memory tracker = CategoryTracker({
			hasTopBodysuit: false,
			hasPantsSkirt: false,
			hasShoesBoots: false,
			hasHair: false,
			remainingItems: config.totalGearCount - config.colorCount - 1 // Exclude colors and skin type
		});

		// Reveal Legendary (if applicable)
		if (config.legendaryCount > 0) {
			selectedGear[selectedCount++] = _selectGearByRarity(GEARMetadata.Rarity.LEGENDARY, to, tokenId, nonce++, selectedGear, true, tracker);
		}

		// Reveal Epic or Rare
		for (uint256 i = 0; i < config.epicOrRareCount; i++) {
			selectedGear[selectedCount++] = _selectGearByRarity(
				_randomEpicRareRoll(tokenId, nonce++) ? GEARMetadata.Rarity.EPIC : GEARMetadata.Rarity.RARE,
				to,
				tokenId,
				nonce++,
				selectedGear,
				true,
				tracker
			);
		}

		// Reveal Uncommons
		for (uint256 i = 0; i < config.uncommonCount; i++) {
			selectedGear[selectedCount++] = _selectGearByRarity(GEARMetadata.Rarity.UNCOMMON, to, tokenId, nonce++, selectedGear, true, tracker);
		}

		// Reveal Commons
		for (uint256 i = 0; i < config.commonCount; i++) {
			selectedGear[selectedCount++] = _selectGearByRarity(GEARMetadata.Rarity.COMMON, to, tokenId, nonce++, selectedGear, true, tracker);
		}

		// Add skin type based on pack size
		selectedGear[selectedCount++] = _selectSkinType(cardSkin);

		// Add colors
		uint256[] memory selectedColors = _selectColors(cardSize, tokenId, nonce);
		for (uint256 i = 0; i < selectedColors.length; i++) {
			selectedGear[selectedCount++] = selectedColors[i];
		}

		// For all revealed gear, decrease the supply by 1, because it is now revealed and can be harvested
		// If a piece of gear is not selected in the harvest, it will be available for selection again
		for (uint256 i = 0; i < selectedGear.length; i++) {
			gearRemainingSupply[selectedGear[i]]--;
		}

		revealedGear[tokenId] = selectedGear;
		isRevealed[tokenId] = true;

		return selectedGear;
	}

	function _selectGearByRarity(
		GEARMetadata.Rarity rarity,
		address to,
		uint256 tokenId,
		uint256 nonce,
		uint256[] memory alreadyRevealedGear,
		bool excludeSpecialCategories,
		CategoryTracker memory tracker
	) internal view returns (uint256) {
		SelectionParams memory params = SelectionParams({
			rarity: rarity,
			to: to,
			tokenId: tokenId,
			nonce: nonce,
			alreadyRevealedGear: alreadyRevealedGear,
			excludeSpecialCategories: excludeSpecialCategories,
			tracker: tracker
		});

		return _performGearSelection(params);
	}

	function _performGearSelection(SelectionParams memory params) internal view returns (uint256) {
		uint256[] memory rarityTokens = gearContract.getRarityNFTAssetIds(params.rarity);
		require(rarityTokens.length > 0, "No tokens available for this rarity");

		uint256 maxAttempts = 1000; // Prevent infinite loops
		uint256 attempts = 0;

		// Check if we need to force a specific category
		string[] memory forcedCategories = _needsForcedCategories(params.tracker);
		bool needsForcedCategories = forcedCategories.length > 0;

		// Calculate total remaining supply for this rarity
		uint256 totalRemaining = 0;
		for (uint256 i = 0; i < rarityTokens.length; i++) {
			if (rarityTokens[i] != 0) {
				totalRemaining += gearRemainingSupply[rarityTokens[i]];
			}
		}
		require(totalRemaining > 0, "No remaining supply for this rarity");

		while (attempts < maxAttempts) {
			// Generate random number based on total remaining supply
			bytes32 randomHash = keccak256(abi.encodePacked(block.timestamp, block.prevrandao, params.to, params.tokenId, params.nonce, attempts));
			uint256 randomNum = uint256(randomHash) % totalRemaining;

			// Select gear based on weighted probabilities
			uint256 cumulative = 0;
			for (uint256 i = 0; i < rarityTokens.length; i++) {
				uint256 candidate = rarityTokens[i];
				if (candidate == 0) continue;

				cumulative += gearRemainingSupply[candidate];
				if (randomNum < cumulative) {
					ValidationParams memory validationParams = ValidationParams({
						candidate: candidate,
						alreadyRevealedGear: params.alreadyRevealedGear,
						needsForcedCategories: needsForcedCategories,
						forcedCategories: forcedCategories,
						excludeSpecialCategories: params.excludeSpecialCategories,
						tracker: params.tracker
					});

					if (_isValidCandidate(validationParams)) {
						return candidate;
					}

					break;
				}
			}

			attempts++;
		}

		revert("Could not find valid gear after maximum attempts");
	}

	function _isValidCandidate(ValidationParams memory params) internal view returns (bool) {
		// Check for duplicates
		for (uint256 i = 0; i < params.alreadyRevealedGear.length; i++) {
			if (params.candidate == params.alreadyRevealedGear[i]) {
				return false;
			}
		}

		string memory category = gearContract.getDrifterAssetCategory(params.candidate);

		// If we need a forced category, only accept matching items
		if (params.needsForcedCategories) {
			// Check if the candidate's category matches any in the forced categories
			if (_categoryMatches(category, params.forcedCategories)) {
				_updateCategoryTracker(params.tracker, category);
				return true;
			}
		} else {
			// Normal selection process
			if (!params.excludeSpecialCategories || !_isSpecialCategory(category)) {
				_updateCategoryTracker(params.tracker, category);
				return true;
			}
		}

		return false;
	}

	function _selectSkinType(uint8 cardSkin) internal view returns (uint256) {
		require(cardSkin > 0 && cardSkin <= 9, "Invalid token type");

		// Get all skin type tokens
		uint256[] memory skinTokens = gearContract.getCategoryNFTAssetIds("Skin Type");
		require(skinTokens.length > 0, "No skin types available");
		require(cardSkin <= skinTokens.length, "Token type exceeds available skin types");

		// Return the nth skin type where n is the token type (1-based index)
		return skinTokens[cardSkin - 1];
	}

	function _selectColors(DNACardLib.CardSize cardSize, uint256 tokenId, uint256 nonce) internal view returns (uint256[] memory) {
		uint256 colorCount = revealConfigs[cardSize].colorCount;
		uint256[] memory selectedColors = new uint256[](colorCount);

		// Get all available colors first
		uint256[] memory availableColors = gearContract.getCategoryNFTAssetIds("Color");
		require(availableColors.length > 0, "No colors available");

		// Create a shuffled index array based on the tokenId and nonce
		uint256[] memory indices = new uint256[](availableColors.length);
		for (uint256 i = 0; i < availableColors.length; i++) {
			indices[i] = i;
		}

		// Fisher-Yates shuffle
		for (uint256 i = availableColors.length - 1; i > 0; i--) {
			uint256 randomValue = uint256(keccak256(abi.encodePacked(tokenId, nonce, i)));
			uint256 j = randomValue % (i + 1);

			// Swap indices[i] and indices[j]
			uint256 temp = indices[i];
			indices[i] = indices[j];
			indices[j] = temp;
		}

		// Take the first colorCount items from the shuffled array
		for (uint256 i = 0; i < colorCount; i++) {
			selectedColors[i] = availableColors[indices[i]];
		}

		return selectedColors;
	}

	function _isSpecialCategory(string memory category) internal pure returns (bool) {
		return _isSkinType(category) || _isColor(category);
	}

	function _isSkinType(string memory category) internal pure returns (bool) {
		bytes32 categoryHash = keccak256(abi.encodePacked(category));
		bytes32 skinTypeHash = keccak256(abi.encodePacked("Skin Type"));
		return categoryHash == skinTypeHash;
	}

	function _isColor(string memory category) internal pure returns (bool) {
		bytes32 categoryHash = keccak256(abi.encodePacked(category));
		bytes32 colorHash = keccak256(abi.encodePacked("Color"));
		return categoryHash == colorHash;
	}

	function _updateCategoryTracker(CategoryTracker memory tracker, string memory category) internal pure {
		if (_categoryMatches(category, _getRequiredCategory(0))) {
			tracker.hasTopBodysuit = true;
		} else if (_categoryMatches(category, _getRequiredCategory(1))) {
			tracker.hasPantsSkirt = true;
		} else if (_categoryMatches(category, _getRequiredCategory(2))) {
			tracker.hasShoesBoots = true;
		} else if (_categoryMatches(category, _getRequiredCategory(3))) {
			tracker.hasHair = true;
		}

		if (tracker.remainingItems > 0) {
			tracker.remainingItems--;
		}
	}

	function _needsForcedCategories(CategoryTracker memory tracker) internal pure returns (string[] memory) {
		// Only force categories in the last N items
		uint256 FORCE_THRESHOLD = 4; // Adjust this value as needed
		if (tracker.remainingItems > FORCE_THRESHOLD) {
			return new string[](0);
		}

		// Check which categories are still missing
		// Return the first category in the array for the required category index
		if (!tracker.hasTopBodysuit) return _getRequiredCategory(0);
		if (!tracker.hasPantsSkirt) return _getRequiredCategory(1);
		if (!tracker.hasShoesBoots) return _getRequiredCategory(2);
		if (!tracker.hasHair) return _getRequiredCategory(3);

		return new string[](0);
	}

	function _randomEpicRareRoll(uint256 tokenId, uint256 nonce) internal pure returns (bool) {
		// 20% chance to return true (epic), 80% chance to return false (rare)
		return uint256(keccak256(abi.encodePacked(tokenId, nonce))) % 5 == 0;
	}

	// Split _autoSelectAndHarvestGear into multiple functions to avoid stack too deep
	function _autoSelectAndHarvestGear(address to, uint256 tokenId, DNACardLib.CardSize cardSize) internal returns (uint256[] memory) {
		(uint256[] memory selectedGear, uint256[] memory specialGear) = _selectGearForHarvest(tokenId, cardSize);
		return _performHarvest(to, tokenId, selectedGear, specialGear);
	}

	function _selectGearForHarvest(uint256 tokenId, DNACardLib.CardSize cardSize) private view returns (uint256[] memory, uint256[] memory) {
		HarvestConfig memory config = harvestConfigs[cardSize];
		uint256[] memory availableGear = revealedGear[tokenId];

		uint256[] memory selectedGear = new uint256[](config.totalHarvestCount);
		uint256[] memory specialGear = new uint256[](revealConfigs[cardSize].colorCount + 1);
		uint256 selectedCount;
		uint256 specialCount;

		// First pass: collect special gear and categorize non-special gear
		uint256[] memory legendaryGear = new uint256[](availableGear.length);
		uint256[] memory epicGear = new uint256[](availableGear.length);
		uint256[] memory rareGear = new uint256[](availableGear.length);
		uint256[] memory uncommonGear = new uint256[](availableGear.length);
		uint256[] memory commonGear = new uint256[](availableGear.length);

		GearCounts memory counts;

		for (uint256 i = 0; i < availableGear.length; i++) {
			uint256 gearId = availableGear[i];
			string memory category = gearContract.getDrifterAssetCategory(gearId);

			if (_isSpecialCategory(category)) {
				specialGear[specialCount++] = gearId;
				continue;
			}

			GEARMetadata.Rarity rarity = gearContract.getDrifterAssetRarity(gearId);
			if (rarity == GEARMetadata.Rarity.LEGENDARY) {
				legendaryGear[counts.legendaryCount++] = gearId;
			} else if (rarity == GEARMetadata.Rarity.EPIC) {
				epicGear[counts.epicCount++] = gearId;
			} else if (rarity == GEARMetadata.Rarity.RARE) {
				rareGear[counts.rareCount++] = gearId;
			} else if (rarity == GEARMetadata.Rarity.UNCOMMON) {
				uncommonGear[counts.uncommonCount++] = gearId;
			} else if (rarity == GEARMetadata.Rarity.COMMON) {
				commonGear[counts.commonCount++] = gearId;
			}
		}

		// Add legendaries first
		for (uint256 i = 0; i < config.legendaryCount && i < counts.legendaryCount; i++) {
			selectedGear[selectedCount++] = legendaryGear[i];
		}

		// Add epics first, then rares if needed
		uint256 epicRareNeeded = config.rareOrEpicCount;
		uint256 epicsTaken = 0;

		// Take epics first
		for (uint256 i = 0; i < counts.epicCount && epicRareNeeded > 0; i++) {
			selectedGear[selectedCount++] = epicGear[i];
			epicsTaken++;
			epicRareNeeded--;
		}

		// Only take rares if we still need more after epics
		if (epicRareNeeded > 0) {
			for (uint256 i = 0; i < counts.rareCount && epicRareNeeded > 0; i++) {
				selectedGear[selectedCount++] = rareGear[i];
				epicRareNeeded--;
			}
		}

		// Add uncommons
		for (uint256 i = 0; i < config.uncommonCount && i < counts.uncommonCount; i++) {
			selectedGear[selectedCount++] = uncommonGear[i];
		}

		// Add commons
		for (uint256 i = 0; i < config.commonCount && i < counts.commonCount; i++) {
			selectedGear[selectedCount++] = commonGear[i];
		}

		return (selectedGear, specialGear);
	}

	function _performHarvest(address to, uint256 tokenId, uint256[] memory selectedGear, uint256[] memory specialGear) private returns (uint256[] memory) {
		// Mint selected gear
		for (uint256 i = 0; i < selectedGear.length; i++) {
			if (selectedGear[i] != 0) {
				gearContract.mint(to, selectedGear[i], 1);
				if (gearRemainingSupply[selectedGear[i]] > 0) {
					gearRemainingSupply[selectedGear[i]]--;
				}
			}
		}

		// Mint special gear
		for (uint256 i = 0; i < specialGear.length; i++) {
			if (specialGear[i] != 0) {
				gearContract.mint(to, specialGear[i], 1);
			}
		}

		// Create combined array for event
		uint256 totalLength = selectedGear.length;
		for (uint256 i = 0; i < specialGear.length; i++) {
			if (specialGear[i] != 0) totalLength++;
		}

		uint256[] memory allGear = new uint256[](totalLength);
		uint256 index = 0;

		for (uint256 i = 0; i < selectedGear.length; i++) {
			if (selectedGear[i] != 0) {
				allGear[index++] = selectedGear[i];
			}
		}

		for (uint256 i = 0; i < specialGear.length; i++) {
			if (specialGear[i] != 0) {
				allGear[index++] = specialGear[i];
			}
		}

		isHarvested[tokenId] = true;

		return allGear;
	}

	function getRevealedGear(uint256 tokenId) external view returns (uint256[] memory) {
		require(isRevealed[tokenId], "DNA Card not revealed yet");
		return revealedGear[tokenId];
	}

	function getRemainingSelectionTime(uint256 tokenId) external view returns (uint256) {
		uint256 revealTime = revealTimestamps[tokenId];
		if (revealTime == 0) return 0;

		uint256 endTime = revealTime + SELECTION_TIME_LIMIT;
		if (block.timestamp >= endTime) return 0;

		return endTime - block.timestamp;
	}

	function _validateSelectedGear(
		uint256[] calldata selectedGearIds,
		uint256[] memory availableGear,
		HarvestConfig memory config
	) private view returns (uint256[] memory) {
		require(selectedGearIds.length == config.totalHarvestCount, "Invalid number of selected gear");

		uint256 selectedLegendary;
		uint256 selectedRareOrEpic;
		uint256 selectedUncommon;
		uint256 selectedCommon;

		// Verify all selected gear exists in revealed gear and count rarities
		for (uint256 i = 0; i < selectedGearIds.length; i++) {
			// Disallow choosing a special category as a gear
			require(!_isSpecialCategory(gearContract.getDrifterAssetCategory(selectedGearIds[i])), "Cannot choose a special category as a gear");

			bool found = false;
			for (uint256 j = 0; j < availableGear.length; j++) {
				if (selectedGearIds[i] == availableGear[j]) {
					found = true;
					GEARMetadata.Rarity rarity = gearContract.getDrifterAssetRarity(selectedGearIds[i]);
					if (rarity == GEARMetadata.Rarity.LEGENDARY) {
						selectedLegendary++;
					} else if (rarity == GEARMetadata.Rarity.EPIC || rarity == GEARMetadata.Rarity.RARE) {
						selectedRareOrEpic++;
					} else if (rarity == GEARMetadata.Rarity.UNCOMMON) {
						selectedUncommon++;
					} else if (rarity == GEARMetadata.Rarity.COMMON) {
						selectedCommon++;
					}
					break;
				}
			}
			require(found, "Selected gear not in revealed set");
		}

		// Verify rarity counts
		require(selectedLegendary == config.legendaryCount, "Invalid legendary count");
		require(selectedRareOrEpic == config.rareOrEpicCount, "Invalid rare/epic count");
		require(selectedUncommon == config.uncommonCount, "Invalid uncommon count");
		require(selectedCommon == config.commonCount, "Invalid common count");

		return selectedGearIds;
	}

	function _getSpecialGear(uint256[] memory availableGear, DNACardLib.CardSize cardSize) private view returns (uint256[] memory, uint256) {
		uint256[] memory specialGear = new uint256[](revealConfigs[cardSize].colorCount + 1);
		uint256 specialCount;

		for (uint256 i = 0; i < availableGear.length; i++) {
			string memory category = gearContract.getDrifterAssetCategory(availableGear[i]);
			if (_isSpecialCategory(category)) {
				specialGear[specialCount++] = availableGear[i];
			}
		}

		return (specialGear, specialCount);
	}

	function _mintSelectedGear(
		address to,
		uint256[] memory selectedGear,
		uint256[] memory specialGear,
		uint256 specialCount
	) private returns (uint256[] memory) {
		uint256 totalGear = selectedGear.length + specialCount;
		for (uint256 i = 0; i < selectedGear.length; i++) {
			gearContract.mint(to, selectedGear[i], 1);
			if (gearRemainingSupply[selectedGear[i]] > 0) {
				gearRemainingSupply[selectedGear[i]]--;
			}
		}
		for (uint256 i = 0; i < specialCount; i++) {
			gearContract.mint(to, specialGear[i], 1);
		}

		// Create array for event emission
		uint256[] memory allGear = new uint256[](totalGear);
		for (uint256 i = 0; i < selectedGear.length; i++) {
			allGear[i] = selectedGear[i];
		}
		for (uint256 i = 0; i < specialCount; i++) {
			allGear[selectedGear.length + i] = specialGear[i];
		}

		return allGear;
	}

	function harvestReveal(
		address to,
		uint256 tokenId,
		DNACardLib.CardSize cardSize,
		uint256[] calldata selectedGearIds
	) public onlyDnaCard returns (uint256[] memory) {
		require(address(gearContract) != address(0), "Gear contract not set");
		require(isRevealed[tokenId], "DNA Card not revealed yet");
		require(!isHarvested[tokenId], "DNA Card already harvested");

		uint256 revealTime = revealTimestamps[tokenId];
		require(revealTime > 0, "Invalid reveal timestamp");

		uint256[] memory availableGear = revealedGear[tokenId];

		// For all revealed gear, increase the supply by 1
		// This is because unselected gear should be available for selection again, and the supply will be reduced by 1 if it is selected
		for (uint256 i = 0; i < availableGear.length; i++) {
			gearRemainingSupply[availableGear[i]]++;
		}

		// If time limit has expired, auto-select gear
		if (block.timestamp > revealTime + SELECTION_TIME_LIMIT + SELECTION_TIME_LIMIT_BUFFER) {
			return _autoSelectAndHarvestGear(to, tokenId, cardSize);
		}

		HarvestConfig memory config = harvestConfigs[cardSize];
		require(availableGear.length > 0, "No revealed gear found");

		// Validate selected gear
		uint256[] memory validatedGear = _validateSelectedGear(selectedGearIds, availableGear, config);

		// Get special gear (skin type and colors)
		(uint256[] memory specialGear, uint256 specialCount) = _getSpecialGear(availableGear, cardSize);

		// Mint all gear and emit event
		uint256[] memory allGear = _mintSelectedGear(to, validatedGear, specialGear, specialCount);

		// Mark as harvested
		isHarvested[tokenId] = true;

		return allGear;
	}

	function _getRequiredCategory(uint256 index) internal pure returns (string[] memory) {
		string[] memory categories;

		if (index == 0) {
			categories = new string[](6);
			categories[0] = "Tops/Bodysuits";
			categories[1] = "Bras";
			categories[2] = "Jackets & Coats";
			categories[3] = "Vests";
			categories[4] = "Dresses";
			categories[5] = "Jumpsuits";
		} else if (index == 1) {
			categories = new string[](5);
			categories[0] = "Leggings";
			categories[1] = "Leggings/Tights";
			categories[2] = "Pants/Shorts";
			categories[3] = "Skirts";
			categories[4] = "Tights";
		} else if (index == 2) {
			categories = new string[](7);
			categories[0] = "Boots";
			categories[1] = "Flats";
			categories[2] = "Heels";
			categories[3] = "Sandals";
			categories[4] = "Slippers";
			categories[5] = "Sneakers";
			categories[6] = "Formal";
		} else if (index == 3) {
			categories = new string[](5);
			categories[0] = "Hair";
			categories[1] = "Hats";
			categories[2] = "Head Hovers";
			categories[3] = "Headbands";
			categories[4] = "Helmets";
		} else {
			revert("Invalid category index");
		}

		return categories;
	}

	// Helper to check if a category matches any in the list
	function _categoryMatches(string memory category, string[] memory categories) internal pure returns (bool) {
		for (uint256 i = 0; i < categories.length; i++) {
			if (_compareStrings(category, categories[i])) {
				return true;
			}
		}
		return false;
	}

	function _compareStrings(string memory a, string memory b) internal pure returns (bool) {
		return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
	}

	// Reject direct ETH transfers
	receive() external payable {
		revert("Direct ETH transfers not allowed");
	}
}

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

import "@limitbreak/creator-token-standards/src/erc721c/ERC721C.sol";
import "@limitbreak/creator-token-standards/src/access/OwnableBasic.sol";
import "@limitbreak/creator-token-standards/src/programmable-royalties/BasicRoyalties.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

import "./GEAR.sol";
import "./BioCanvas.sol";
import "./DrifterName.sol";
import "./DrifterEquip.sol";

contract Drifter is ERC721C, DrifterName, DrifterEquip, BasicRoyalties, OwnableBasic {
	using Address for address;
	using Strings for uint256;

	uint96 public constant ROYALTY_FEE_NUMERATOR = 500; // 5% royalty

	uint256 public latestTokenId = 0;
	uint256 public totalSupply = 0;

	string public baseURI = "https://m.cyberbrokers.com/base/drifter/";

	BioCanvas public bioCanvasContract;

	mapping(uint256 => uint256) public drifterAttributeCount;
	mapping(uint256 => string[]) public drifterAttributeKeys;
	mapping(uint256 => uint256[]) public drifterAttributeValues;

	// Mapping to track Drifter name payment promo codes using hashed values
	mapping(bytes32 => bool) public promoCodesUsed;
	mapping(bytes32 => bool) public validPromoCodes;

	event DrifterCreated(
		uint256 indexed drifterId,
		uint256 bioCanvasId,
		uint256[] assetIds,
		uint256[] assetColors,
		string[] attributeKeys,
		uint256[] attributeValues,
		string name
	);

	event DrifterEdited(uint256 indexed drifterId, uint256[] assetIds, uint256[] assetColors, string[] attributeKeys, uint256[] attributeValues, string name);

	modifier onlyBioCanvas() {
		require(msg.sender == address(bioCanvasContract), "Caller is not the bio canvas contract");
		_;
	}

	modifier onlyTokenOwner(uint256 tokenId) {
		require(_isApprovedOrOwner(msg.sender, tokenId), "Caller is not owner nor approved");
		_;
	}

	constructor(
		string memory name_,
		string memory symbol_,
		address payable bioCanvasAddress_,
		address payable gearAddress_,
		address payable royaltyReceiver_
	) ERC721OpenZeppelin(name_, symbol_) DrifterName() DrifterEquip(gearAddress_) BasicRoyalties(royaltyReceiver_, ROYALTY_FEE_NUMERATOR) {
		bioCanvasContract = BioCanvas(bioCanvasAddress_);
	}

	function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721C, ERC1155Receiver, ERC2981) returns (bool) {
		return super.supportsInterface(interfaceId);
	}

	/**
	 * @dev Creates a new Drifter from a BioCanvas and optionally equips GEAR
	 * @param bioCanvasId The ID of the BioCanvas token to convert
	 * @param assetIds Array of GEAR token IDs to equip (can be empty)
	 * @param assetColors Array of color indexes to update
	 * @param namePlacement The placement index for name generation
	 * @param expectedName The expected name to be generated
	 * @param _attributeKeys The keys of the attributes to update
	 * @param _attributeValues The values of the attributes to update
	 * @return The ID of the newly created Drifter
	 */
	function createDrifter(
		uint256 bioCanvasId,
		uint256[] calldata assetIds,
		uint256[] calldata assetColors,
		string[] calldata _attributeKeys,
		uint256[] calldata _attributeValues,
		uint256 namePlacement,
		string calldata expectedName,
		string calldata promoCode
	) external payable returns (uint256) {
		// Verify caller owns the BioCanvas
		require(bioCanvasContract.balanceOf(_msgSender(), bioCanvasId) > 0, "Caller does not own the BioCanvas");

		// Convert BioCanvas to Drifter
		require(bioCanvasContract.convertToDrifter(bioCanvasId, 1, _msgSender()), "Failed to convert BioCanvas to Drifter");

		// Mint the Drifter
		uint256 drifterId = mint(_msgSender());

		// Confirm the name rolled or set a custom name
		if (namePlacement < 2 ** 255) {
			_confirmRolledName(drifterId, namePlacement, expectedName, _msgSender());
		} else {
			string memory paymentMethod = msg.value > 0 ? "ETH" : "USDC";
			setDrifterName(drifterId, expectedName, promoCode, paymentMethod);
		}

		// If GEAR was provided, store it as equipped
		if (assetIds.length > 0) {
			_equipGear(drifterId, assetIds, _msgSender());
		}

		if (assetColors.length > 0) {
			_updateDrifterColors(drifterId, assetColors);
		}

		drifterAttributeCount[drifterId] = _attributeKeys.length;
		drifterAttributeKeys[drifterId] = _attributeKeys;
		drifterAttributeValues[drifterId] = _attributeValues;

		emit DrifterCreated(drifterId, bioCanvasId, assetIds, assetColors, _attributeKeys, _attributeValues, expectedName);
		return drifterId;
	}

	/**
	 * @dev Edits the equipped GEAR for an existing Drifter
	 * @param drifterId The ID of the Drifter to edit
	 * @param assetIds Array of GEAR token IDs to equip (can be empty to unequip all)
	 * @param assetColors Array of color indexes to update
	 * @param _attributeKeys The keys of the attributes to update
	 * @param _attributeValues The values of the attributes to update
	 */
	function editDrifterGear(
		uint256 drifterId,
		uint256[] calldata assetIds,
		uint256[] calldata assetColors,
		string[] calldata _attributeKeys,
		uint256[] calldata _attributeValues
	) external onlyTokenOwner(drifterId) {
		// Update equipped GEAR
		_equipGear(drifterId, assetIds, msg.sender);

		if (assetColors.length > 0) {
			_updateDrifterColors(drifterId, assetColors);
		}

		// Gender is set within the gear management UI, separate from the other attributes
		_updateDrifterAttributes(drifterId, _attributeKeys, _attributeValues);

		emit DrifterEdited(drifterId, assetIds, assetColors, drifterAttributeKeys[drifterId], drifterAttributeValues[drifterId], drifterNames[drifterId]);
	}

	function editDrifterAttributes(
		uint256 drifterId,
		string[] calldata _attributeKeys,
		uint256[] calldata _attributeValues
	) external onlyTokenOwner(drifterId) {
		_updateDrifterAttributes(drifterId, _attributeKeys, _attributeValues);

		emit DrifterEdited(
			drifterId,
			equippedGear[drifterId],
			equippedGearColors[drifterId],
			drifterAttributeKeys[drifterId],
			drifterAttributeValues[drifterId],
			drifterNames[drifterId]
		);
	}

	function _updateDrifterAttributes(uint256 drifterId, string[] calldata _attributeKeys, uint256[] calldata _attributeValues) internal {
		// For each provided key, see if the key exists in the drifterAttributeKeys array
		// If it does, update the value at the corresponding index in the drifterAttributeValues array
		// If it doesn't, add the key and value to the arrays
		for (uint256 i = 0; i < _attributeKeys.length; i++) {
			string memory key = _attributeKeys[i];
			uint256 value = _attributeValues[i];

			bool found = false;
			for (uint256 j = 0; j < drifterAttributeKeys[drifterId].length; j++) {
				if (keccak256(abi.encodePacked(drifterAttributeKeys[drifterId][j])) == keccak256(abi.encodePacked(key))) {
					drifterAttributeValues[drifterId][j] = value;
					found = true;
					break;
				}
			}

			if (!found) {
				drifterAttributeCount[drifterId]++;
				drifterAttributeKeys[drifterId].push(key);
				drifterAttributeValues[drifterId].push(value);
			}
		}
	}

	/**
	 * @dev Wrapper function to confirm a rolled name for a Drifter
	 * @param drifterId The ID of the Drifter
	 * @param placement The placement index for name generation
	 * @param expectedName The expected generated name
	 */
	function confirmDrifterName(uint256 drifterId, uint256 placement, string calldata expectedName) external onlyTokenOwner(drifterId) {
		_confirmRolledName(drifterId, placement, expectedName, _msgSender());
	}

	/**
	 * @dev Wrapper function to create a custom name for a Drifter
	 * @param drifterId The ID of the Drifter
	 * @param name The custom name to set
	 */
	function setDrifterName(
		uint256 drifterId,
		string calldata name,
		string calldata promoCode,
		string memory paymentMethod
	) public payable onlyTokenOwner(drifterId) {
		if (bytes(promoCode).length == 0) {
			if (keccak256(bytes(paymentMethod)) == keccak256(bytes("ETH"))) {
				require(msg.value >= getNameCreationCost(name, paymentMethod), "Insufficient payment");
			} else if (keccak256(bytes(paymentMethod)) == keccak256(bytes("USDC"))) {
				uint256 price = getNameCreationCost(name, paymentMethod);
				require(usdcContract.balanceOf(msg.sender) >= price, "Insufficient USDC balance");
				require(usdcContract.allowance(msg.sender, address(this)) >= price, "Insufficient USDC allowance");
				require(usdcContract.transferFrom(msg.sender, address(this), price), "USDC transfer failed");
			}
		} else {
			require(isValidUnusedPromoCode(promoCode), "Invalid or used promo code");
			bytes32 promoCodeHash = keccak256(abi.encodePacked(promoCode));
			promoCodesUsed[promoCodeHash] = true;
		}

		_createName(drifterId, name);
	}

	function mint(address to) internal returns (uint256) {
		_mint(to, ++latestTokenId);
		totalSupply++;
		return latestTokenId;
	}

	function setBaseURI(string memory newBaseURI) external onlyOwner {
		baseURI = newBaseURI;
	}

	function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
		require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
		return string(abi.encodePacked(baseURI, tokenId.toString()));
	}

	// Admin functions to manage promo codes using pre-hashed values
	function addPromoCodeHash(bytes32 promoCodeHash) external onlyOwner {
		require(promoCodeHash != 0, "Promo code hash cannot be zero");
		validPromoCodes[promoCodeHash] = true;
	}

	function removePromoCodeHash(bytes32 promoCodeHash) external onlyOwner {
		validPromoCodes[promoCodeHash] = false;
	}

	function isValidUnusedPromoCode(string memory promoCode) public view returns (bool) {
		if (bytes(promoCode).length == 0) return false;
		bytes32 promoCodeHash = keccak256(abi.encodePacked(promoCode));
		return validPromoCodes[promoCodeHash] && !promoCodesUsed[promoCodeHash];
	}

	function setDrifterNamePrices(uint64[] memory ethPrices, uint64[] memory usdcPrices) external onlyOwner {
		_setDrifterNamePrices(ethPrices, usdcPrices);
	}

	// DrifterName admin functions exposed through Drifter with onlyOwner access control
	function addNames(string[] memory newNames) external onlyOwner {
		_addNames(newNames);
	}

	function addDisallowedNames(string[] memory newNames) external onlyOwner {
		_addDisallowedNames(newNames);
	}

	function addRestrictedWords(string[] memory words) external onlyOwner {
		_addRestrictedWords(words);
	}

	function withdraw() external onlyOwner {
		payable(owner()).transfer(address(this).balance);
	}

	function withdrawUsdc() external onlyOwner {
		usdcContract.transfer(owner(), usdcContract.balanceOf(address(this)));
	}

	function setUsdcAddress(address _newUsdcAddress) external onlyOwner {
		usdcContract = IERC20(_newUsdcAddress);
	}

	function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
		_setDefaultRoyalty(receiver, feeNumerator);
	}

	function setTokenRoyalty(address receiver, uint256 tokenId, uint96 feeNumerator) external onlyOwner {
		_setTokenRoyalty(tokenId, receiver, feeNumerator);
	}

	/**
	 * @dev Admin function to set any name for a Drifter, bypassing restrictions
	 * @param drifterId The ID of the Drifter
	 * @param name The name to set
	 */
	function adminSetDrifterName(uint256 drifterId, string calldata name) external onlyOwner {
		require(_exists(drifterId), "ERC721: operator query for nonexistent token");
		require(!usedNames[name], "Name already in use");

		_setName(drifterId, name);
	}

	// Reject direct ETH transfers
	receive() external payable {
		revert("Direct ETH transfers not allowed");
	}
}

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

import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "./GEAR.sol";

abstract contract DrifterEquip is ERC1155Holder {
	GEAR public gearContract;

	// Mapping to track equipped GEAR for each Drifter
	mapping(uint256 => uint256[]) public equippedGear;
	mapping(uint256 => uint256[]) public equippedGearColors;

	constructor(address payable gearAddress_) {
		gearContract = GEAR(gearAddress_);
	}

	/**
	 * @dev Gets all equipped GEAR for a Drifter
	 * @param drifterId The ID of the Drifter
	 * @return Array of equipped GEAR token IDs
	 */
	function getEquippedGear(uint256 drifterId) external view returns (uint256[] memory) {
		return equippedGear[drifterId];
	}

	function getEquippedGearColors(uint256 drifterId) external view returns (uint256[] memory) {
		return equippedGearColors[drifterId];
	}

	/**
	 * @dev Internal function to validate color assignments for a Drifter's gear
	 * @param drifterId The ID of the Drifter
	 * @param colorIndexes Array of color indexes
	 */
	function _updateDrifterColors(uint256 drifterId, uint256[] calldata colorIndexes) internal {
		// Require that the colorIndexes array is the same length as the equippedGear array
		uint256[] memory currentGear = equippedGear[drifterId];
		require(colorIndexes.length == currentGear.length, "Color indexes array must be the same length as equipped gear array");

		// Need to verify that all colors are valid color types
		for (uint256 i = 0; i < colorIndexes.length; i++) {
			uint256 colorIndex = colorIndexes[i];

			// If this color index is 0, then it's a default color and we don't need to verify it
			if (colorIndex == 0) continue;

			// Verify it's a Color category
			string memory category = gearContract.getDrifterAssetCategory(colorIndex);
			require(keccak256(abi.encodePacked(category)) == keccak256(abi.encodePacked("Color")), "Asset must be of category Color");

			// Need to verify that all provided colors are included in the equippedGear array
			bool colorFound = false;
			for (uint256 j = 0; j < currentGear.length; j++) {
				if (currentGear[j] == colorIndex) {
					colorFound = true;
					break;
				}
			}
			require(colorFound, "Color Asset not equipped on Drifter");
		}

		// All checks passed, update the equipped gear colors
		equippedGearColors[drifterId] = colorIndexes;
	}

	/**
	 * @dev Internal function to equip GEAR to a Drifter
	 * @param drifterId The ID of the Drifter
	 * @param gearIds Array of GEAR token IDs to equip
	 * @param owner The owner of the Drifter and GEAR
	 */
	function _equipGear(uint256 drifterId, uint256[] calldata gearIds, address owner) internal {
		uint256[] memory oldGearIds = equippedGear[drifterId];

		// Unequip GEAR that isn't in the new configuration
		if (oldGearIds.length > 0) {
			for (uint256 i = 0; i < oldGearIds.length; i++) {
				// Skip Non-NFT gear
				if (gearContract.isNonNFT(oldGearIds[i])) continue;

				bool keepGear = false;
				for (uint256 j = 0; j < gearIds.length; j++) {
					if (oldGearIds[i] == gearIds[j]) {
						keepGear = true;
						break;
					}
				}
				if (!keepGear) {
					gearContract.safeTransferFrom(address(this), owner, oldGearIds[i], 1, "");
				}
			}
		}

		// Verify and transfer only new GEAR tokens
		if (gearIds.length > 0) {
			string[] memory usedCategories = new string[](gearIds.length);
			uint256 categoryCount = 0;

			for (uint256 i = 0; i < gearIds.length; i++) {
				bool isAlreadyEquipped = false;
				for (uint256 j = 0; j < oldGearIds.length; j++) {
					if (gearIds[i] == oldGearIds[j]) {
						isAlreadyEquipped = true;

						string memory category = gearContract.getDrifterAssetCategory(gearIds[i]);
						if (keccak256(abi.encodePacked(category)) != keccak256(abi.encodePacked("Color"))) {
							bool categoryExists = false;
							for (uint256 k = 0; k < categoryCount; k++) {
								if (keccak256(abi.encodePacked(usedCategories[k])) == keccak256(abi.encodePacked(category))) {
									categoryExists = true;
									break;
								}
							}
							if (!categoryExists) {
								usedCategories[categoryCount++] = category;
							}
						}
						break;
					}
				}

				if (!isAlreadyEquipped) {
					if (!gearContract.isNonNFT(gearIds[i])) {
						require(gearContract.balanceOf(owner, gearIds[i]) > 0, "Owner does not own all specified GEAR");
						gearContract.safeTransferFrom(owner, address(this), gearIds[i], 1, "");
					}

					string memory category = gearContract.getDrifterAssetCategory(gearIds[i]);

					// Allow multiple "Color" items but require unique categories for everything else
					if (keccak256(abi.encodePacked(category)) != keccak256(abi.encodePacked("Color"))) {
						bool categoryExists = false;
						for (uint256 k = 0; k < categoryCount; k++) {
							if (keccak256(abi.encodePacked(usedCategories[k])) == keccak256(abi.encodePacked(category))) {
								categoryExists = true;
								break;
							}
						}
						require(!categoryExists, "Duplicate category not allowed");
						usedCategories[categoryCount++] = category;
					}
				}
			}
		}

		equippedGear[drifterId] = gearIds;
	}
}

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

import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

abstract contract DrifterName {
	using Strings for uint256;

	// Single array to store all name components
	string[] public names;

	// Mapping for disallowed names and array for restricted words
	mapping(string => bool) public disallowedNames;
	string[] public restrictedWords;

	// Mapping to track used names
	mapping(string => bool) public usedNames;

	// Mapping to track drifter names
	mapping(uint256 => string) public drifterNames;

	// Drifter name prices
	uint64[5] public drifterNamePricesETH = [0.25 ether, 0.1 ether, 0.05 ether, 0.02 ether, 0.005 ether];
	uint64[5] public drifterNamePricesUSDC = [575_000_000, 230_000_000, 115_000_000, 46_000_000, 11_500_000];

	// USDC contract
	IERC20 public usdcContract;

	event NameSet(uint256 indexed tokenId, string name);

	function _setDrifterNamePrices(uint64[] memory ethPrices, uint64[] memory usdcPrices) internal {
		require(ethPrices.length == 5, "Invalid number of ETH prices");
		require(usdcPrices.length == 5, "Invalid number of USDC prices");

		// Check prices are greater than 0
		for (uint256 i = 0; i < 5; i++) {
			require(ethPrices[i] > 0, "Invalid ETH price");
			require(usdcPrices[i] > 0, "Invalid USDC price");
		}

		drifterNamePricesETH[0] = ethPrices[0];
		drifterNamePricesETH[1] = ethPrices[1];
		drifterNamePricesETH[2] = ethPrices[2];
		drifterNamePricesETH[3] = ethPrices[3];
		drifterNamePricesETH[4] = ethPrices[4];

		drifterNamePricesUSDC[0] = usdcPrices[0];
		drifterNamePricesUSDC[1] = usdcPrices[1];
		drifterNamePricesUSDC[2] = usdcPrices[2];
		drifterNamePricesUSDC[3] = usdcPrices[3];
		drifterNamePricesUSDC[4] = usdcPrices[4];
	}

	// Function to calculate name creation cost based on length
	function getNameCreationCost(string memory name, string memory paymentMethod) public view returns (uint256) {
		uint256 length = bytes(name).length;

		// Max length is 32 characters
		require(length <= 32, "Name too long");

		// Make sure name isn't already taken
		require(!usedNames[name], "Name already in use");

		// Check for restricted words
		bytes memory nameBytes = bytes(name);
		for (uint i = 0; i < restrictedWords.length; i++) {
			bytes memory restrictedWord = bytes(restrictedWords[i]);
			if (_contains(nameBytes, restrictedWord)) {
				revert("Name contains restricted word");
			}
		}

		// Check for disallowed names
		require(!disallowedNames[name], "Name is disallowed");

		if (keccak256(bytes(paymentMethod)) == keccak256(bytes("ETH"))) {
			if (length <= 3) return drifterNamePricesETH[0];
			if (length == 4) return drifterNamePricesETH[1];
			if (length == 5) return drifterNamePricesETH[2];
			if (length == 6) return drifterNamePricesETH[3];
			return drifterNamePricesETH[4]; // 7 or more characters
		} else if (keccak256(bytes(paymentMethod)) == keccak256(bytes("USDC"))) {
			if (length <= 3) return drifterNamePricesUSDC[0];
			if (length == 4) return drifterNamePricesUSDC[1];
			if (length == 5) return drifterNamePricesUSDC[2];
			if (length == 6) return drifterNamePricesUSDC[3];
			return drifterNamePricesUSDC[4]; // 7 or more characters
		} else {
			revert("Invalid payment method");
		}
	}

	// Admin functions to populate arrays
	function _addNames(string[] memory newNames) internal {
		for (uint256 i = 0; i < newNames.length; i++) {
			if (bytes(newNames[i]).length > 0) {
				names.push(newNames[i]);
			}
		}
	}

	function _addDisallowedNames(string[] memory newNames) internal {
		for (uint256 i = 0; i < newNames.length; i++) {
			if (bytes(newNames[i]).length > 0) {
				disallowedNames[newNames[i]] = true;
			}
		}
	}

	function _addRestrictedWords(string[] memory words) internal {
		for (uint256 i = 0; i < words.length; i++) {
			if (bytes(words[i]).length > 0) {
				restrictedWords.push(words[i]);
			}
		}
	}

	// Public function to generate a random name based on address and placement
	function rollName(address sender, uint256 placement) public view returns (string memory) {
		return _rollName(sender, placement);
	}

	// View function to generate a random name based on address and placement
	function _rollName(address rollSender, uint256 placement) internal view returns (string memory) {
		require(names.length > 0, "Name list not initialized");

		// Cap the number of placements to 10,000, just roll over back to 0 if exceeded
		placement = placement % 10000;

		string memory generatedName;
		uint256 seed = uint256(keccak256(abi.encodePacked(rollSender, placement, "seed")));
		do {
			// Generate first index
			uint256 firstIndex = uint256(keccak256(abi.encodePacked(rollSender, placement, "first", seed))) % names.length;

			// Generate second index and re-roll if it matches first
			seed = uint256(keccak256(abi.encodePacked(rollSender, placement, "second", seed)));
			uint256 secondIndex = seed % names.length;
			while (secondIndex == firstIndex) {
				seed = uint256(keccak256(abi.encodePacked(seed)));
				secondIndex = seed % names.length;
			}

			// Determine if we should use three names (25% chance)
			uint256 useThreeNames = uint256(keccak256(abi.encodePacked(rollSender, placement, "length", seed))) % 4;

			if (useThreeNames == 0) {
				// 25% chance for three names
				// Generate third index and re-roll if it matches first or second
				seed = uint256(keccak256(abi.encodePacked(rollSender, placement, "third", seed)));
				uint256 thirdIndex = seed % names.length;
				while (thirdIndex == firstIndex || thirdIndex == secondIndex) {
					seed = uint256(keccak256(abi.encodePacked(seed)));
					thirdIndex = seed % names.length;
				}

				generatedName = string(abi.encodePacked(names[firstIndex], " ", names[secondIndex], " ", names[thirdIndex]));
			} else {
				// 75% chance for two names
				generatedName = string(abi.encodePacked(names[firstIndex], " ", names[secondIndex]));
			}

			seed = uint256(keccak256(abi.encodePacked(seed)));
		} while (usedNames[generatedName]);

		return generatedName;
	}

	// Internal function to validate name characters
	function _isValidNameFormat(string memory name) internal pure returns (bool) {
		bytes memory nameBytes = bytes(name);
		uint256 length = nameBytes.length;

		// Check for leading/trailing spaces
		if (nameBytes[0] == 0x20 || nameBytes[length - 1] == 0x20) {
			return false;
		}

		// Track consecutive spaces
		bool lastWasSpace = false;

		for (uint256 i = 0; i < length; i++) {
			bytes1 char = nameBytes[i];

			// Check for consecutive spaces
			if (char == 0x20) {
				if (lastWasSpace) {
					return false;
				}
				lastWasSpace = true;
				continue;
			}
			lastWasSpace = false;

			// Allow a-z
			if (char >= 0x61 && char <= 0x7A) {
				continue;
			}
			// Allow A-Z
			if (char >= 0x41 && char <= 0x5A) {
				continue;
			}
			// Allow 0-9
			if (char >= 0x30 && char <= 0x39) {
				continue;
			}
			// Allow hyphen
			if (char == 0x2D) {
				continue;
			}
			// Allow underscore
			if (char == 0x5F) {
				continue;
			}
			// Allow apostrophe
			if (char == 0x27) {
				continue;
			}
			// If we get here, we found an invalid character
			return false;
		}
		return true;
	}

	// Internal function to confirm a rolled name
	function _confirmRolledName(uint256 tokenId, uint256 placement, string memory expectedName, address rollSender) internal {
		require(bytes(drifterNames[tokenId]).length == 0, "Name already set for this token");

		string memory generatedName = _rollName(rollSender, placement);
		require(keccak256(abi.encodePacked(generatedName)) == keccak256(abi.encodePacked(expectedName)), "Generated name does not match expected name");

		require(!_isNameInvalid(expectedName), "Invalid name");
		require(!usedNames[expectedName], "Name already in use");

		_setName(tokenId, expectedName);
	}

	// Internal function to create a custom name
	function _createName(uint256 tokenId, string memory name) internal {
		require(_isValidNameFormat(name), "Invalid name format");
		require(!_isNameInvalid(name), "Invalid name");
		require(!usedNames[name], "Name already in use");
		require(bytes(name).length <= 32, "Name too long");

		_setName(tokenId, name);
	}

	// Internal function to check if a name is invalid
	function _isNameInvalid(string memory name) internal view returns (bool) {
		// Check against disallowed names
		if (disallowedNames[name]) {
			return true;
		}

		// Check for restricted words
		bytes memory nameBytes = bytes(name);
		for (uint i = 0; i < restrictedWords.length; i++) {
			bytes memory restrictedWord = bytes(restrictedWords[i]);
			if (_contains(nameBytes, restrictedWord)) {
				return true;
			}
		}

		return false;
	}

	// Helper function for case-insensitive character comparison
	function _toLower(bytes1 char) internal pure returns (bytes1) {
		// Convert uppercase A-Z to lowercase a-z
		if (char >= 0x41 && char <= 0x5A) {
			return bytes1(uint8(char) + 32);
		}
		return char;
	}

	// Internal function to check if a string contains another string (case-insensitive)
	function _contains(bytes memory what, bytes memory where) internal pure returns (bool) {
		if (where.length == 0 || what.length < where.length) {
			return false;
		}

		for (uint256 i = 0; i <= what.length - where.length; i++) {
			bool found = true;
			for (uint256 j = 0; j < where.length; j++) {
				if (_toLower(what[i + j]) != _toLower(where[j])) {
					found = false;
					break;
				}
			}
			if (found) {
				return true;
			}
		}
		return false;
	}

	// Internal function to set a name
	function _setName(uint256 tokenId, string memory name) internal {
		// If this Drifter already has a name, unset that name
		if (bytes(drifterNames[tokenId]).length > 0) {
			usedNames[drifterNames[tokenId]] = false;
		}

		drifterNames[tokenId] = name;
		usedNames[name] = true;
		emit NameSet(tokenId, name);
	}

	// View function to get a drifter's name
	function getName(uint256 tokenId) external view returns (string memory) {
		string memory name = drifterNames[tokenId];
		require(bytes(name).length > 0, "No name set for this token");
		return name;
	}
}

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

pragma solidity ^0.8.0;

import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

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

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

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

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

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

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

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

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

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

        return batchBalances;
    }

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

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

        address operator = _msgSender();

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

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

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

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

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

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

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

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

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

        return array;
    }
}

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

import "../utils/AutomaticValidatorTransferApproval.sol";
import "../utils/CreatorTokenBase.sol";
import "../token/erc1155/ERC1155OpenZeppelin.sol";
import {TOKEN_TYPE_ERC1155} from "@limitbreak/permit-c/src/Constants.sol";

/**
 * @title ERC1155C
 * @author Limit Break, Inc.
 * @notice Extends OpenZeppelin's ERC1155 implementation with Creator Token functionality, which
 *         allows the contract owner to update the transfer validation logic by managing a security policy in
 *         an external transfer validation security policy registry.  See {CreatorTokenTransferValidator}.
 */
abstract contract ERC1155C is ERC1155OpenZeppelin, CreatorTokenBase, AutomaticValidatorTransferApproval {
    
    /**
     * @notice Overrides behavior of isApprovedFor all such that if an operator is not explicitly approved
     *         for all, the contract owner can optionally auto-approve the 721-C transfer validator for transfers.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool isApproved) {
        isApproved = super.isApprovedForAll(owner, operator);

        if (!isApproved) {
            if (autoApproveTransfersFromValidator) {
                isApproved = operator == address(getTransferValidator());
            }
        }
    }

    /**
     * @notice Indicates whether the contract implements the specified interface.
     * @dev Overrides supportsInterface in ERC165.
     * @param interfaceId The interface id
     * @return true if the contract implements the specified interface, false otherwise
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return 
        interfaceId == type(ICreatorToken).interfaceId || 
        interfaceId == type(ICreatorTokenLegacy).interfaceId || 
        super.supportsInterface(interfaceId);
    }

    /**
     * @notice Returns the function selector for the transfer validator's validation function to be called 
     * @notice for transaction simulation. 
     */
    function getTransferValidationFunction() external pure returns (bytes4 functionSignature, bool isViewFunction) {
        functionSignature = bytes4(keccak256("validateTransfer(address,address,address,uint256,uint256)"));
        isViewFunction = false;
    }

    /// @dev Ties the open-zeppelin _beforeTokenTransfer hook to more granular transfer validation logic
    function _beforeTokenTransfer(
        address /*operator*/,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory /*data*/
    ) internal virtual override {
        uint256 idsArrayLength = ids.length;
        for (uint256 i = 0; i < idsArrayLength;) {
            _validateBeforeTransfer(from, to, ids[i], amounts[i]);

            unchecked {
                ++i;
            }
        }
    }

    /// @dev Ties the open-zeppelin _afterTokenTransfer hook to more granular transfer validation logic
    function _afterTokenTransfer(
        address /*operator*/,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory /*data*/
    ) internal virtual override {
        uint256 idsArrayLength = ids.length;
        for (uint256 i = 0; i < idsArrayLength;) {
            _validateAfterTransfer(from, to, ids[i], amounts[i]);

            unchecked {
                ++i;
            }
        }
    }

    function _tokenType() internal pure override returns(uint16) {
        return uint16(TOKEN_TYPE_ERC1155);
    }
}

/**
 * @title ERC1155CInitializable
 * @author Limit Break, Inc.
 * @notice Initializable implementation of ERC1155C to allow for EIP-1167 proxy clones.
 */
abstract contract ERC1155CInitializable is ERC1155OpenZeppelinInitializable, CreatorTokenBase, AutomaticValidatorTransferApproval {

    function initializeERC1155(string memory uri_) public override {
        super.initializeERC1155(uri_);

        _emitDefaultTransferValidator();
        _registerTokenType(getTransferValidator());
    }

    /**
     * @notice Overrides behavior of isApprovedFor all such that if an operator is not explicitly approved
     *         for all, the contract owner can optionally auto-approve the 721-C transfer validator for transfers.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool isApproved) {
        isApproved = super.isApprovedForAll(owner, operator);

        if (!isApproved) {
            if (autoApproveTransfersFromValidator) {
                isApproved = operator == address(getTransferValidator());
            }
        }
    }

    /**
     * @notice Indicates whether the contract implements the specified interface.
     * @dev Overrides supportsInterface in ERC165.
     * @param interfaceId The interface id
     * @return true if the contract implements the specified interface, false otherwise
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return 
        interfaceId == type(ICreatorToken).interfaceId || 
        interfaceId == type(ICreatorTokenLegacy).interfaceId || 
        super.supportsInterface(interfaceId);
    }

    /**
     * @notice Returns the function selector for the transfer validator's validation function to be called 
     * @notice for transaction simulation. 
     */
    function getTransferValidationFunction() external pure returns (bytes4 functionSignature, bool isViewFunction) {
        functionSignature = bytes4(keccak256("validateTransfer(address,address,address,uint256,uint256)"));
        isViewFunction = false;
    }

    /// @dev Ties the open-zeppelin _beforeTokenTransfer hook to more granular transfer validation logic
    function _beforeTokenTransfer(
        address /*operator*/,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory /*data*/
    ) internal virtual override {
        uint256 idsArrayLength = ids.length;
        for (uint256 i = 0; i < idsArrayLength;) {
            _validateBeforeTransfer(from, to, ids[i], amounts[i]);

            unchecked {
                ++i;
            }
        }
    }

    /// @dev Ties the open-zeppelin _afterTokenTransfer hook to more granular transfer validation logic
    function _afterTokenTransfer(
        address /*operator*/,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory /*data*/
    ) internal virtual override {
        uint256 idsArrayLength = ids.length;
        for (uint256 i = 0; i < idsArrayLength;) {
            _validateAfterTransfer(from, to, ids[i], amounts[i]);

            unchecked {
                ++i;
            }
        }
    }

    function _tokenType() internal pure override returns(uint16) {
        return uint16(TOKEN_TYPE_ERC1155);
    }
}

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

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

import "../../access/OwnablePermissions.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";

abstract contract ERC1155OpenZeppelinBase is ERC1155 {

}

abstract contract ERC1155OpenZeppelin is ERC1155OpenZeppelinBase {
    constructor(string memory uri_) ERC1155(uri_) {}
}

abstract contract ERC1155OpenZeppelinInitializable is OwnablePermissions, ERC1155OpenZeppelinBase {

    error ERC1155OpenZeppelinInitializable__AlreadyInitializedERC1155();

    bool private _erc1155Initialized;

    function initializeERC1155(string memory uri_) public virtual {
        _requireCallerIsContractOwner();

        if(_erc1155Initialized) {
            revert ERC1155OpenZeppelinInitializable__AlreadyInitializedERC1155();
        }

        _erc1155Initialized = true;

        _setURI(uri_);
    }
}

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

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// 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 (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;

import "../../interfaces/IERC2981.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}