Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import { ChonkTraits } from "../ChonkTraits.sol";
import { IChonkStorage } from "../interfaces/IChonkStorage.sol";
import { Utils } from "../common/Utils.sol";

contract MainRenderer2D {

    string constant SVG_BACKPACK = '<g id="All Traits"><g id="backpack" class="closed"><path d="M0 0 L30 0 L30 30 L0 30 Z" fill="rgb(12, 109, 157)" /><svg id="backpackUI" viewBox="0 0 120 120"> <style>.ui{width:1px; height: 1px; fill:white}</style> <g id="closeBtn" transform="translate(2,2)"> <rect x="1" y="1" class="ui"></rect> <rect x="2" y="2" class="ui"></rect> <rect x="3" y="3" class="ui"></rect> <rect x="4" y="4" class="ui"></rect> <rect x="5" y="5" class="ui"></rect> <rect x="5" y="1" class="ui"></rect> <rect x="4" y="2" class="ui"></rect> <!-- <rect x="3" y="3" width="1" height="1" fill="white"></rect> --> <rect x="2" y="4" class="ui"></rect> <rect x="1" y="5" class="ui"></rect> </g> <g id="leftBtn" class="button" transform="translate(45,110)"> <path d="M0 0 L6 0 L6 6 L0 6 Z" fill="transparent" /> <rect x="2" y="0" class="ui"></rect> <rect x="1" y="1" class="ui"></rect> <rect x="0" y="2" class="ui"></rect> <rect x="1" y="3" class="ui"></rect> <rect x="2" y="4" class="ui"></rect> </g> <g id="rightBtn" class="button" transform="translate(65,110)"> <path d="M0 0 L6 0 L6 6 L0 6 Z" fill="transparent" /> <rect x="3" y="0" class="ui"></rect> <rect x="4" y="1" class="ui"></rect> <rect x="5" y="2" class="ui"></rect> <rect x="4" y="3" class="ui"></rect> <rect x="3" y="4" class="ui"></rect> </g> </svg> ';
    string private constant SVG_START = '<svg shape-rendering="crispEdges" viewBox="0 0 30 30" fill="none" xmlns="http://www.w3.org/2000/svg">';
    string private constant SVG_STYLE = '<style> body{overflow: hidden; margin: 0;} svg{ max-width: 100vw; max-height: 100vh; width: 100%;} #main rect{width:1px; height: 1px;} .bg{width:30px; height: 30px;} .on { scale: 177%; transform: translate(-6px, -3px); } .off { scale: 100%; transform: translate(0px, 0px); } .button { cursor: pointer; fill: transparent; } .closed{ transform: translate(0px, 30px); } .open{ transform: translate(0px, 0px); } </style>';
    string private constant SVG_BG_MAIN_START = '<rect class="bg"/><g id="main" class="off">';
    string private constant SVG_TOGGLE = '<rect id="toggleMain" class="button" x="25" y="0" width="5" height="5" /><rect id="toggleBackpack" class="button" x="0" y="0" width="5" height="5" />';
    string private constant SVG_TOGGLE_SCRIPT = '<script><![CDATA[  const maxTraitsPerScreen = 20; const mainGroup = document.getElementById("main"); const backpackGroup = document.getElementById("backpack"); const backpackTraits = document.getElementById("backpackTraits"); const backpackTraitsSvgs = Array.from(backpackTraits.getElementsByTagName("svg"));  const ghostGroup = document.getElementById("ghost"); const leftBtn = document.getElementById("leftBtn"); const rightBtn = document.getElementById("rightBtn"); let curScreen = 0; const numScreens = Math.ceil(backpackTraitsSvgs.length / maxTraitsPerScreen); while (backpackTraits.firstChild) { backpackTraits.removeChild(backpackTraits.firstChild);} const ghostClone = ghostGroup.outerHTML; for (let i = 0; i < backpackTraitsSvgs.length; i += maxTraitsPerScreen) {  const gElement = document.createElementNS("http://www.w3.org/2000/svg", "g"); gElement.setAttribute("transform", `translate(${(i / maxTraitsPerScreen) * 30} 0)`); for (let j = 0; j < maxTraitsPerScreen && i + j < backpackTraitsSvgs.length; ++j) { const svg = backpackTraitsSvgs[i + j]; const x = -(j % 5) * 30; const y = -(Math.floor(j / 5) * 30) - 10; svg.setAttribute("viewBox", `${x} ${y} 150 150`); svg.innerHTML = ghostClone + svg.innerHTML; gElement.appendChild(svg);} backpackTraits.appendChild(gElement); } ghostGroup.remove(); if (backpackTraitsSvgs.length <= maxTraitsPerScreen) { leftBtn.style.display = "none"; rightBtn.style.display = "none";} else {leftBtn.style.opacity = 0.1;} leftBtn.onclick = () => { if (curScreen === 0) return; curScreen--; backpackTraits.style.transform = `translate(-${curScreen * 100}%, 0)`; rightBtn.style.opacity = 1; if (curScreen === 0) { leftBtn.style.opacity = 0.1;} }; rightBtn.onclick = () => { if (curScreen >= numScreens - 1) return; curScreen++; backpackTraits.style.transform = `translate(-${curScreen * 100}%, 0)`;leftBtn.style.opacity = 1;if (curScreen >= numScreens - 1) { rightBtn.style.opacity = 0.1; }}; document.getElementById("toggleMain").onclick = () => { mainGroup.classList.toggle("on"); mainGroup.classList.toggle("off"); if (backpackGroup.classList.contains("open")) { backpackGroup.classList.toggle("open"); backpackGroup.classList.toggle("closed");}}; document.getElementById("toggleBackpack").onclick = () => { backpackGroup.classList.toggle("open"); backpackGroup.classList.toggle("closed"); if (mainGroup.classList.contains("on")) { mainGroup.classList.toggle("on"); mainGroup.classList.toggle("off"); } };  ]]></script>';
    string private constant SVG_END = '</svg> ';

    error InvalidBodyBytes();

    function generateBackgroundColorStyles(IChonkStorage.ChonkData memory _chonkdata) internal pure returns (string memory backgroundColorStyles) {
        backgroundColorStyles = string.concat(
            '<style>',
            'body, svg{ background: #', _chonkdata.backgroundColor, '; }',
            '.bg { fill: #', _chonkdata.backgroundColor, '; }',
            '</style>'
        );
    }

    function generateChonkData(IChonkStorage.ChonkData memory _chonkdata) internal pure returns (string memory chonkDataJson) {
        chonkDataJson = string.concat(
            '"chonkdata":[',
                '{ "background_color" : "#', _chonkdata.backgroundColor, '" },',
                '{ "num_items_in_backpack" : "', Utils.toString(_chonkdata.numOfItemsInBackpack), '" },',
                '{ "renderer" : "2D" },',
                '{ "body_type" : "', _chonkdata.bodyName, '" }'
           ']'
        );
    }

    function renderAsDataUri(
        uint256 _tokenId,
        string memory _bodySvg,
        string memory _traitsSvg,
        string memory _traitsAttributes,
        string memory _backpackSVGs,
        IChonkStorage.ChonkData memory _chonkdata
    ) public pure returns (string memory) {

        string memory fullSvg;
        string memory fullAttributes;

        fullSvg = string.concat(
            SVG_START,
            SVG_STYLE,
            generateBackgroundColorStyles(_chonkdata),
            SVG_BG_MAIN_START,
            _bodySvg,
            _traitsSvg,
            '</g>'
        );

        string memory image = string.concat(
            '"image":"data:image/svg+xml;base64,',
            Utils.encode(bytes(string.concat(fullSvg, SVG_END) )),
            '"'
        );

        if (bytes(_traitsAttributes).length > 0) {
            fullAttributes = string.concat('"attributes":[', _traitsAttributes, ']');
        }
        else {
            fullAttributes = string.concat('"attributes":[]');
        }

        string memory combinedHTML = string.concat(
            '<!DOCTYPE html><html><head>',
            SVG_STYLE,
            generateBackgroundColorStyles(_chonkdata),
            '</head><body>',
            SVG_START,
            SVG_BG_MAIN_START,
            _bodySvg,
            _traitsSvg,
            _backpackSVGs,
            '</g></g></g>',
            SVG_TOGGLE,
            SVG_TOGGLE_SCRIPT,
            '</body></html>'
        );

        string memory animationURL = string.concat(
            '"animation_url":"data:text/html;base64,',
            Utils.encode(bytes(combinedHTML)),
            '"'
        );

        string memory json = string.concat(
            '{"name":"Chonk #',
                Utils.toString(_tokenId),
                '","description":"',
                _chonkdata.descriptionParts[0],
                Utils.toString(_tokenId),
                _chonkdata.descriptionParts[1],
                '",',
                fullAttributes,
                ',', generateChonkData(_chonkdata),
                ',', image,
                ',', animationURL, // comment out for qa collection
            '}'
        );

        return string.concat("data:application/json;base64,", Utils.encode(bytes(json)));
    }

    function getBodyImageSvg(bytes memory _pixels) public pure returns (string memory) {
        // optimised for hex and set 30 coords
        string[16] memory hexSymbols = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
        string[30] memory coords = ["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29"];

        bytes memory svgParts;

        for (uint i; i < 4500; i += 5) {
            if (_pixels[i] > 0) {
                uint x = (i / 5) % 30;
                uint y = (i / 5) / 30;

                bytes memory color = abi.encodePacked(
                    hexSymbols[uint8(_pixels[i + 2]) >> 4],
                    hexSymbols[uint8(_pixels[i + 2]) & 0xf],
                    hexSymbols[uint8(_pixels[i + 3]) >> 4],
                    hexSymbols[uint8(_pixels[i + 3]) & 0xf],
                    hexSymbols[uint8(_pixels[i + 4]) >> 4],
                    hexSymbols[uint8(_pixels[i + 4]) & 0xf]
                );

                svgParts = abi.encodePacked(
                    svgParts,
                    '<rect x="', coords[x],
                    '" y="', coords[y],
                    '" width="1" height="1" fill="#', color, '"/>'
                );
            }
        }

        return string(abi.encodePacked('<g id="Body">', svgParts, '</g>'));
    }

    function colorMapToSVG(bytes memory colorMap) public pure returns (string memory) {
        bytes memory pixels = getBodyImage(colorMap);
        return getBodyImageSvg(pixels);
    }

    function getBodyImage(bytes memory colorMap) public pure returns (bytes memory) {
        uint256 length = colorMap.length;
        if (length == 0 || length % 5 != 0) revert InvalidBodyBytes();

        bytes memory pixels = new bytes(30 * 30 * 5); // 30x30 grid with 5 bytes per pixel
        uint256 pixelCount = length / 5;

        for (uint256 i; i < pixelCount; ++i) {
            uint256 offset = i * 5;

            uint8 x = uint8(colorMap[offset]);
            uint8 y = uint8(colorMap[offset + 1]);
            uint256 index = (uint256(y) * 30 + uint256(x)) * 5;

            // Set the pixel data in the pixels array
            unchecked {
                pixels[index] = colorMap[offset];
                pixels[index + 1] = colorMap[offset + 1];
                pixels[index + 2] = colorMap[offset + 2];
                pixels[index + 3] = colorMap[offset + 3];
                pixels[index + 4] = colorMap[offset + 4];
            }
        }

        return pixels;
    }

    function getBackpackSVGs(
        address _traitsContract,
        address _tbaAddress,
        uint256 _maxTraitsToOutput
    ) public view returns (string memory backpackSVGs) {
        ChonkTraits traitsContract = ChonkTraits(_traitsContract);

        uint256[] memory traitTokens = traitsContract.walletOfOwner(_tbaAddress);
        string memory bodyGhostSvg = traitsContract.getGhostSvg();

        uint256 numTraits = traitTokens.length < _maxTraitsToOutput ? traitTokens.length : _maxTraitsToOutput;

        string[] memory traitSvgs = new string[](numTraits);
        for (uint256 i; i < numTraits; ++i) {
            traitSvgs[i] = traitsContract.getSvgForTokenId(traitTokens[i]);
        }

        string memory baseSvgPart = '<svg viewBox="0 0 150 150">';
        string memory closeSvgTag = '</svg>';
        bytes memory buffer;

        buffer = abi.encodePacked(
            SVG_BACKPACK,
            bodyGhostSvg,
            '<g id="backpackTraits">'
        );

        for (uint256 i; i < numTraits; ++i) {
            buffer = abi.encodePacked(
                buffer,
                baseSvgPart,
                traitSvgs[i],
                closeSvgTag
            );
        }

        if (traitTokens.length > _maxTraitsToOutput) {
            buffer = abi.encodePacked(
                buffer,
                baseSvgPart,
                '<g id="MoreTraits"><rect style="width:10px; height:2px;" x="10" y="16" fill="#ffffff"></rect><rect style="height:10px; width:2px;" x="14" y="12" fill="#ffffff"></rect></g>',
                closeSvgTag
            );
        }

        buffer = abi.encodePacked(
            buffer,
            '</g>'
        );

        backpackSVGs = string(buffer);
    }

    function stringTrait(string memory traitName, string memory traitValue) public pure returns (string memory) {
        return string.concat(
            '{"trait_type":"',
                traitName,
            '","value":"',
                traitValue,
            '"}'
        );
    }

}

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

// OpenZeppelin Imports
import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { ERC721Burnable } from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import { ERC721Enumerable } from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { Ownable } from "solady/auth/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

// Associated Interfaces and Libraries
import { CommitReveal } from "./common/CommitReveal.sol";
import { IERC4906 } from "./interfaces/IERC4906.sol";
import { IChonkStorage } from "./interfaces/IChonkStorage.sol";
import { ITraitStorage } from "./interfaces/ITraitStorage.sol";
import { TraitCategory } from "./TraitCategory.sol";

// Renderer
import { TraitRenderer } from "./renderers/TraitRenderer.sol";

// Other Chonks Associated Contracts
import { ChonksMain } from "./ChonksMain.sol";
import { ChonksMarket } from "./ChonksMarket.sol";

interface IRenderMinterV1 {
    function explainTrait(
        ITraitStorage.StoredTrait calldata storedTrait,
        uint128 randomness
    ) external view returns (ITraitStorage.StoredTrait memory);
}

/*
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:cllllllllllllllllllllllllllllllllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:clllxOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ccldOOOOOOO0KKKxllldOOOOOOOOOOOO0KKKxllldOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXWMNl   ;kOOOOOOOOOOOXWMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXMMWl   ;kkkkkkkkkkkOXMMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXMMWl   ,dxxxxxxxxxxxKWMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:coooxOOOOOOOKNNXd'.'cxkkkxxkkkkkk0XNXd'.'lkOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;:oOOOOOOOOOOOOOkkOOOOOOOOOOOOOOOOOOkkOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:lddxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okkkkkkkkkkkkkkkkkkkkkkkkkkkkxxddl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:lxxxxxxxxxxxxxxxxxxxxxxxxxxxxl::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:cllldxkxxxxkkkkkkkkkkkkkkkkkkkkkxdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;clllxOOOOOOOOkkkOOOOOOOOOOOOOOkkkOOOOOOOOdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOkxxxkOOOOOOOOOOOOkxxxkOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOkkkOOOOkkkkkOOOOOOOOOOOOkkxkkOOOOkkkOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxddoooxOOOOOOOOOOOOOOOOOOOOOOOOOOOOxoooddxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::oOOOOOOOOOOOOOOOOOOOOOOOOOOOOo::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOkxdxkOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOo:::okOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOkxddl:;:lddxxkOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOo::::;;;:::::oOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldddddxdl:;;;;;;;;;;:ldxxxxxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::::;;;;;;;;;;;;:::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
*/

contract ChonkTraits is IERC165, ERC721Enumerable, ERC721Burnable, ITraitStorage, Ownable, IERC4906, ReentrancyGuard {

    // We use this database for persistent storage
    Traits public traitTokens;

    // The renderer contract for the Traits
    TraitRenderer public traitRenderer;

    // The ChonksMain contract
    ChonksMain public chonksMain;

    // The ChonksMarket contract
    ChonksMarket public marketplace;

    // Metadata for each Trait by index
    mapping(uint256 => TraitMetadata) public traitIndexToMetadata;

    // Approved operators for each Trait
    mapping(uint256 traitId => address[] operators) public traitIdToApprovedOperators;

    // Contract addresses that are approved to create Traits
    mapping (address => bool) public isMinter;

    // These are Chonks-related contracts that are approved to invalidate operator approvals
    mapping (address => bool) public approvedInvalidators;

    // The next token ID to be minted
    uint256 public nextTokenId;

    // The transient Chonk ID, used in _beforeTokenTransfer and _afterTokenTransfer
    uint256 internal _transientChonkId;

    // When the initial mint started
    uint256 public initialMintStartTime;

    // The description parts
    string[2] descriptionParts;

    /// Errors

    error AddressCantBurn();
    error CantTransfer();
    error CantTransferDuringMint();
    error CantTransferEquipped();
    error MintStartTimeAlreadySet();
    error NotATBA();
    error NotAValidMinterContract();
    error NotYourTrait();
    error SetChonksMainAddress();
    error SetMarketplaceAddress();
    error TraitNotFound(uint256 _tokenId);
    error TraitTokenDoesntExist();

    /// Modifiers

    modifier onlyMinter(address _address) {
        // Add DataMinter contract first via `AddMinter`.
        if (!isMinter[_address]) revert NotAValidMinterContract();
        _;
    }

    constructor() ERC721("Chonk Traits", "CHONK TRAITS") {
        _initializeOwner(msg.sender);
        traitRenderer = new TraitRenderer();
    }

    function getTraitIndexToMetadata(uint256 _traitIndex) public view returns (TraitMetadata memory) {
        return traitIndexToMetadata[_traitIndex];
    }

    // Called by DataMinter contracts to set the trait for a tokenId
    function setTraitForTokenId(uint256 _tokenId, ITraitStorage.StoredTrait memory _trait) public onlyMinter(msg.sender) {
        traitTokens.all[_tokenId] = _trait;
    }

    /// @dev Called in DataMinter contracts to add Traits
    function setTraitIndexToMetadata(uint256 _traitIndex, TraitMetadata memory _metadata) public onlyMinter(msg.sender) {
        traitIndexToMetadata[_traitIndex] = _metadata;
    }

    /// @dev NOTE: Mints to a smart contract address that implements onERC721Received
    function safeMint(address _to) public onlyMinter(msg.sender) returns (uint256) {
        resolveEpochIfNecessary();

        uint tokenId = ++nextTokenId;
        _safeMint(_to, tokenId);

        return tokenId;
    }

    function burn(uint256 _tokenId) public override {
        if (!isMinter[msg.sender]) revert AddressCantBurn();

        _burn(_tokenId);
    }

    function burnBatch(uint256[] memory tokenIds) public {
        if (!isMinter[msg.sender]) revert AddressCantBurn();

        for (uint256 i; i < tokenIds.length; ++i) {
            _burn(tokenIds[i]);
        }
    }

    /// @notice Initializes and closes epochs. Thank you Jalil & MouseDev.
    /// @dev Based on the commit-reveal scheme proposed by MouseDev in Checks.
    function resolveEpochIfNecessary() public {
        CommitReveal.Epoch storage currentEpoch = traitTokens.epochs[traitTokens.epoch];

        if (
            // If epoch has not been committed,
            !currentEpoch.committed ||
            // Or the reveal commitment timed out.
            (!currentEpoch.revealed && currentEpoch.revealBlock < block.number - 256)
        ) {
            // This means the epoch has not been committed, OR the epoch was committed but has expired.
            // Set committed to true, and record the reveal block:
            // this was 50 x 12, 600 seconds - 10 mins on L1
            // but on L2 it's more like 50 x 2, 100 seconds - 1.6 mins on L2
            currentEpoch.revealBlock = uint64(block.number + 50);
            currentEpoch.committed = true;

        } else if (block.number > currentEpoch.revealBlock) {
            // Epoch has been committed and is within range to be revealed.
            // Set its randomness to the target block hash.
             currentEpoch.randomness = uint128(uint256(keccak256(
                abi.encodePacked(
                    blockhash(currentEpoch.revealBlock),
                    block.prevrandao
                ))) % (2 ** 128 - 1)
            );

            currentEpoch.revealed = true;

            // Notify dApps about the new epoch.
            emit CommitReveal.NewEpoch(traitTokens.epoch, currentEpoch.revealBlock);
             // Notify OS to update all tokens
            emit BatchMetadataUpdate(0, type(uint256).max);

            // Initialize the next epoch
            ++traitTokens.epoch;

            resolveEpochIfNecessary();
        }
    }

    /// @notice The identifier of the current epoch
    function getEpoch() view public returns(uint256) {
        return traitTokens.epoch;
    }

    /// @notice Get the data for a given epoch
    /// @param index The identifier of the epoch to fetch
    function getEpochData(uint256 index) view public returns(CommitReveal.Epoch memory) {
        return traitTokens.epochs[index];
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        if (!_exists(_tokenId)) revert TraitTokenDoesntExist();

        return renderAsDataUri(_tokenId);
    }

    function getTrait(uint256 _tokenId) public view returns (ITraitStorage.StoredTrait memory) {
        ITraitStorage.StoredTrait memory storedTrait = traitTokens.all[_tokenId];
        uint128 randomness = traitTokens.epochs[storedTrait.epoch].randomness;
        IRenderMinterV1 dataContract = IRenderMinterV1(storedTrait.dataMinterContract);

        if (storedTrait.dataMinterContract == address(0) && storedTrait.seed == 0)
            revert TraitNotFound(_tokenId);

        return dataContract.explainTrait(storedTrait, randomness);
    }

    /// @notice Lets you easily go from the Trait token id to the Trait Metadata, as explained by the DataMinter contract the Trait was minted with
    function getTraitMetadata(uint256 _tokenId) public view returns (TraitMetadata memory) {
        StoredTrait memory trait = getTrait(_tokenId);
        return traitIndexToMetadata[trait.traitIndex];
    }

    function getStoredTraitForTokenId(uint256 _tokenId) public view returns (ITraitStorage.StoredTrait memory) {
        return traitTokens.all[_tokenId];
    }

    function getCurrentEpoch() public view returns (uint256) {
        return traitTokens.epoch;
    }

    function renderAsDataUri(uint256 _tokenId) public view returns (string memory) {
        StoredTrait memory trait = getTrait(_tokenId);
        string memory traitSvg = trait.isRevealed ? getTraitImageSvg(trait.traitIndex) : '<svg></svg>';


        return traitRenderer.renderAsDataUri(
            _tokenId,
            trait,
            traitIndexToMetadata[trait.traitIndex],
            getGhostSvg(),
            traitSvg,
            descriptionParts
        );
    }

    function getSvgForTokenId(uint256 _tokenId) public view returns (string memory traitSvg) {
        // don't get the ghost here for now
        StoredTrait memory trait = getTrait(_tokenId);

        if (trait.isRevealed) {
            traitSvg = getTraitImageSvg(trait.traitIndex);
        } else {
            traitSvg = '<svg></svg>';
        }
    }

    function getZMapForTokenId(uint256 _tokenId) public view returns (string memory) {
        StoredTrait memory trait = getTrait(_tokenId);
        return string(traitIndexToMetadata[trait.traitIndex].zMap);
    }

    function getTraitImageSvg(uint256 index) public view returns (string memory svg) {
        return traitRenderer.getTraitImageSvg(traitIndexToMetadata[index].colorMap);
    }

    function getGhostSvg() public view returns (string memory svg) {
        return traitRenderer.getGhostSvg();
    }

    function createSvgFromPixels(bytes memory _pixels) public view returns (bytes memory svgParts) {
        return traitRenderer.createSvgFromPixels(_pixels);
    }

    function getSvgAndMetadataTrait(StoredTrait memory trait, uint256 traitId) public view returns (string memory traitSvg, string memory traitAttributes ) {
        return traitRenderer.getSvgAndMetadataTrait(
            trait,
            traitId,
            traitIndexToMetadata[trait.traitIndex]
        );
    }

    function getSVGZmapAndMetadataTrait(StoredTrait memory trait, uint256 traitId) public view returns(string memory traitSvg, bytes memory traitZmap, string memory traitAttributes ) {
         return traitRenderer.getSVGZmapAndMetadataTrait(
            trait,
            traitId,
            traitIndexToMetadata[trait.traitIndex]
        );
    }

    function getSvgAndMetadata(IChonkStorage.StoredChonk memory storedChonk) public view returns (string memory traitsSvg, string memory traitsAttributes) {
        return traitRenderer.getSvgAndMetadata(storedChonk, this.callGetSvgAndMetadataTrait);
    }

    function getSvgZmapsAndMetadata(IChonkStorage.StoredChonk memory storedChonk) public view returns (string memory traitsSvg, bytes memory traitZMaps, string memory traitsAttributes) {
        return traitRenderer.getSvgZmapsAndMetadata(storedChonk, this.callGetSVGZmapAndMetadataTrait);
    }

    function callGetSvgAndMetadataTrait(uint256 _traitId, string memory _traitsSvg, string memory _traitsAttributes ) public view returns (string memory traitsSvg, string memory traitsAttributes) {
        StoredTrait memory storedTrait = getTrait(_traitId);
        return traitRenderer.callGetSvgAndMetadataTrait(
            _traitId,
            _traitsSvg,
            _traitsAttributes,
            storedTrait,
            traitIndexToMetadata[storedTrait.traitIndex]
        );
    }

    function callGetSVGZmapAndMetadataTrait(uint256 _traitId, string memory _traitsSvg, string memory _traitsAttributes, bytes memory _traitZMaps) public view returns (string memory traitsSvg, string memory traitsAttributes, bytes memory traitZMaps) {
        StoredTrait memory storedTrait = getTrait(_traitId);
        return traitRenderer.callGetSVGZmapAndMetadataTrait(
            _traitId,
            _traitsSvg,
            _traitsAttributes,
            _traitZMaps,
            storedTrait,
            traitIndexToMetadata[storedTrait.traitIndex]
        );
    }

    function walletOfOwner(address _owner) public view returns(uint256[] memory) {
        uint256 tokenCount = balanceOf(_owner);

        uint256[] memory tokensId = new uint256[](tokenCount);
        for (uint256 i; i < tokenCount; ++i){
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
        }

        return tokensId;
    }

    /// Setters/OnlyOwner

    function setChonksMain(address _ChonksMain) public onlyOwner {
        chonksMain = ChonksMain(_ChonksMain);
    }

    function setMarketplace(address _marketplace) public onlyOwner {
        marketplace = ChonksMarket(_marketplace);
    }

    function addMinter(address _minter) public onlyOwner {
        isMinter[_minter] = true;
    }

    function removeMinter(address _minter) public onlyOwner {
        isMinter[_minter] = false;
    }

    function setTraitRenderer(address _traitRenderer) public onlyOwner {
        traitRenderer = TraitRenderer(_traitRenderer);
    }

    function setGhostMaps(bytes memory _colorMap, bytes memory _zMap) public onlyOwner {
        // ghost.colorMap = _colorMap;
        // ghost.zMap = _zMap;
        traitRenderer.setGhostMaps(_colorMap, _zMap);
    }

    function addApprovedInvalidator(address _invalidator) public onlyOwner {
        approvedInvalidators[_invalidator] = true;
    }

    function removeApprovedInvalidator(address _invalidator) public onlyOwner {
        approvedInvalidators[_invalidator] = false;
    }

    function setMintStartTime(uint256 _initialMintStartTime) public onlyOwner {
        if (initialMintStartTime != 0) revert MintStartTimeAlreadySet();
        initialMintStartTime = _initialMintStartTime;
    }

    function setDescriptionParts(string[2] memory _descriptionParts) public onlyOwner {
        descriptionParts = _descriptionParts;
    }

    /// Boilerplate

    function supportsInterface(bytes4 interfaceId) public view override(IERC165, ERC721Enumerable, ERC721) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function _cleanUpMarketplaceOffersAndBids(uint256 _tokenId, address _to) internal {
        // Delete the Offer on Chonk ID before the transfer
        address tba = ownerOf(_tokenId);
        uint256 chonkId = chonksMain.tbaAddressToTokenId(tba);
        marketplace.removeChonkOfferOnTraitTransfer(chonkId);

        marketplace.deleteTraitOffersBeforeTokenTransfer(_tokenId);
        marketplace.deleteTraitBidsBeforeTokenTransfer(_tokenId, _to);
    }

    // Override functions for marketplace compatibility
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
        if (from == address(0)) {
            super._beforeTokenTransfer(from, to, tokenId);
            return;
        }

        if (block.timestamp < initialMintStartTime + 24 hours) revert CantTransferDuringMint();

        // Check if the Trait is equipped on the Chonk, revert if so
        (,,, bool isEquipped) = chonksMain.getFullPictureForTrait(tokenId);
        if (isEquipped) revert CantTransferEquipped();

        (, address seller,,) = marketplace.traitOffers(tokenId);
        // If there's an Offer on the Trait, seller is not 0
        if (seller != address(0)) {
            if (msg.sender != address(marketplace)) revert CantTransfer();
        }

        // If burning
        if (to == address(0)) {
            _cleanUpMarketplaceOffersAndBids(tokenId, to);

            // If burning, store the owning Chonk ID for Marketplace cleanup later
            address tba = ownerOf(tokenId);
            _transientChonkId = chonksMain.tbaAddressToTokenId(tba);

            super._beforeTokenTransfer(from, to, tokenId);
            return;
        }

        // Ensure the `to` address is a TBA
        if (chonksMain.tbaAddressToTokenId(to) == 0) revert NotATBA();

        _cleanUpMarketplaceOffersAndBids(tokenId, to);

        super._beforeTokenTransfer(from, to, tokenId);
    }

    // Remove an active ChonkOffer because owned Traits changed
    function _afterTokenTransfer(address _from , address _to, uint256 _traitTokenId) internal override(ERC721) {
        if (address(chonksMain)  == address(0)) revert SetChonksMainAddress();
        if (address(marketplace) == address(0)) revert SetMarketplaceAddress();

        // Ignore if minting
        if (_from == address(0)) return;

        // If burning
        if (_to == address(0)) {
            uint256 id = _transientChonkId;
            _transientChonkId = 0;
            marketplace.removeChonkOfferOnTraitTransfer(id);
            return;
        }

        // Delete the Offer on Chonk ID after the transfer
        address tba = ownerOf(_traitTokenId);
        uint256 chonkId = chonksMain.tbaAddressToTokenId(tba);
        marketplace.removeChonkOfferOnTraitTransfer(chonkId);

        emit BatchMetadataUpdate(0, type(uint256).max);
    }

    // Approvals

    /// @notice Override approve to track individual token approvals
    function approve(address _operator, uint256 _tokenId) public override(ERC721, IERC721) {
        if (!_exists(_tokenId)) revert TraitTokenDoesntExist();
        if (ownerOf(_tokenId) != msg.sender) revert NotYourTrait();

        // if removing approval
        if (_operator == address(0)) {
            // Remove the operator from the array
            address[] storage operators = traitIdToApprovedOperators[_tokenId];
            for (uint256 i; i < operators.length; ++i) {
                if (operators[i] == _operator) {
                    // Replace with last element and pop
                    operators[i] = operators[operators.length - 1];
                    operators.pop();
                    break;
                }
            }
        } else {
            // Add operator if not already present
            address[] storage operators = traitIdToApprovedOperators[_tokenId];
            bool exists = false;
            for (uint256 i; i < operators.length; ++i) {
                if (operators[i] == _operator) {
                    exists = true;
                    break;
                }
            }
            if (!exists) {
                operators.push(_operator);
            }
        }

        super.approve(_operator, _tokenId);
    }

    /// @notice Override setApprovalForAll to track operator approvals
    function setApprovalForAll(address _operator, bool _approved) public override(ERC721, IERC721) {
        // Cannot approve self as operator
        require(_operator != msg.sender, "ERC721: approve to caller");

        // For setApprovalForAll, we need to update approvals for all tokens owned by msg.sender
        uint256 balance = balanceOf(msg.sender);
        for (uint256 i; i < balance; ++i) {
            uint256 tokenId = tokenOfOwnerByIndex(msg.sender, i);

            if (_approved) {
                // Add operator if not already present
                address[] storage operators = traitIdToApprovedOperators[tokenId];
                bool exists = false;
                for (uint256 j; j < operators.length; ++j) {
                    if (operators[j] == _operator) {
                        exists = true;
                        break;
                    }
                }
                if (!exists) {
                    operators.push(_operator);
                }
            } else {
                // Remove the operator
                address[] storage operators = traitIdToApprovedOperators[tokenId];
                for (uint256 j; j < operators.length; ++j) {
                    if (operators[j] == _operator) {
                        // Replace with last element and pop
                        operators[j] = operators[operators.length - 1];
                        operators.pop();
                        break;
                    }
                }
            }
        }

        super.setApprovalForAll(_operator, _approved);
    }

    /// @notice Invalidates all operator approvals for a specific token
    function invalidateAllOperatorApprovals(uint256 _tokenId) public {
        if (!_exists(_tokenId)) revert TraitTokenDoesntExist();

        // We allow ChonksMain to invalidate all operator approvals for a token
        if (ownerOf(_tokenId) != msg.sender && msg.sender != address(chonksMain) && !approvedInvalidators[msg.sender])
            revert NotYourTrait();

        address[] memory operators = traitIdToApprovedOperators[_tokenId];
        if (operators.length == 0) return;

        // Remove individual token approval
        _approve(address(0), _tokenId);

        // Remove all operator approvals for this token
        for (uint256 i; i < operators.length; ++i) {
            _setApprovalForAll(ownerOf(_tokenId), operators[i], false);
        }

        // Clear tracking array
        delete traitIdToApprovedOperators[_tokenId];

        emit ITraitStorage.AllOperatorApprovalsInvalidated(_tokenId);
    }

    /// Approval Getters

    // Function to get the entire array of approved operators for a traitId
    function getApprovedOperators(uint256 traitId) public view returns (address[] memory) {
        return traitIdToApprovedOperators[traitId];
    }

}

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

/// A shared interface for data storage of the Chonks
interface IChonkStorage {

    struct StoredChonk {
        // The token id of the Chonk
        uint256 tokenId;

        // The token id of the head, 0 if unequipped
        uint256 headId;

        // The token id of the hair, 0 if unequipped
        uint256 hairId;

        // The token id of the face, 0 if unequipped
        uint256 faceId;

        // The token id of the accessory, 0 if unequipped
        uint256 accessoryId;

        // The token id of the top, 0 if unequipped
        uint256 topId;

        // The token id of the bottom, 0 if unequipped
        uint256 bottomId;

        // The token id of the shoes, 0 if unequipped
        uint256 shoesId;

        // Randomly set in ChonksMain.mint() but can be updated by holder at any time
        uint8 bodyIndex;

        // RRGGBB colour of the background, default blue #0D6E9D set in ChonksMain.sol mint(), and setBackgroundColor()
        string backgroundColor;

        // Bool to determine whether to render in 3D or not
        bool render3D;
    }

    struct BodyMetadata {
        // Refers to the number used in ChonksMain.addNewBody; Not token id
        uint256 bodyIndex;

        // e.g. 'Skin Tone 1'
        string bodyName;

        // bytes memory colorMap = new bytes(2700); 30x30 grid by 3 bytes (rgb, each colour is a byte, or 2 hex digits);
        bytes colorMap;

        // The map of possible 3D traits
        bytes zMap;
    }

    struct ChonkData {
        string backgroundColor;
        string bodyName;
        // string rendererSet;
        uint256 numOfItemsInBackpack;
        string[2] descriptionParts;
    }

    /// Events

    event Mint(address indexed owner, uint256 indexed tokenId);
    event Equip(address indexed owner, uint256 indexed tokenId, uint256 indexed traitTokenId, uint8 traitCategory);
    event Unequip(address indexed owner, uint256 indexed tokenId, uint8 traitCategory);
    event EquipAll(address indexed owner, uint256 indexed tokenId);
    event UnequipAll(address indexed owner, uint256 indexed tokenId);
    event BackgroundColor(address indexed owner, uint256 indexed tokenId, string color);
    event BodyIndex(address indexed owner, uint256 indexed tokenId, uint8 _bodyIndex);
    event Render3D(address indexed owner, uint256 indexed tokenId, bool renderZ);

}

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

library Utils {
    uint256 internal constant MULTIPLIER   = 100;
    uint256 internal constant GOLDEN_RATIO = 161803;


    function toHexString(bytes memory data) internal pure returns (string memory) {
        bytes memory alphabet = "0123456789abcdef";
        bytes memory str = new bytes(2 + data.length * 2);
        str[0] = "0";
        str[1] = "x";
        for (uint256 i = 0; i < data.length; i++) {
            str[2 + i * 2] = alphabet[uint8(data[i] >> 4)];
            str[2 + i * 2 + 1] = alphabet[uint8(data[i] & 0x0f)];
        }
        return string(str);
    }


    /// @dev Zero-index based pseudorandom number based on one input and max bound - thank you Checks
    function random(uint256 input, uint256 _max) internal pure returns (uint256) {
        return (uint256(keccak256(abi.encodePacked(input))) % _max);
    }

    /// @dev Zero-index based salted pseudorandom number based on two inputs and max bound - thank you Checks
    function random(uint256 input, string memory salt, uint256 _max) internal pure returns (uint256) {
        return (uint256(keccak256(abi.encodePacked(input, salt))) % _max);
    }

    /**
      * Compute the largest integer smaller than or equal to the square root of `n`
    */
    // function floorSqrt(uint256 n) internal pure returns (uint256) { unchecked {
    //     if (n > 0) {
    //         uint256 x = n / 2 + 1;
    //         uint256 y = (x + n / x) / 2;
    //         while (x > y) {
    //             x = y;
    //             y = (x + n / x) / 2;
    //         }
    //         return x;
    //     }
    //     return 0;
    // }}

    /**
      * Compute the smallest integer larger than or equal to the square root of `n`
    */
    // function ceilSqrt(uint256 n) internal pure returns (uint256) { unchecked {
    //     uint256 x = floorSqrt(n);
    //     return x ** 2 == n ? x : x + 1;
    // }}

    // function lerp(int256 targetFrom, int256 targetTo, int256 currentFrom, int256 currentTo, int current) internal pure returns (int256) { unchecked {
    //     int256 t = 0;a
    //     int256 divisor = currentTo - currentFrom - 1;

    //     if (divisor > 0) {
    //         t = (current - currentFrom) * int256(MULTIPLIER) / (divisor);
    //     }

    //     return targetFrom * int256(MULTIPLIER) + t * (targetTo - targetFrom);
    // }}

    function toByteArray(bytes32 _bytes32) internal pure returns (bytes memory result) {
        uint8 i = 0;
        while(i < 32 && _bytes32[i] != 0) {
            i++;
        }
        bytes memory bytesArray = new bytes(i);
        for (i = 0; i < 32 && _bytes32[i] != 0; i++) {
            bytesArray[i] = _bytes32[i];
        }
        return bytesArray;
    }

    function toString(bytes32 _bytes32) internal pure returns (string memory result) {
        return string(toByteArray(_bytes32));
    }

    function toStringBytes3(bytes3 _bytes) public pure returns (string memory) {
        bytes memory hexChars = "0123456789abcdef";
        bytes memory hexString = new bytes(6); // Since bytes3 contains 3 bytes, resulting in 6 hex characters

        for (uint i = 0; i < 3; i++) {
            hexString[i * 2] = hexChars[uint8(_bytes[i] >> 4)];
            hexString[1 + i * 2] = hexChars[uint8(_bytes[i] & 0x0f)];
        }

        return string(hexString);
    }


    /*

        Gas Efficient uint/int to string functions
        Copied from: https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol

    */

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 1)`.
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(uint256(-value));
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

     /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// See: https://datatracker.ietf.org/doc/html/rfc4648
    /// @param fileSafe  Whether to replace '+' with '-' and '/' with '_'.
    /// @param noPadding Whether to strip away the padding.
    function encode(bytes memory data, bool fileSafe, bool noPadding) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            let dataLength := mload(data)

            if dataLength {
                // Multiply by 4/3 rounded up.
                // The `shl(2, ...)` is equivalent to multiplying by 4.
                let encodedLength := shl(2, div(add(dataLength, 2), 3))

                // Set `result` to point to the start of the free memory.
                result := mload(0x40)

                // Store the table into the scratch space.
                // Offsetted by -1 byte so that the `mload` will load the character.
                // We will rewrite the free memory pointer at `0x40` later with
                // the allocated size.
                // The magic constant 0x0670 will turn "-_" into "+/".
                mstore(0x1f, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef")
                mstore(0x3f, xor("ghijklmnopqrstuvwxyz0123456789-_", mul(iszero(fileSafe), 0x0670)))

                // Skip the first slot, which stores the length.
                let ptr := add(result, 0x20)
                let end := add(ptr, encodedLength)

                // Run over the input, 3 bytes at a time.
                for {} 1 {} {
                    data := add(data, 3) // Advance 3 bytes.
                    let input := mload(data)

                    // Write 4 bytes. Optimized for fewer stack operations.
                    mstore8(0, mload(and(shr(18, input), 0x3F)))
                    mstore8(1, mload(and(shr(12, input), 0x3F)))
                    mstore8(2, mload(and(shr(6, input), 0x3F)))
                    mstore8(3, mload(and(input, 0x3F)))
                    mstore(ptr, mload(0x00))

                    ptr := add(ptr, 4) // Advance 4 bytes.
                    if iszero(lt(ptr, end)) { break }
                }
                mstore(0x40, add(end, 0x20)) // Allocate the memory.
                // Equivalent to `o = [0, 2, 1][dataLength % 3]`.
                let o := div(2, mod(dataLength, 3))
                // Offset `ptr` and pad with '='. We can simply write over the end.
                mstore(sub(ptr, o), shl(240, 0x3d3d))
                // Set `o` to zero if there is padding.
                o := mul(iszero(iszero(noPadding)), o)
                mstore(sub(ptr, o), 0) // Zeroize the slot after the string.
                mstore(result, sub(encodedLength, o)) // Store the length.
            }
        }
    }

    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// Equivalent to `encode(data, false, false)`.
    function encode(bytes memory data) internal pure returns (string memory result) {
        result = encode(data, false, false);
    }

    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// Equivalent to `encode(data, fileSafe, false)`.
    function encode(bytes memory data, bool fileSafe) internal pure returns (string memory result) {
        result = encode(data, fileSafe, false);
    }

    // function contains(string memory _str, string memory _searchStr) internal pure returns (bool) {
    //     bytes memory str = bytes(_str);
    //     bytes memory searchStr = bytes(_searchStr);

    //     for (uint i = 0; i <= str.length - searchStr.length; i++) {
    //         bool found = true;
    //         for (uint j = 0; j < searchStr.length; j++) {
    //             if (str[i + j] != searchStr[j]) {
    //                 found = false;
    //                 break;
    //             }
    //         }
    //         if (found) return true;
    //     }
    //     return false;
    // }

    function startsWith(string memory _str, string memory _prefix) internal pure returns (bool) {
        bytes memory str = bytes(_str);
        bytes memory prefix = bytes(_prefix);
        if (str.length < prefix.length) return false;
        for (uint i = 0; i < prefix.length; i++) {
            if (str[i] != prefix[i]) return false;
        }
        return true;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (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 = _owners[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 nor 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 nor approved");

        _transfer(from, to, tokenId);
    }

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

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

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

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

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        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);

        _balances[to] += 1;
        _owners[tokenId] = to;

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits 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.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

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

pragma solidity ^0.8.0;

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

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
        _burn(tokenId);
    }
}

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

pragma solidity ^0.8.0;

import "../ERC721.sol";
import "./IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

library CommitReveal {

    event NewEpoch(uint256 indexed epoch, uint64 indexed revealBlock);

    // copy pasta from the legendary Checks contract by jalil + mouseDev
    struct Epoch {
        // The source of randomness for tokens from this epoch
        uint128 randomness;
        // The block at which this epoch was / is revealed
        uint64 revealBlock;
        // Whether the epoch has been instantiated
        bool committed;
        // Whether the epoch has been revealed
        bool revealed;
    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";

/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
    /// @dev This event emits when the metadata of a token is changed.
    /// Third-party platforms such as NFT marketplaces can listen to
    /// the event and auto-update the tokens in their apps.
    event MetadataUpdate(uint256 _tokenId);
    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}

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

import { CommitReveal } from "../common/CommitReveal.sol";
import { TraitCategory } from "../TraitCategory.sol";

interface ITraitStorage {

    struct StoredTrait {
        // The epoch when it was minted
        uint256 epoch;

        // If the trait has been revealed or not
        bool isRevealed;

        // Data used to calculate the commit-reveal
        uint256 seed;

        // The RenderMinter contract that can `explain` the trait
        address dataMinterContract;

        // A sequential numbering of the traits that exist in the collection
        uint256 traitIndex;

        // e.g. Head, Top, Shoes, etc.
        TraitCategory.Name traitType;
    }

    struct Traits {
        // A mapping of each token ID to what it actually is (the StoredTrait)
        mapping(uint256 => StoredTrait) all;

        // Collection-wide epoch; The current epoch index of the mapping below
        uint256 epoch;

        // A mapping of the above epoch (or past epochs) to the commit-reveal scheme. The epoch in StoredTrait is the epoch when that trait was *minted*
        mapping(uint256 => CommitReveal.Epoch) epochs;
    }

    // With Bodies, we just hardcode 5 Bodies in contracts
    // But with Traits, we want to be able to add them, hence this struct
    struct TraitMetadata {
        // Refers to the number used in ChonkTraits.addNewTrait; not a token ID
        uint256 traitIndex;

        // e.g. 'Blue top'
        string traitName;

        // e.g. TraitCategory.Name.Top
        TraitCategory.Name traitType;

        // The row-major byte array of the 2d version of a Trait
        bytes colorMap;

        // The row-major byte array of the 3d version of a Trait
        bytes zMap;

        // The DataMinter contract responsible for this trait
        /// @dev Cast as not an address
        address dataMinterContract;

        // Address of creator
        address creatorAddress;

        // Name of creator
        string creatorName;

        // Which Release the Trait was in
        string release;
    }

    // Event for when all approvals are invalidated
    event AllOperatorApprovalsInvalidated(uint256 indexed tokenId);

}

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

library TraitCategory {

    enum Name {
        None, // 0
        Head, // 1
        Hair, // 2
        Face, // 3
        Accessory, // 4
        Top, // 5
        Bottom, // 6
        Shoes // 7
    }

    function toString(Name name) public pure returns (string memory) {
        if (name == Name.Head) return "Head";
        if (name == Name.Hair) return "Hair";
        if (name == Name.Face) return "Face";
        if (name == Name.Accessory) return "Accessory";
        if (name == Name.Top) return "Top";
        if (name == Name.Bottom) return "Bottom";
        if (name == Name.Shoes) return "Shoes";
        return "";
    }

}

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

import { IChonkStorage } from "../interfaces/IChonkStorage.sol";
import { ITraitStorage } from "../interfaces/ITraitStorage.sol";
import { TraitCategory } from "../TraitCategory.sol";
import { Utils } from "../common/Utils.sol";

contract TraitRenderer {

    struct Ghost {
        bytes colorMap;
        bytes zMap;
    }

    Ghost public ghost;

    string private constant SVG_START = '<svg shape-rendering="crispEdges" viewBox="0 0 30 30" fill="none" xmlns="http://www.w3.org/2000/svg"><style>rect{width:1px; height: 1px;} .bg{width:30px; height: 30px;} </style><rect class="bg" fill="#0D6E9D"/>';

    function renderAsDataUri(
        uint256 _tokenId,
        ITraitStorage.StoredTrait memory trait,
        ITraitStorage.TraitMetadata memory metadata,
        string memory ghostSvg,
        string memory traitSvg,
        string[2] memory descriptionParts
    ) public pure returns (string memory) {
        string memory fullSvg;
        string memory attributes;

        if (trait.isRevealed) {
            attributes = string.concat(
                '"attributes":[',
                stringTrait(
                    TraitCategory.toString(trait.traitType),
                    metadata.traitName
                ),
                ',',
                stringTrait(
                    'Creator',
                    metadata.creatorName
                ),
                ',',
                stringTrait(
                    'Release',
                    metadata.release
                ),
                ']'
            );
        } else {
            attributes = '"attributes":[]';
            traitSvg = '<svg></svg>';
        }

        fullSvg = wrapWithSvgTag(string.concat(ghostSvg, traitSvg));

        string memory image = string.concat(
            '"image":"data:image/svg+xml;base64,',
            Utils.encode(bytes(fullSvg)),
            '"'
        );

        string memory json = string.concat(
            '{"name":"Chonk Trait #',
            Utils.toString(_tokenId),
            '","description":"',
            descriptionParts[0],
            Utils.toString(_tokenId),
            descriptionParts[1],
            '",',
            attributes,
            ',',
            image,
            '}'
        );

        return string.concat("data:application/json;base64,", Utils.encode(bytes(json)));
    }

    // Add a getter function since the constant is private
    // TODO: needed? not used anywhere
    function getSvgStart() public pure returns (string memory) {
        return SVG_START;
    }

    // Update any functions that need the SVG_START, for example:
    function wrapWithSvgTag(string memory content) public pure returns (string memory) {
        return string.concat(SVG_START, content, '</svg>');
    }

    function createSvgFromPixels(bytes memory _pixels) public pure returns (bytes memory svgParts) {
        string[16] memory hexSymbols = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
        string[30] memory coords = ["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29"];

        for (uint i; i < 4500; i += 5) {
            if (_pixels[i] > 0) {
                uint x = (i / 5) % 30;
                uint y = (i / 5) / 30;

                bytes memory color = abi.encodePacked(
                    hexSymbols[uint8(_pixels[i + 2]) >> 4],
                    hexSymbols[uint8(_pixels[i + 2]) & 0xf],
                    hexSymbols[uint8(_pixels[i + 3]) >> 4],
                    hexSymbols[uint8(_pixels[i + 3]) & 0xf],
                    hexSymbols[uint8(_pixels[i + 4]) >> 4],
                    hexSymbols[uint8(_pixels[i + 4]) & 0xf]
                );

                svgParts = abi.encodePacked(
                    svgParts,
                    '<rect x="', coords[x],
                    '" y="', coords[y],
                    '" width="1" height="1" fill="#', color, '"/>'
                );
            }
        }
    }

    function getTraitImage(bytes memory colorMap) public pure returns (bytes memory) {
        uint256 length = colorMap.length;
        // require(length > 0 && length % 5 == 0, "Invalid trait bytes length"); //TODO: put back in... only we can add a colorMap so do we need it?

        bytes memory pixels = new bytes(30 * 30 * 5); // 30x30 grid with 5 bytes per pixel
        uint256 pixelCount = length / 5;

        for (uint256 i; i < pixelCount; i++) {
            uint256 offset = i * 5;

            uint8 x = uint8(colorMap[offset]);
            uint8 y = uint8(colorMap[offset + 1]);
            uint256 index = (uint256(y) * 30 + uint256(x)) * 5;

            // Set the pixel data in the pixels array
            unchecked {
                pixels[index] = colorMap[offset];
                pixels[index + 1] = colorMap[offset + 1];
                pixels[index + 2] = colorMap[offset + 2];
                pixels[index + 3] = colorMap[offset + 3];
                pixels[index + 4] = colorMap[offset + 4];
            }
        }

        return pixels;
    }

    function getGhostSvg() public view returns (string memory svg) {
        bytes memory pixels = getTraitImage(ghost.colorMap);
        bytes memory svgParts = createSvgFromPixels(pixels);

        return string(abi.encodePacked('<g id="ghost" class="g" style="opacity: 50%;">', svgParts, '</g>'));
    }

    function setGhostMaps(bytes memory _colorMap, bytes memory _zMap) public  {
        ghost.colorMap = _colorMap;
        ghost.zMap = _zMap;
    }

    function getTraitImageSvg(bytes memory colorMap) public pure returns (string memory svg) {
        bytes memory pixels = getTraitImage(colorMap);
        bytes memory svgParts = createSvgFromPixels(pixels);
        return string(abi.encodePacked('<g id="Trait">', svgParts, '</g>'));
    }

    function getSvgAndMetadataTrait(
        ITraitStorage.StoredTrait memory trait,
        uint256 traitId,
        ITraitStorage.TraitMetadata memory metadata
    ) public pure returns(string memory traitSvg, string memory traitAttributes) {
        if (trait.isRevealed && traitId > 0) {
            traitAttributes = stringTrait(
                TraitCategory.toString(metadata.traitType),
                metadata.traitName
            );

            traitSvg = getTraitImageSvg(metadata.colorMap);
        } else {
            traitAttributes = '{}';
            traitSvg = '<svg></svg>';
        }
    }

    function getSVGZmapAndMetadataTrait(
        ITraitStorage.StoredTrait memory trait,
        uint256 traitId,
        ITraitStorage.TraitMetadata memory metadata
    ) public pure returns(
        string memory traitSvg,
        bytes memory traitZmap,
        string memory traitAttributes
    ) {
        if (trait.isRevealed && traitId > 0) {
            traitSvg = getTraitImageSvg(metadata.colorMap);

            traitAttributes = stringTrait(
                TraitCategory.toString(metadata.traitType),
                metadata.traitName
            );

            traitZmap = metadata.zMap;
        } else {
            traitSvg = '<svg></svg>';
            traitAttributes = '{}';
            traitZmap = '';
        }
    }

    function callGetSvgAndMetadataTrait(
        uint256 traitId,
        string memory _traitsSvg,
        string memory _traitsAttributes,
        ITraitStorage.StoredTrait memory storedTrait,
        ITraitStorage.TraitMetadata memory metadata
    ) public pure returns (string memory traitsSvg, string memory traitsAttributes) {
        string memory traitAttribute;
        string memory traitSvg;

        (traitSvg, traitAttribute) = getSvgAndMetadataTrait(storedTrait, traitId, metadata);

        if (bytes(_traitsAttributes).length == 0) {
            traitsSvg = traitSvg;
            traitsAttributes = traitAttribute;
        } else {
            traitsSvg = string.concat(_traitsSvg, traitSvg);
            traitsAttributes = string.concat(_traitsAttributes, ',', traitAttribute);
        }
    }

    function callGetSVGZmapAndMetadataTrait(
        uint256 traitId,
        string memory _traitsSvg,
        string memory _traitsAttributes,
        bytes memory _traitZMaps,
        ITraitStorage.StoredTrait memory storedTrait,
        ITraitStorage.TraitMetadata memory metadata
    ) public pure returns (
        string memory traitsSvg,
        string memory traitsAttributes,
        bytes memory traitZMaps
    ) {
        string memory traitAttribute;
        string memory traitSvg;
        bytes memory traitZMap;

        (traitSvg, traitZMap, traitAttribute) = getSVGZmapAndMetadataTrait(storedTrait, traitId, metadata);

        if (bytes(_traitsAttributes).length == 0) {
            traitsSvg = traitSvg;
            traitsAttributes = traitAttribute;
            traitZMaps = traitZMap;
        } else {
            traitsSvg = string.concat(_traitsSvg, traitSvg);
            traitsAttributes = string.concat(_traitsAttributes, ',', traitAttribute);
            traitZMaps = bytes.concat(_traitZMaps, traitZMap);
        }
    }

    function getSvgAndMetadata(
        IChonkStorage.StoredChonk memory storedChonk,
        function(uint256, string memory, string memory) external view returns (string memory, string memory) callGetSvgAndMetadataTraitFn
    ) public view returns (string memory traitsSvg, string memory traitsAttributes) {
        if (storedChonk.shoesId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.shoesId, traitsSvg, traitsAttributes);

        if (storedChonk.bottomId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.bottomId, traitsSvg, traitsAttributes);

        if (storedChonk.topId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.topId, traitsSvg, traitsAttributes);

        if (storedChonk.hairId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.hairId, traitsSvg, traitsAttributes);

        if (storedChonk.faceId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.faceId, traitsSvg, traitsAttributes);

        if (storedChonk.headId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.headId, traitsSvg, traitsAttributes);

        if (storedChonk.accessoryId > 0)
            (traitsSvg, traitsAttributes) = callGetSvgAndMetadataTraitFn(storedChonk.accessoryId, traitsSvg, traitsAttributes);
    }

    function getSvgZmapsAndMetadata(
        IChonkStorage.StoredChonk memory storedChonk,
        function(uint256, string memory, string memory, bytes memory) external view returns (string memory, string memory, bytes memory) callGetSVGZmapAndMetadataTraitFn
    ) public view returns (string memory traitsSvg, bytes memory traitZMaps, string memory traitsAttributes) {
        if (storedChonk.shoesId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.shoesId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.bottomId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.bottomId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.topId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.topId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.hairId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.hairId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.faceId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.faceId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.headId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.headId, traitsSvg, traitsAttributes, traitZMaps);

        if (storedChonk.accessoryId > 0)
            (traitsSvg, traitsAttributes, traitZMaps) = callGetSVGZmapAndMetadataTraitFn(storedChonk.accessoryId, traitsSvg, traitsAttributes, traitZMaps);
    }

    function stringTrait(string memory traitName, string memory traitValue) internal pure returns (string memory) {
        return string.concat(
            '{"trait_type":"',
                traitName,
            '","value":"',
                traitValue,
            '"}'
        );
    }
}

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

// OpenZeppelin/Solady Imports
import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { ERC721Enumerable } from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import { IERC165 } from  "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { MerkleProofLib } from "solady/utils/MerkleProofLib.sol";
import { Ownable } from "solady/auth/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

// ERC-6551 Imports
import { IAccountImplementation } from "./interfaces/TBABoilerplate/IAccountImplementation.sol";
import { IAccountProxy } from "./interfaces/TBABoilerplate/IAccountProxy.sol";
import { IRegistry } from  "./interfaces/TBABoilerplate/IRegistry.sol";

// Renderers
import { MainRenderer2D } from "./renderers/MainRenderer2D.sol";
import { MainRenderer3D } from "./renderers/MainRenderer3D.sol";

// The Traits ERC-721 Contract
import { ChonkTraits } from "./ChonkTraits.sol";
import { ChonkEquipHelper } from "./ChonkEquipHelper.sol";

// Associated Interfaces and Libraries
import { IERC4906 } from "./interfaces/IERC4906.sol";
import { IChonkStorage } from "./interfaces/IChonkStorage.sol";
import { ITraitStorage } from "./interfaces/ITraitStorage.sol";
import { TraitCategory } from "./TraitCategory.sol";

// Other Chonks Associated Contracts
import { ChonksMarket } from "./ChonksMarket.sol";
import { FirstReleaseDataMinter } from "./FirstReleaseDataMinter.sol";

/*
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:cllllllllllllllllllllllllllllllllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:clllxOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ccldOOOOOOO0KKKxllldOOOOOOOOOOOO0KKKxllldOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXWMNl   ;kOOOOOOOOOOOXWMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXMMWl   ;kkkkkkkkkkkOXMMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxxkOOOOOOOXMMWl   ,dxxxxxxxxxxxKWMWl   ;kOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:coooxOOOOOOOKNNXd'.'cxkkkxxkkkkkk0XNXd'.'lkOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;:oOOOOOOOOOOOOOkkOOOOOOOOOOOOOOOOOOkkOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:lddxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::oOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOo::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okkkkkkkkkkkkkkkkkkkkkkkkkkkkxxddl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:lxxxxxxxxxxxxxxxxxxxxxxxxxxxxl::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:cllldxkxxxxkkkkkkkkkkkkkkkkkkkkkxdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;clllxOOOOOOOOkkkOOOOOOOOOOOOOOkkkOOOOOOOOdlllc:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:okOOOOOOOOOOkxxxkOOOOOOOOOOOOkxxxkOOOOOOOOOOko:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOkkkOOOOkkkkkOOOOOOOOOOOOkkxkkOOOOkkkOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOkxxxkOOOOOOOOOOOOOOOOOOOOOOOOOOOOkxxxkOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldxddoooxOOOOOOOOOOOOOOOOOOOOOOOOOOOOxoooddxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::oOOOOOOOOOOOOOOOOOOOOOOOOOOOOo::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOkxdxkOOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOOOOOo:::okOOOOOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOkxddl:;:lddxxkOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:oOOOOOOOo::::;;;:::::oOOOOOOOo:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:ldddddxdl:;;;;;;;;;;:ldxxxxxdl:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::::;;;;;;;;;;;;:::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
*/

contract ChonksMain is IChonkStorage, IERC165, ERC721Enumerable, Ownable, IERC4906, ReentrancyGuard {

    // ERC-6551 Boilerplate addresses
    IRegistry constant REGISTRY = IRegistry(0x000000006551c19487814612e58FE06813775758);
    address constant ACCOUNT_PROXY = 0x55266d75D1a14E4572138116aF39863Ed6596E7F;
    address constant ACCOUNT_IMPLEMENTATION = 0x41C8f39463A868d3A88af00cd0fe7102F30E44eC;

    // constants
    uint8 constant MAX_MINT_AMOUNT = 10;

    // Storage for Body metadata
    mapping(uint256 => IChonkStorage.BodyMetadata) public bodyIndexToMetadata;

    /// The address of the ERC-721 Traits contract
    ChonkTraits public traitsContract;

    // The address of the ChonksMarket contract
    ChonksMarket public marketplace;

    // The address of the ChonkEquipHelper helper contract
    ChonkEquipHelper public chonkEquipHelper;

    // The contract that handles rendering and minting the first release of traits
    FirstReleaseDataMinter public firstReleaseDataMinter;

    // The render contract that handles SVG generation
    MainRenderer2D public mainRenderer2D;

    // The render contract that handles 3d generation
    MainRenderer3D public mainRenderer3D;

    uint256 public maxTraitsToOutput = 99;

    uint256 public nextTokenId;

    address public withdrawAddress;

    uint256 public price;

    uint256 public initialMintStartTime;

    string[2] descriptionParts;

    // The date when contract was deployed, a year after which, certain functions can't be called by the owner
    uint256 public immutable deploymentTime;

    mapping(uint256 tokenID => StoredChonk chonk) public chonkTokens;

    // Mapping of tokenID to the TBA account address
    mapping(uint256 => address) public tokenIdToTBAAccountAddress;

    // Mapping of the TBA account address to its tokenId. Great for getting from Trait Token ID to Chonk Token ID or Owner
    mapping(address => uint256) public tbaAddressToTokenId;

    // Chonk ID to approved addresses
    mapping(uint256 chonkId => address[] operators) public chonkIdToApprovedOperators;

    // Mappings for Merkles
    mapping(address => bool) public collectionsAddressDidUse;
    mapping(address => bool) public friendsAddressDidUse;
    mapping(address => bool) public creatorsAddressDidUse;

    /// Merkle Roots
    bytes32 public collectionsMerkle;
    bytes32 public friendsMerkle;
    bytes32 public creatorsMerkle;

    /// Errors
    error CanOnlyReserveFirstTwo();
    error CantTransferDuringMint();
    error CantTransferToTBAs();
    error ChonkDoesntExist();
    error FirstReleaseDataMinterNotSet();
    error IncorrectChonkOwner();
    error IncorrectTBAOwner();
    error IncorrectTraitType();
    error InsufficientFunds();
    error InvalidBodyIndex();
    error InvalidColor();
    error InvalidTraitCount();
    error InvalidTraitCategory();
    error InvalidMintAmount();
    error MintEnded();
    error MintNotStarted();
    error MintStartTimeAlreadySet();
    error Timelocked();
    error TraitLengthsMustMatch();
    error UseUnequip();
    error WithdrawFailed();

    /// Modifier
    modifier onlyChonkOwner(uint256 _chonkId) {
        if (msg.sender != ownerOf(_chonkId)) revert IncorrectChonkOwner();
        _;
    }

    /// Constructor
    constructor() ERC721("Chonks", "CHONKS") {
        _initializeOwner(msg.sender);
        deploymentTime = block.timestamp;
    }

    function teamReserve() public onlyOwner {
        if (totalSupply() > 2) revert CanOnlyReserveFirstTwo();
        _mintInternal(msg.sender, 2, 7);
    }

    function teamMint(address _to, uint256 _amount, uint8 _traitCount) public onlyOwner {
        if (_traitCount < 4 || _traitCount > 7) revert InvalidTraitCount();
        if (initialMintStartTime == 0 || block.timestamp < initialMintStartTime) revert MintNotStarted();
        if (block.timestamp > initialMintStartTime + 26 hours) revert MintEnded();

        _mintInternal(_to, _amount, _traitCount);
    }

    function mint(uint256 _amount, bytes32[] memory _merkleProof) public payable {
        if (address(firstReleaseDataMinter) == address(0)) revert FirstReleaseDataMinterNotSet();

        if (_amount == 0 || _amount > MAX_MINT_AMOUNT) revert InvalidMintAmount();
        if (initialMintStartTime == 0 || block.timestamp < initialMintStartTime) revert MintNotStarted();
        if (block.timestamp > initialMintStartTime + 24 hours) revert MintEnded();
        if (msg.value != price * _amount) revert InsufficientFunds();

        uint8 traitCount = 4;
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        if (MerkleProofLib.verify(_merkleProof, collectionsMerkle, leaf)) {
            if (!collectionsAddressDidUse[msg.sender]) {
                traitCount = 5;
                collectionsAddressDidUse[msg.sender] = true;
            }
        } else if (MerkleProofLib.verify(_merkleProof, friendsMerkle, leaf)) {
            if (!friendsAddressDidUse[msg.sender]) {
                traitCount = 6;
                friendsAddressDidUse[msg.sender] = true;
            }
        } else if (MerkleProofLib.verify(_merkleProof, creatorsMerkle, leaf)) {
            if (!creatorsAddressDidUse[msg.sender]) {
                traitCount = 7;
                creatorsAddressDidUse[msg.sender] = true;
            }
        }

        _mintInternal(msg.sender, _amount, traitCount);
    }

    function _mintInternal(address _to, uint256 _amount, uint8 _traitCount) internal {
        for (uint i; i < _amount; ++i) {
            uint256 tokenId = ++nextTokenId;
            _mint(_to, tokenId);

            address tokenBoundAccountAddress = REGISTRY.createAccount(
                ACCOUNT_PROXY, // implementation address
                0, // salt
                8453, // chainId
                address(this), // tokenContract
                tokenId // tokenId
            );

            // Set the cross-reference between tokenId and TBA account address
            tokenIdToTBAAccountAddress[tokenId] = tokenBoundAccountAddress;
            tbaAddressToTokenId[tokenBoundAccountAddress] = tokenId;

            // Initialize the TBA
            IAccountProxy(payable(tokenBoundAccountAddress)).initialize(address(ACCOUNT_IMPLEMENTATION));

            // Mint Traits to equip below
            uint256[] memory traitsIds = firstReleaseDataMinter.safeMintMany(tokenBoundAccountAddress, _traitCount);

            // Initialize the Chonk
            StoredChonk storage chonk = chonkTokens[tokenId];
            chonk.tokenId = tokenId;
            // This randomly picks your Chonk skin color but you can change it any time.
            chonk.bodyIndex = uint8(uint256(keccak256(abi.encodePacked(tokenId))) % 5); // even chance for 5 different bodies
            // Set the default background color
            chonk.backgroundColor = "0D6E9D";

            chonk.shoesId = traitsIds[0];
            chonk.bottomId = traitsIds[1];
            chonk.topId = traitsIds[2];
            chonk.hairId = traitsIds[3];
        }
    }

    function getOwnerAndTBAAddressForChonkId(uint256 _chonkId) public view returns (address owner, address tbaAddress) {
        owner = ownerOf(_chonkId);
        tbaAddress = tokenIdToTBAAccountAddress[_chonkId];
    }

    /// Equip/Unequip Traits
    function equip(uint256 _chonkTokenId, uint256 _traitTokenId) public onlyChonkOwner(_chonkTokenId) {
        if (_traitTokenId == 0) revert UseUnequip();

        TraitCategory.Name traitType = chonkEquipHelper.equipValidation(_chonkTokenId, _traitTokenId);
        _setTrait(_chonkTokenId, traitType, _traitTokenId);

        emit Equip(ownerOf(_chonkTokenId), _chonkTokenId, _traitTokenId, uint8(traitType));
    }

    function unequip(uint256 _chonkTokenId, TraitCategory.Name traitType) public onlyChonkOwner(_chonkTokenId) {
        _setTrait(_chonkTokenId, traitType, 0);

        emit Unequip(ownerOf(_chonkTokenId), _chonkTokenId, uint8(traitType));
    }

    function _setTrait(uint256 _chonkTokenId, TraitCategory.Name traitType, uint256 _traitTokenId) internal {
        if (traitType == TraitCategory.Name.Head)           chonkTokens[_chonkTokenId].headId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Hair)      chonkTokens[_chonkTokenId].hairId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Face)      chonkTokens[_chonkTokenId].faceId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Accessory) chonkTokens[_chonkTokenId].accessoryId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Top)       chonkTokens[_chonkTokenId].topId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Bottom)    chonkTokens[_chonkTokenId].bottomId = _traitTokenId;
        else if (traitType == TraitCategory.Name.Shoes)     chonkTokens[_chonkTokenId].shoesId = _traitTokenId;
    }

    function unequipAll(uint256 _chonkTokenId) public onlyChonkOwner(_chonkTokenId) {
        StoredChonk storage chonk = chonkTokens[_chonkTokenId];

        chonk.headId = 0;
        chonk.hairId = 0;
        chonk.faceId = 0;
        chonk.accessoryId = 0;
        chonk.topId = 0;
        chonk.bottomId = 0;
        chonk.shoesId = 0;

        emit UnequipAll(ownerOf(_chonkTokenId), _chonkTokenId);
    }

    function equipMany(
      uint256 _chonkTokenId,
      uint256[] calldata _traitTokenIds,
      uint8[] calldata _traitCategories
    ) public onlyChonkOwner(_chonkTokenId) {
        if (_traitTokenIds.length != _traitCategories.length) revert TraitLengthsMustMatch();

        StoredChonk storage chonk = chonkTokens[_chonkTokenId];
        address owner = ownerOf(_chonkTokenId);
        address tba = tokenIdToTBAAccountAddress[_chonkTokenId];

        for (uint256 i; i < _traitTokenIds.length; i++) {
            uint256 _traitTokenId = _traitTokenIds[i];
            uint8 _traitCategory = _traitCategories[i];

            if (_traitTokenId == 0) revert UseUnequip();
            if (_traitCategory == 0 || _traitCategory > 7) revert InvalidTraitCategory();

            TraitCategory.Name traitCategoryEnum = TraitCategory.Name(_traitCategory);

            chonkEquipHelper.performValidations(tba, _traitTokenId, traitCategoryEnum);

            if (_traitCategory == uint8(TraitCategory.Name.Head)) {
                chonk.headId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Hair)) {
                chonk.hairId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Face)) {
                chonk.faceId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Accessory)) {
                chonk.accessoryId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Top)) {
                chonk.topId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Bottom)) {
                chonk.bottomId = _traitTokenId;
            } else if (_traitCategory == uint8(TraitCategory.Name.Shoes)) {
                chonk.shoesId = _traitTokenId;
            }

            emit Equip(owner, _chonkTokenId, _traitTokenId, _traitCategory);
        }

        emit EquipAll(owner, _chonkTokenId);
    }

    /// tokenURI/Rendering

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        if (!_exists(_tokenId)) revert ChonkDoesntExist();
        return renderAsDataUri(_tokenId);
    }

    /// @param _index The index of the body to get the SVG for
    /// @return svg The SVG for the body
    function getBodyImageSvg(uint256 _index) public view returns (string memory) {
        return mainRenderer2D.colorMapToSVG(bodyIndexToMetadata[_index].colorMap);
    }

    function getBodySVGZmapsAndMetadata(IChonkStorage.StoredChonk memory storedChonk) public view returns (string memory, bytes memory , string memory) {
        return (
            getBodyImageSvg(storedChonk.bodyIndex),
            bodyIndexToMetadata[storedChonk.bodyIndex].zMap,
            mainRenderer2D.stringTrait('Body Type', bodyIndexToMetadata[storedChonk.bodyIndex].bodyName)
        );
    }

    function getBodySvgAndMetadata(IChonkStorage.StoredChonk memory storedChonk) public view returns (string memory, string memory) {
        return (
            getBodyImageSvg(storedChonk.bodyIndex),
            mainRenderer2D.stringTrait('Body Type', bodyIndexToMetadata[storedChonk.bodyIndex].bodyName)
        );
    }

    // Returns all necessary ownership info for a Trait
    function getFullPictureForTrait(uint256 _chonkTraitTokenId) public view returns (
        address traitOwnerTBA,
        uint256 chonkTokenId,
        address chonkOwner,
        bool isEquipped
    ) {
        traitOwnerTBA = traitsContract.ownerOf(_chonkTraitTokenId);
        chonkTokenId = tbaAddressToTokenId[traitOwnerTBA];
        chonkOwner = ownerOf(chonkTokenId);
        isEquipped = checkIfTraitIsEquipped(chonkTokenId, _chonkTraitTokenId);
    }

    /// @notice Returns the TBA address for a Chonk
    function getTBAAddressForChonkId(uint256 _chonkId) public view returns (address) {
        return tokenIdToTBAAccountAddress[_chonkId];
    }

    /// @notice Returns the ChonkId for a TBA
    function getChonkIdForTBAAddress(address _tbaAddress) public view returns (uint256) {
        return tbaAddressToTokenId[_tbaAddress];
    }

    function getTraitsForChonkId(uint256 _chonkId) public view returns (uint256[] memory traitTokens) {
        address tbaAddress = getTBAAddressForChonkId(_chonkId);
        traitTokens = traitsContract.walletOfOwner(tbaAddress);
    }

    function getBackpackSVGs(uint256 _tokenId) public view returns (string memory) {
        return mainRenderer2D.getBackpackSVGs(
            address(traitsContract),
            getTBAAddressForChonkId(_tokenId),
            maxTraitsToOutput
        );
    }

    function _gatherData(uint256 _tokenId) internal view returns (
        string memory bodySvg,
        bytes  memory bodyZmap,
        string memory traitsSvg,
        bytes  memory traitZmaps,
        string memory traitsAttributes,
        string memory backpackSVGs,
        bytes  memory fullZmap,
        ChonkData memory chonkdata
    ) {
        StoredChonk memory storedChonk = getChonk(_tokenId);
        (bodySvg, bodyZmap,) = getBodySVGZmapsAndMetadata(storedChonk);
        (traitsSvg, traitZmaps, traitsAttributes) = traitsContract.getSvgZmapsAndMetadata(storedChonk);
        backpackSVGs = getBackpackSVGs(_tokenId);

        chonkdata.backgroundColor = storedChonk.backgroundColor;
        chonkdata.numOfItemsInBackpack = getTraitsForChonkId(_tokenId).length;
        chonkdata.bodyName =  bodyIndexToMetadata[storedChonk.bodyIndex].bodyName;
        chonkdata.descriptionParts = descriptionParts; // stuffing descriptionParts in here to avoid stack too deep

        fullZmap = bytes.concat(bodyZmap, traitZmaps);
    }

    function renderAsDataUri(uint256 _tokenId) public view returns (string memory) {
        return (getChonk(_tokenId).render3D) ? renderAsDataUri3D(_tokenId) : renderAsDataUri2D(_tokenId);
    }

    function renderAsDataUri2D(uint256 _tokenId) public view returns (string memory) {
        (
            string memory bodySvg,,
            string memory traitsSvg,,
            string memory traitsAttributes,
            string memory backpackSVGs,,
            ChonkData memory chonkdata
        ) = _gatherData(_tokenId);

        return mainRenderer2D.renderAsDataUri(
            _tokenId,
            bodySvg,
            traitsSvg,
            traitsAttributes,
            backpackSVGs,
            chonkdata
        );
    }

    function renderAsDataUri3D(uint256 _tokenId) public view returns (string memory) {
        (
            string memory bodySvg,,
            string memory traitsSvg,,
            string memory traitsAttributes,,
            bytes  memory fullZmap,
            ChonkData memory chonkdata
        ) = _gatherData(_tokenId);

        return mainRenderer3D.renderAsDataUri(
            _tokenId,
            bodySvg,
            traitsSvg,
            traitsAttributes,
            fullZmap,
            chonkdata
        );
    }

    function chonkMakeover(
        uint256 _chonkTokenId,
        uint256[] calldata _traitTokenIds,
        uint8[] calldata _traitCategories,
        uint8 _bodyIndex,
        string memory _backgroundColor,
        bool _render3D
    ) public onlyChonkOwner(_chonkTokenId) {
        equipMany(_chonkTokenId, _traitTokenIds, _traitCategories);
        setBodyIndex(_chonkTokenId, _bodyIndex);
        setBackgroundColor(_chonkTokenId, _backgroundColor);
        setTokenRender3D(_chonkTokenId, _render3D);
    }

    /// Getters

    // Gets complete zMap for a Chonk, body and traits
    function getChonkZMap(uint256 _tokenId) public view returns (string memory) {
        bytes memory traitZmaps;

        (, traitZmaps,) = traitsContract.getSvgZmapsAndMetadata(getChonk(_tokenId));

        return string.concat(
            getBodyZMap(_tokenId),
            string(traitZmaps)
        );
    }

    function getBodyZMap(uint256 _tokenId) public view returns (string memory) {
        bytes memory bodyZmap;

        (, bodyZmap,) = getBodySVGZmapsAndMetadata(getChonk(_tokenId));

        return string(bodyZmap);
    }

    function getChonk(uint256 _tokenId) public view returns (IChonkStorage.StoredChonk memory) {
        return chonkTokens[_tokenId];
    }

    function checkIfTraitIsEquipped(uint256 _chonkId, uint256 _traitId) public view returns (bool) {
        IChonkStorage.StoredChonk memory storedChonk = getChonk(_chonkId);
        return storedChonk.headId == _traitId ||
            storedChonk.hairId == _traitId ||
            storedChonk.faceId == _traitId ||
            storedChonk.accessoryId == _traitId ||
            storedChonk.topId == _traitId ||
            storedChonk.bottomId == _traitId ||
            storedChonk.shoesId == _traitId;
    }

    /// @dev Returns the token ids the end user's wallet owns
    function walletOfOwner(address _owner) public view returns (uint256[] memory) {
        uint256 tokenCount = balanceOf(_owner);

        uint256[] memory tokensId = new uint256[](tokenCount);
        for (uint256 i; i < tokenCount; ++i){
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
        }

        return tokensId;
    }

    /// @notice Returns the timestamp one year after contract deployment
    function oneYearFromDeployment() public view returns (uint256) {
        return deploymentTime + 365 days;
    }

    function isTimelocked() public view returns (bool) {
        return block.timestamp > oneYearFromDeployment();
    }

    /// Ownable Functions

    function addNewBody(uint256 _bodyIndex, string memory _bodyName, bytes memory _colorMap, bytes memory _zMap) public onlyOwner {
        if (isTimelocked()) revert Timelocked();

        BodyMetadata storage metadata = bodyIndexToMetadata[_bodyIndex];
        metadata.bodyIndex = _bodyIndex;
        metadata.bodyName = _bodyName;
        metadata.colorMap = _colorMap;
        metadata.zMap = _zMap;
    }

    function setTraitsContract(ChonkTraits _address) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        traitsContract = _address;
    }

    function setFirstReleaseDataMinter(address _dataContract) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        firstReleaseDataMinter = FirstReleaseDataMinter(_dataContract);
    }

    function setMainRenderer2D(address _mainRenderer2D) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        mainRenderer2D = MainRenderer2D(_mainRenderer2D);
    }

    function setMainRenderer3D(address _mainRenderer3D) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        mainRenderer3D = MainRenderer3D(_mainRenderer3D);
    }

    function setMarketplace(address _marketplace) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        marketplace = ChonksMarket(_marketplace);
    }

    function setChonkEquipHelper(address _chonkEquipHelper) public onlyOwner {
        if (isTimelocked()) revert Timelocked();
        chonkEquipHelper = ChonkEquipHelper(_chonkEquipHelper);
    }

    function setMaxTraitsToOutput(uint256 _maxTraitsToOutput) public onlyOwner {
        maxTraitsToOutput = _maxTraitsToOutput;
    }

    function setMintStartTime(uint256 _initialMintStartTime) public onlyOwner {
        if (initialMintStartTime != 0) revert MintStartTimeAlreadySet();
        initialMintStartTime = _initialMintStartTime;
    }

    function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
        withdrawAddress = _withdrawAddress;
    }

    function setPrice(uint256 _priceInWei) public onlyOwner {
        price = _priceInWei;
    }

    function setFriendsMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
        friendsMerkle = _merkleRoot;
    }

    function setCollectionsMerkle(bytes32 _merkleRoot) public onlyOwner {
        collectionsMerkle = _merkleRoot;
    }

    function setCreatorsMerkle(bytes32 _merkleRoot) public onlyOwner {
        creatorsMerkle = _merkleRoot;
    }

    function setDescriptionParts(string[2] memory _descriptionParts) public onlyOwner {
        descriptionParts = _descriptionParts;
    }

    /// Public Setters

    function setBodyIndex(uint256 _chonkTokenId, uint8 _bodyIndex) public onlyChonkOwner(_chonkTokenId) {
        if (_bodyIndex > 4) revert InvalidBodyIndex();

        chonkTokens[_chonkTokenId].bodyIndex = _bodyIndex;
        emit BodyIndex(ownerOf(_chonkTokenId), _chonkTokenId, _bodyIndex );
    }

    function setTokenRender3D(uint256 _tokenId, bool _render3D) public onlyChonkOwner(_tokenId) {
        chonkTokens[_tokenId].render3D = _render3D;
        emit Render3D(ownerOf(_tokenId), _tokenId, _render3D);
    }

    function validateColor(string memory _color) internal pure {
        bytes memory colorBytes = bytes(_color);
        if (colorBytes.length != 6) revert InvalidColor();

        // Ensure all characters are valid hex characters (0-9, a-f, A-F)
        for (uint i; i < 6; i++) {
            if (
                !(colorBytes[i] >= 0x30 && colorBytes[i] <= 0x39) && // 0-9
                !(colorBytes[i] >= 0x41 && colorBytes[i] <= 0x46) && // A-F
                !(colorBytes[i] >= 0x61 && colorBytes[i] <= 0x66)    // a-f
            ) {
                revert InvalidColor(); // Invalid character found
            }
        }
    }

    function setBackgroundColor(uint256 _chonkTokenId, string memory _color) public onlyChonkOwner(_chonkTokenId) {
        validateColor(_color); // Call the helper function

        chonkTokens[_chonkTokenId].backgroundColor = _color;

        emit BackgroundColor(ownerOf(_chonkTokenId), _chonkTokenId, _color );
    }

    function setChonkAttributes(uint256 _tokenId, string memory _color, uint8 _bodyIndex, bool _render3D) public onlyChonkOwner(_tokenId) {
        validateColor(_color); // Call the helper function
        if (_bodyIndex > 4) revert InvalidBodyIndex();

        chonkTokens[_tokenId].backgroundColor = _color;
        chonkTokens[_tokenId].bodyIndex = _bodyIndex;
        chonkTokens[_tokenId].render3D = _render3D;
    }

    // Boilerplate

    function supportsInterface(bytes4 interfaceId) public view override(IERC165, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    // Override functions for marketplace compatibility
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override {
        if (from == address(0)) {
            super._beforeTokenTransfer(from, to, tokenId);
            return;
        }

        if (block.timestamp < initialMintStartTime + 24 hours) revert CantTransferDuringMint();

        // Ensure you can't transfer a Chonk to a TBA (Chonks can't hold Chonks)
         if (tbaAddressToTokenId[to] != 0) revert CantTransferToTBAs();

        // Cache TBA address and trait tokens to minimize external calls
        address tbaAddress = tokenIdToTBAAccountAddress[tokenId];

        uint256[] memory chonkIds = walletOfOwner(to);
        address[] memory tbas = new address[](chonkIds.length);
        for (uint256 j; j < chonkIds.length; ++j) {
            tbas[j] = tokenIdToTBAAccountAddress[chonkIds[j]];
        }

        marketplace.deleteChonkOfferBeforeTokenTransfer(tokenId);
        marketplace.deleteChonkBidsBeforeTokenTransfer(tokenId, to);

        uint256[] memory traitTokenIds = traitsContract.walletOfOwner(tbaAddress);
        for (uint256 i; i < traitTokenIds.length; ++i) {
            uint256 traitTokenId = traitTokenIds[i];

            // Clean up marketplace offers/bids
            marketplace.deleteTraitOffersBeforeTokenTransfer(traitTokenId);
            marketplace.deleteTraitBidsBeforeTokenTransfer(traitTokenId, tbas);

            // Clean up past approvals for new TBA owner
            traitsContract.invalidateAllOperatorApprovals(traitTokenId);
        }

        super._beforeTokenTransfer(from, to, tokenId);
    }

    function _afterTokenTransfer(address _from, address, uint256 _tokenId) internal virtual override {
        _invalidateAllOperatorApprovals(_tokenId, _from);
    }

    /// Approvals

    function getChonkIdToApprovedOperators(uint256 _chonkId) public view returns (address[] memory) {
        return chonkIdToApprovedOperators[_chonkId];
    }

    function approve(address _operator, uint256 _chonkId) public override(IERC721, ERC721) {
        if (msg.sender != ownerOf(_chonkId)) revert Unauthorized();

        _incrementApprovals(_chonkId, _operator);
        _approve(_operator, _chonkId);
    }

    function setApprovalForAllChonksMarketplace(uint256 _chonkId, address _operator, bool _approved) public {
        address owner = ownerOf(_chonkId);
        if (owner != msg.sender) revert Unauthorized();

        if (_approved) _incrementApprovals(_chonkId, _operator);
        _setApprovalForAll(owner, _operator, _approved);
    }

    // Please use the function above as it's more appropriate. Traditional marketplaces will use this
    function setApprovalForAll(address _operator, bool _approved) public override(IERC721, ERC721) {
        if (_approved) {
            uint256[] memory chonkIds = walletOfOwner(msg.sender);

            // Don't approve if the user doesn't own any Chonks
            if (chonkIds.length == 0) revert Unauthorized();

            for (uint i; i < chonkIds.length; ++i) {
                _incrementApprovals(chonkIds[i], _operator);
            }
        }

        _setApprovalForAll(msg.sender, _operator, _approved);
    }

    function _incrementApprovals(uint256 _chonkId, address _operator) private {
        address[] storage operators = chonkIdToApprovedOperators[_chonkId];
        operators.push(_operator);
    }

    /// @dev – Called on _afterTokenTransfer
    /// Prevents subsequent owners from using the previous owner's approvals
    function _invalidateAllOperatorApprovals(uint256 _chonkId, address _previousOwner) private {
        address[] memory approvals = chonkIdToApprovedOperators[_chonkId];
        address tbaForChonk = tokenIdToTBAAccountAddress[_chonkId];
        // may need to use tbaAddressToTokenId w/ msg.sender value and check that?

        // Invalidate all other approvals including the ChonksMarket
        for (uint256 i; i < approvals.length; ++i) {
            _setApprovalForAll(_previousOwner, approvals[i], false);
            _setApprovalForAll(tbaForChonk, approvals[i], false);
        }

        delete chonkIdToApprovedOperators[_chonkId];
    }

    /// Withdraw

    function withdraw() public onlyOwner {
        (bool success,) = payable(withdrawAddress).call{ value: address(this).balance }("");
        if (!success) revert WithdrawFailed();
    }

}

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

import { ChonksMain } from "./ChonksMain.sol";
import { ChonkTraits } from "./ChonkTraits.sol";
import { IChonkStorage } from "./interfaces/IChonkStorage.sol";
import { Ownable } from "solady/auth/Ownable.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract ChonksMarket is Ownable, ReentrancyGuard {

    // Structs

    // If a Chonk offer, sells the Chonk and all of its Traits, else just sells the Trait
    struct ChonkOffer {
        // How much for the Chonk
        uint256 priceInWei;
        // Who is selling (the end user wallet)
        address seller;
        // The TBA of the Chonk ID
        address sellerTBA;
        // An optional address to restrict the buyer to
        address onlySellTo;
        // Accompanying Trait IDs
        uint256[] traitIds;
        // An abi.encoded version of the traitIds
        bytes encodedTraitIds;
    }

    struct TraitOffer {
        // How much for the Chonk
        uint256 priceInWei;
        // Who is selling (the end user wallet)
        address seller;
        // The TBA of the Chonk ID
        address sellerTBA;
        // An optional address to restrict the buyer to
        address onlySellTo;
    }

    struct ChonkBid {
        // The address of the bidder
        address bidder;
        // The amount in Wei
        uint256 amountInWei;
        // Accompanying Trait IDs
        uint256[] traitIds;
        // An abi.encoded version of the traitIds
        bytes encodedTraitIds;
    }

    struct TraitBid {
        // The address of the bidder
        address bidder;
        // Chonk TBA
        address bidderTBA;
        // The amount in Wei
        uint256 amountInWei;
    }

    // Storage

    ChonksMain public immutable CHONKS_MAIN;
    ChonkTraits public immutable CHONK_TRAITS;

    uint256 public royaltyPercentage; // starts at 250 (for 2.5%)
    address public teamWallet;

    bool public paused = true;
    bool public pausabilityRevoked;

    // Offers

    mapping(uint256 chonkId => ChonkOffer chonkOffer) public chonkOffers;
    mapping(uint256 traitId => TraitOffer traitOffer) public traitOffers;

    // Bids

    mapping(uint256 chonkId => ChonkBid chonkBid) public chonkBids;
    mapping(uint256 traitId => TraitBid traitBid) public traitBids;

    // Funds

    mapping(address eoa => uint256 balance) public withdrawableFunds;

    // Approvals for TBA

    mapping(uint256 chonkId => address[] operators)
        public chonkIdToApprovedOperators;

    /// Errors

    error ApproveTheMarketplace();
    error BidderChanged();
    error BidIsTooLow();
    error CantAcceptYourOwnBid();
    error CantBeZero();
    error CantBidOnYourOwnChonk();
    error CantBidOnYourOwnTrait();
    error CantBuyYourOwnChonk();
    error CantBuyYourOwnTrait();
    error CMUnauthorized();
    error NoBidToAccept();
    error NoOfferToCancel();
    error NotYourBid();
    error NotYourChonk();
    error NotYourOffer();
    error NotYourTrait();
    error OfferDoesNotExist();
    error OnlySellToEOAs();
    error OnlyTraitContract();
    error Paused();
    error PausabilityRevoked();
    error TBANeedsToApproveMarketplace();
    error TraitEquipped();
    error TraitIdsChangedSinceBid();
    error TraitIdsChangedSinceListingRelist();
    error WithdrawFailed();
    error WrongAmount();
    error YouCantBuyThatChonk();
    error YouCantBuyThatTrait();

    /// Events (These map to the order of the functions below)

    // Chonk Events

    event ChonkOfferCanceled(
        uint256 indexed chonkId,
        address indexed seller
    );
    event ChonkOffered(
        uint256 indexed chonkId,
        uint256 indexed price,
        address indexed seller,
        address sellerTBA
    );
    event ChonkOfferedToAddress(
        uint256 indexed chonkId,
        uint256 indexed price,
        address indexed seller,
        address sellerTBA,
        address onlySellTo
    );
    event ChonkBought(
        uint256 indexed chonkId,
        address indexed buyer,
        uint256 indexed amountInWei,
        address seller
    );

    event ChonkBidWithdrawn(
        uint256 indexed chonkId,
        address indexed bidder,
        uint256 indexed amountInWei
    );
    event ChonkBidEntered(
        uint256 indexed chonkId,
        address indexed bidder,
        uint256 indexed amountInWei
    );
    event ChonkBidAccepted(
        uint256 indexed chonkId,
        uint256 indexed amountInWei,
        address indexed buyer,
        address seller
    );

    // Trait Events

    event TraitOfferCanceled(
        uint256 indexed traitId,
        address indexed seller
    );
    event TraitOffered(
        uint256 indexed traitId,
        uint256 indexed price,
        address indexed seller,
        address sellerTBA
    );
    event TraitOfferedToAddress(
        uint256 indexed traitId,
        uint256 indexed price,
        address indexed seller,
        address sellerTBA,
        address onlySellTo
    );
    event TraitBought(
        uint256 indexed traitId,
        address indexed buyerTBA,
        uint256 indexed amountInWei,
        address buyer,
        address seller
    );

    event TraitBidWithdrawn(
        uint256 indexed traitId,
        address indexed bidder,
        uint256 indexed amountInWei
    );
    event TraitBidEntered(
        uint256 indexed traitId,
        address indexed bidder,
        uint256 indexed amountInWei
    );
    event TraitBidAccepted(
        uint256 indexed traitId,
        uint256 indexed amountInWei,
        address indexed buyer,
        address seller
    );

    /// Modifiers

    modifier ensurePriceIsNotZero(uint256 _price) {
        if (_price == 0) revert CantBeZero();
        _;
    }

    modifier notPaused() {
        if (paused) revert Paused();
        _;
    }

    modifier onlyTraitContract() {
        if (msg.sender != address(CHONK_TRAITS)) revert OnlyTraitContract();
        _;
    }

    modifier onlyMainContract() {
        if (msg.sender != address(CHONKS_MAIN)) revert CMUnauthorized();
        _;
    }

    /// Constructor

    constructor(
        address _chonksMain,
        address _chonkTraits,
        uint8 _royaltyPercentage,
        address _teamWallet
    ) {
        _initializeOwner(msg.sender);

        CHONKS_MAIN = ChonksMain(_chonksMain);
        CHONK_TRAITS = ChonkTraits(_chonkTraits);
        royaltyPercentage = _royaltyPercentage;
        teamWallet = _teamWallet;
    }

    // GETTERS

    // Add a custom getter function
    function getChonkOffer(uint256 _chonkId) public view returns (
        uint256 priceInWei,
        address seller,
        address sellerTBA,
        address onlySellTo,
        uint256[] memory traitIds,
        bytes memory encodedTraitIds
    ) {
        ChonkOffer memory offer = chonkOffers[_chonkId];
        return (
            offer.priceInWei,
            offer.seller,
            offer.sellerTBA,
            offer.onlySellTo,
            offer.traitIds,
            offer.encodedTraitIds
        );
    }

    function getTraitOffer(uint256 _traitId) public view returns (
        uint256 priceInWei,
        address seller,
        address sellerTBA,
        address onlySellTo
    ) {
        TraitOffer memory offer = traitOffers[_traitId];
        return (
            offer.priceInWei,
            offer.seller,
            offer.sellerTBA,
            offer.onlySellTo
        );
    }

    function getChonkBid(uint256 _chonkId) public view returns (
        address bidder,
        uint256 amountInWei,
        uint256[] memory traitIds,
        bytes memory encodedTraitIds
    ) {
        ChonkBid memory bid = chonkBids[_chonkId];
        return (
            bid.bidder,
            bid.amountInWei,
            bid.traitIds,
            bid.encodedTraitIds
        );
    }

    function getTraitBid(uint256 _traitId) public view returns (
        address bidder,
        address bidderTBA,
        uint256 amountInWei
    ) {
        TraitBid memory bid = traitBids[_traitId];
        return (
            bid.bidder,
            bid.bidderTBA,
            bid.amountInWei
        );
    }

    /*
    Chonk

    Cancel, Offer, Buy
    Withdraw Bid, Bid, Accept Bid
    */

    function cancelOfferChonk(uint256 _chonkId) public {
        if (chonkOffers[_chonkId].seller != msg.sender) revert NotYourOffer();

        delete chonkOffers[_chonkId];

        emit ChonkOfferCanceled(_chonkId, msg.sender);
    }

    function offerChonk(uint256 _chonkId, uint256 _priceInWei) public notPaused ensurePriceIsNotZero(_priceInWei) {
        (address owner, address tbaAddress) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_chonkId);

        _offerChonk(_chonkId, _priceInWei, address(0), owner, tbaAddress);

        emit ChonkOffered(_chonkId, _priceInWei, owner, tbaAddress);
    }

    function offerChonkToAddress(
        uint256 _chonkId,
        uint256 _priceInWei,
        address _onlySellTo
    ) public notPaused ensurePriceIsNotZero(_priceInWei) {
        (address owner, address tbaAddress) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_chonkId);

        _offerChonk(_chonkId, _priceInWei, _onlySellTo, owner, tbaAddress);

        emit ChonkOfferedToAddress(_chonkId, _priceInWei, owner, tbaAddress, _onlySellTo);
    }

    function _offerChonk(uint256 _chonkId, uint256 _priceInWei, address _onlySellTo, address _seller, address _sellerTBA) internal {
        if (_seller != msg.sender) revert NotYourChonk();

        (uint256[] memory traitIds , bytes memory encodedTraitIds) = getTraitIdsAndEncodingForChonk(_chonkId);

        chonkOffers[_chonkId] = ChonkOffer({
            priceInWei: _priceInWei,
            seller: _seller,
            sellerTBA: _sellerTBA,
            onlySellTo: _onlySellTo,
            traitIds: traitIds,
            encodedTraitIds: encodedTraitIds
        });
    }

    function buyChonk(uint256 _chonkId) public payable notPaused nonReentrant {
        ChonkOffer memory offer = chonkOffers[_chonkId];

        // Ensure Offer
        address seller = offer.seller;
        if (seller == address(0)) revert OfferDoesNotExist();
        if (seller == msg.sender) revert CantBuyYourOwnChonk();
        if (offer.onlySellTo != address(0) && offer.onlySellTo != msg.sender)
            revert YouCantBuyThatChonk();

        // Ensure correct price
        if (offer.priceInWei != msg.value) revert WrongAmount();

        if (!CHONKS_MAIN.isApprovedForAll(offer.seller, address(this)) && CHONKS_MAIN.getApproved(_chonkId) != address(this))
            revert ApproveTheMarketplace();

        // Compare current traits owned by the Chonk's TBA with traits at time of listing. Prevents front running attack in the same block
        (, bytes memory encodedTraitIds) = getTraitIdsAndEncodingForChonk(_chonkId);
        if (keccak256(encodedTraitIds) != keccak256(offer.encodedTraitIds))
            revert TraitIdsChangedSinceListingRelist();

        // Delete the Offer
        delete chonkOffers[_chonkId];

        // Refund and clear existing Bid if from buyer
        uint256 refundAmount = 0;
        ChonkBid memory existingBid = chonkBids[_chonkId];
        if (existingBid.bidder == msg.sender) {
            delete chonkBids[_chonkId];
            refundAmount = existingBid.amountInWei;
        }

        if (refundAmount > 0)
            _refundBid(existingBid.bidder, refundAmount);

        // Transfer Chonk (Don't need to transfer Traits because they come with the Chonk)
        CHONKS_MAIN.transferFrom(offer.seller, msg.sender, _chonkId);

        // Pay Royalties and Seller
        _calculateRoyaltiesAndTransferFunds(msg.value, seller);

        emit ChonkBought(_chonkId, msg.sender, msg.value, seller);
    }

    ///////////////////////////////////////////////////////////////////////

    function withdrawBidOnChonk(uint256 _chonkId) public nonReentrant {
        // Ensure bid and that it's yours
        ChonkBid memory bid = chonkBids[_chonkId];
        if (bid.bidder != msg.sender) revert NotYourBid();

        // Delete from mapping
        delete chonkBids[_chonkId];

        // Refund your bid
        _refundBid(msg.sender, bid.amountInWei);

        emit ChonkBidWithdrawn(_chonkId, msg.sender, bid.amountInWei);
    }

    function bidOnChonk(uint256 _chonkId) public payable ensurePriceIsNotZero(msg.value) notPaused nonReentrant {
        address owner = CHONKS_MAIN.ownerOf(_chonkId);
        if (owner == msg.sender) revert CantBidOnYourOwnChonk();

        ChonkBid memory existingBid = chonkBids[_chonkId];
        if (msg.value <= existingBid.amountInWei) revert BidIsTooLow();

        (uint256[] memory traitIds , bytes memory encodedTraitIds) = getTraitIdsAndEncodingForChonk(_chonkId);

        chonkBids[_chonkId] = ChonkBid(
            msg.sender,
            msg.value,
            traitIds,
            encodedTraitIds
        );

        if (existingBid.amountInWei > 0) {
            _refundBid(existingBid.bidder, existingBid.amountInWei);
        }

        emit ChonkBidEntered(_chonkId, msg.sender, msg.value);
    }

    function acceptBidForChonk(uint256 _chonkId, address _bidder) public notPaused nonReentrant {
        address owner = CHONKS_MAIN.ownerOf(_chonkId);
        if (!CHONKS_MAIN.isApprovedForAll(owner, address(this)) && CHONKS_MAIN.getApproved(_chonkId) != address(this))
            revert ApproveTheMarketplace();

        if (owner != msg.sender) revert NotYourChonk();

        ChonkBid memory bid = chonkBids[_chonkId];
        address bidder = bid.bidder;
        if (bidder == address(0)) revert NoBidToAccept();
        if (bidder == msg.sender) revert CantAcceptYourOwnBid();
        if (bidder != _bidder) revert BidderChanged();

        // Since they bid, your Chonk-owned traits changed. They need to re-bid.
        (, bytes memory encodedTraitIds) = getTraitIdsAndEncodingForChonk(_chonkId);

        if (keccak256(encodedTraitIds) != keccak256(bid.encodedTraitIds))
            revert TraitIdsChangedSinceListingRelist();

        delete chonkBids[_chonkId];

        _calculateRoyaltiesAndTransferFunds(bid.amountInWei, owner);

        CHONKS_MAIN.transferFrom(msg.sender, bidder, _chonkId);

        emit ChonkBidAccepted(_chonkId, bid.amountInWei, bidder, owner);
    }

    /*
    Trait

    Cancel, Offer, Buy
    Withdraw Bid, Bid, Accept Bid
    */

    function cancelOfferTrait(uint256 _traitId, uint256 _chonkId) public {
        if (!ensureTraitOwner(_traitId, _chonkId)) revert NotYourTrait();

        address seller = traitOffers[_traitId].seller;
        if (seller == address(0)) revert NoOfferToCancel();
        if (seller != msg.sender) revert NotYourOffer();

        delete traitOffers[_traitId];

        emit TraitOfferCanceled(_traitId, msg.sender);
    }

    /// Note: Needs to be called by the EOA that owns the Chonk
    function offerTrait(
        uint256 _traitId,
        uint256 _chonkId,
        uint256 _priceInWei
    ) public notPaused ensurePriceIsNotZero(_priceInWei) {
        if (!ensureTraitOwner(_traitId, _chonkId)) revert NotYourTrait();

        // Please unequip the trait if you want to sell it
        if (CHONKS_MAIN.checkIfTraitIsEquipped(_chonkId, _traitId))
            revert TraitEquipped();

        address tbaTraitOwner = CHONK_TRAITS.ownerOf(_traitId);
        (address tokenOwner, ) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(
            _chonkId
        );

        traitOffers[_traitId] = TraitOffer(
            _priceInWei,
            tokenOwner,
            tbaTraitOwner,
            address(0)
        );

        emit TraitOffered(_traitId, _priceInWei, tokenOwner, tbaTraitOwner);
    }

    /// @notice This should be called by the EOA that owns the Chonk, not the TBA
    /// @param _traitId The ID of the Trait you're selling
    /// @param _chonkId The ID of the Chonk you're selling the Trait for. This Chonk ID must own the `_traitId`
    /// @param _priceInWei The price of the Trait you're selling, in Wei
    /// @param _onlySellTo should be the EOA that will be buying the Trait for their Chonk
    function offerTraitToAddress(
        uint256 _traitId,
        uint256 _chonkId,
        uint256 _priceInWei,
        address _onlySellTo
    ) public notPaused ensurePriceIsNotZero(_priceInWei) {
        if (!ensureTraitOwner(_traitId, _chonkId)) revert NotYourTrait();

        if (CHONKS_MAIN.tbaAddressToTokenId(_onlySellTo) != 0) revert OnlySellToEOAs();

        // Please unequip the trait if you want to sell it
        if (CHONKS_MAIN.checkIfTraitIsEquipped(_chonkId, _traitId))
            revert TraitEquipped();

        address tbaTraitOwner = CHONK_TRAITS.ownerOf(_traitId);
        (address tokenOwner, ) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_chonkId);

        traitOffers[_traitId] = TraitOffer(
            _priceInWei,
            tokenOwner,
            tbaTraitOwner,
            _onlySellTo
        );

        emit TraitOfferedToAddress(_traitId, _priceInWei, tokenOwner, tbaTraitOwner, _onlySellTo);
    }

    /// @notice This should be called by the EOA that owns the Chonk
    /// @param _traitId The ID of the Trait you're buying
    /// @param _forChonkId should be your Chonk you're buying the Trait for
    function buyTrait(uint256 _traitId, uint256 _forChonkId) public payable notPaused nonReentrant {
        // Ensure msg.sender owns the Chonk token of the TBA
        address owner = CHONKS_MAIN.ownerOf(_forChonkId);
        if (owner != msg.sender) revert NotYourChonk();

        // Ensure you don't own the Trait
        address tba = CHONKS_MAIN.tokenIdToTBAAccountAddress(_forChonkId);
        address traitOwnerTBAAddress = CHONK_TRAITS.ownerOf(_traitId);
        if (traitOwnerTBAAddress == tba) revert CantBuyYourOwnTrait();

        // Ensure Offer
        TraitOffer memory offer = traitOffers[_traitId];

        if (!CHONK_TRAITS.isApprovedForAll(offer.sellerTBA, address(this)) && CHONK_TRAITS.getApproved(_traitId) != address(this))
            revert TBANeedsToApproveMarketplace();

        address seller = offer.seller;
        if (seller == address(0)) revert OfferDoesNotExist();
        if (seller == msg.sender) revert CantBuyYourOwnTrait();
        if (offer.onlySellTo != address(0) && offer.onlySellTo != msg.sender)
            revert YouCantBuyThatTrait();

        // Ensure correct price
        if (offer.priceInWei != msg.value) revert WrongAmount();

        (,,, bool isEquipped) = CHONKS_MAIN.getFullPictureForTrait(_traitId);
        if (isEquipped) revert TraitEquipped();

        // Delete the Offer
        delete traitOffers[_traitId];

        // Clear existing Bid if it exists
        uint256 refundAmount = 0;
        TraitBid memory existingBid = traitBids[_traitId];
        if (existingBid.bidder == msg.sender) {
            delete traitBids[_traitId];
            refundAmount = existingBid.amountInWei;
        }

        if (refundAmount > 0)
            _refundBid(existingBid.bidder, refundAmount);

        CHONK_TRAITS.transferFrom(offer.sellerTBA, tba, _traitId);

        _calculateRoyaltiesAndTransferFunds(msg.value, seller);

        emit TraitBought(_traitId, tba, msg.value, msg.sender, seller);
    }

    ///////////////////////////////////////////////////////////////////////

    function withdrawBidOnTrait(uint256 _traitId) public nonReentrant {
        // Ensure bid and that it's yours
        TraitBid memory bid = traitBids[_traitId];
        if (bid.bidder != msg.sender) revert NotYourBid();

        // Delete from mapping
        delete traitBids[_traitId];

        // Refund your bid
        _refundBid(msg.sender, bid.amountInWei);

        emit TraitBidWithdrawn(_traitId, msg.sender, bid.amountInWei);
    }

    function bidOnTrait(uint256 _traitId, uint256 _yourChonkId) public payable ensurePriceIsNotZero(msg.value) notPaused nonReentrant {
        (address chonkOwner, address tbaAddressOfBiddersChonk) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_yourChonkId);
        // Ensure msg.sender owns the Chonk trait will go to
        if (chonkOwner != msg.sender) revert NotYourChonk();

        // Ensure  msg.sender does own Chonk or Trait
        (address traitOwnerTBA, , address traitChonkOwner, ) = CHONKS_MAIN.getFullPictureForTrait(_traitId);
        if (traitChonkOwner == msg.sender || traitOwnerTBA == msg.sender) revert CantBidOnYourOwnTrait();

        TraitBid memory existingBid = traitBids[_traitId];
        if (msg.value <= existingBid.amountInWei) revert BidIsTooLow();

        // address bidderTBA = CHONKS_MAIN.tokenIdToTBAAccountAddress(_yourChonkId);
        traitBids[_traitId] = TraitBid(msg.sender, tbaAddressOfBiddersChonk, msg.value);

        if (existingBid.amountInWei > 0) {
            _refundBid(existingBid.bidder, existingBid.amountInWei);
        }

        emit TraitBidEntered(_traitId, msg.sender, msg.value);
    }

    function acceptBidForTrait(uint256 _traitId, address _bidder) public notPaused nonReentrant {
        // Ensure Bid
        TraitBid memory bid = traitBids[_traitId];
        address bidder = bid.bidder;
        if (bidder == address(0)) revert NoBidToAccept();
        if (bidder == msg.sender) revert CantAcceptYourOwnBid();
        if (bidder != _bidder) revert BidderChanged();

        (address sellerTBA, , address seller, bool isEquipped) = CHONKS_MAIN.getFullPictureForTrait(_traitId);
        if (seller != msg.sender) revert NotYourTrait();

        if (isEquipped) revert TraitEquipped();

        // Delete Offer for trait ID if present, delete Bid you're accepting
        delete traitOffers[_traitId];
        delete traitBids[_traitId];

        _calculateRoyaltiesAndTransferFunds(bid.amountInWei, seller);

        CHONK_TRAITS.transferFrom(sellerTBA, bid.bidderTBA, _traitId);

        emit TraitBidAccepted(_traitId, bid.amountInWei, bidder, seller);
    }

    /// Helper Functions

    // Ensures that the msg.sender owns the Chonk which owns the TBA that owns the Trait
    function ensureTraitOwner(uint256 _traitId, uint256 _chonkId) public view returns (bool) {
        address traitOwnerTBA = CHONK_TRAITS.ownerOf(_traitId);
        (address chonkOwner, address tbaForChonkId) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_chonkId);

        return (traitOwnerTBA == tbaForChonkId) && (chonkOwner == msg.sender);
    }

    function calculateRoyalty(uint256 _amount) public view returns (uint256) {
        return (_amount * royaltyPercentage) / 10_000;
    }

    function getTraitIdsAndEncodingForChonk(uint256 _chonkId) public view returns (uint256[] memory traitIds, bytes memory encodedTraitIds) {
        (, address tbaAddress) = CHONKS_MAIN.getOwnerAndTBAAddressForChonkId(_chonkId);
        traitIds = CHONK_TRAITS.walletOfOwner(tbaAddress);
        encodedTraitIds = abi.encode(traitIds);
    }

    /// Before Token Transfer

    function deleteChonkOfferBeforeTokenTransfer(uint256 _chonkId) public onlyMainContract {
        ChonkOffer memory offer = chonkOffers[_chonkId];
        if (offer.seller != address(0)) delete chonkOffers[_chonkId];
    }

    function deleteChonkBidsBeforeTokenTransfer(uint256 _chonkId, address _toEOA) public onlyMainContract {
        ChonkBid memory bid = chonkBids[_chonkId];
        if (bid.bidder == _toEOA) {
            delete chonkBids[_chonkId];
            _refundBid(bid.bidder, bid.amountInWei);
        }
    }

    function deleteTraitOffersBeforeTokenTransfer(uint256 _traitId) public {
        if (msg.sender != address(CHONKS_MAIN) && msg.sender != address(CHONK_TRAITS)) revert CMUnauthorized();

        // Delete the Trait Offer
        if (traitOffers[_traitId].seller != address(0)) delete traitOffers[_traitId];
    }

    /// @dev Loops through all of the TBAs associated with the _toEOA address to see if they bid on the Trait. If so, delete and refund the bidder
    function deleteTraitBidsBeforeTokenTransfer(uint256 _traitId, address[] memory _toTBAs) public {
        if (msg.sender != address(CHONKS_MAIN)) revert CMUnauthorized();

        // This handles the case where the bid.bidder owns multiple Chonks
        // since each Chonk has its own TBA and when you bid, we record the TBA
        // the transfer would happen to, we need to check the bid's bidderTBA against
        // the TBA that will receive the trait and then refund the *bidder* if necessary
        TraitBid memory bid = traitBids[_traitId];
        if (bid.bidder != address(0)) {
            for (uint256 i; i < _toTBAs.length; ++i) {
                address toTBA = _toTBAs[i];
                if (bid.bidderTBA == toTBA) {
                    delete traitBids[_traitId];
                    _refundBid(bid.bidder, bid.amountInWei);
                }
            }
        }
    }

    function deleteTraitBidsBeforeTokenTransfer(uint256 _traitId, address _toTBA) public {
        if (msg.sender != address(CHONK_TRAITS)) revert CMUnauthorized();

        TraitBid memory bid = traitBids[_traitId];
        if (bid.bidder != address(0)) {
            if (bid.bidderTBA == _toTBA) {
                delete traitBids[_traitId];
                _refundBid(bid.bidder, bid.amountInWei);
            }
        }
    }

    function removeChonkOfferOnTraitTransfer(uint256 _chonkId) public onlyTraitContract {
        delete chonkOffers[_chonkId];
    }

    /// Withdraw

    function withdrawFunds() public nonReentrant {
        uint256 balance = withdrawableFunds[msg.sender];
        withdrawableFunds[msg.sender] = 0;

        (bool success, ) = msg.sender.call{value: balance, gas: 60_000}("");
        if (!success) revert WithdrawFailed();
    }

    /// Private

    function _calculateRoyaltiesAndTransferFunds(uint256 _amount, address _to) private returns (bool success) {
        uint256 royalties = calculateRoyalty(_amount);
        uint256 amountForSeller = _amount - royalties;

        (bool royaltyPayment, ) = payable(teamWallet).call{value: royalties}("");
        if (!royaltyPayment) withdrawableFunds[teamWallet] += royalties;

        (success, ) = payable(_to).call{value: amountForSeller, gas: 60_000}("");
        if (!success) withdrawableFunds[_to] += amountForSeller;
    }

    function _refundBid(address _to, uint256 _amount) private {
        (bool success, ) = payable(_to).call{value: _amount, gas: 60_000}("");
        if (!success) withdrawableFunds[_to] += _amount;
    }

    /// Only Owner

    // Set the royalty percentage
    function setRoyaltyPercentage(uint256 _royaltyPercentage) public onlyOwner {
        royaltyPercentage = _royaltyPercentage;
    }

    // Set the wallet to receive royalties
    function setTeamWallet(address _teamWallet) public onlyOwner {
        teamWallet = _teamWallet;
    }

    // Allows us to pause the market
    function pause(bool _value) public onlyOwner {
        if (pausabilityRevoked) revert PausabilityRevoked();
        paused = _value;
    }

    // Allows us to revoke the pausability. Will happen after enough time has passed and we feel confident in the market
    // CAUTION: This is irreversible. Ensure `paused` is `false` before revoking
    function revokePausability() public onlyOwner {
        if (pausabilityRevoked) revert PausabilityRevoked();
        pausabilityRevoked = true;
    }

}

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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts 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.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

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

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

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

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

/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(proof) {
                // Initialize `offset` to the offset of `proof` elements in memory.
                let offset := add(proof, 0x20)
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(offset, shl(5, mload(proof)))
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, mload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), mload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if proof.length {
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(proof.offset, shl(5, proof.length))
                // Initialize `offset` to the offset of `proof` in the calldata.
                let offset := proof.offset
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, calldataload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), calldataload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - The sum of the lengths of `proof` and `leaves` must never overflow.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The memory offset of `proof` must be non-zero
    ///   (i.e. `proof` is not pointing to the scratch space).
    function verifyMultiProof(
        bytes32[] memory proof,
        bytes32 root,
        bytes32[] memory leaves,
        bool[] memory flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // Cache the lengths of the arrays.
            let leavesLength := mload(leaves)
            let proofLength := mload(proof)
            let flagsLength := mload(flags)

            // Advance the pointers of the arrays to point to the data.
            leaves := add(0x20, leaves)
            proof := add(0x20, proof)
            flags := add(0x20, flags)

            // If the number of flags is correct.
            for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flagsLength) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    isValid := eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof, shl(5, proofLength))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                leavesLength := shl(5, leavesLength)
                for { let i := 0 } iszero(eq(i, leavesLength)) { i := add(i, 0x20) } {
                    mstore(add(hashesFront, i), mload(add(leaves, i)))
                }
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, leavesLength)
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flagsLength := add(hashesBack, shl(5, flagsLength))

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(mload(flags)) {
                        // Loads the next proof.
                        b := mload(proof)
                        proof := add(proof, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag.
                    flags := add(flags, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flagsLength)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof)
                    )
                break
            }
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    ///
    /// Note:
    /// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`
    ///   will always return false.
    /// - Any non-zero word in the `flags` array is treated as true.
    /// - The calldata offset of `proof` must be non-zero
    ///   (i.e. `proof` is from a regular Solidity function with a 4-byte selector).
    function verifyMultiProofCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32[] calldata leaves,
        bool[] calldata flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // If the number of flags is correct.
            for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flags.length) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    // forgefmt: disable-next-item
                    isValid := eq(
                        calldataload(
                            xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
                        ),
                        root
                    )
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := add(proof.offset, shl(5, proof.length))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, shl(5, leaves.length))
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flags.length := add(hashesBack, shl(5, flags.length))

                // We don't need to make a copy of `proof.offset` or `flags.offset`,
                // as they are pass-by-value (this trick may not always save gas).

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(calldataload(flags.offset)) {
                        // Loads the next proof.
                        b := calldataload(proof.offset)
                        proof.offset := add(proof.offset, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag offset.
                    flags.offset := add(flags.offset, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flags.length)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required.
                        eq(proofEnd, proof.offset)
                    )
                break
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   EMPTY CALLDATA HELPERS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns an empty calldata bytes32 array.
    function emptyProof() internal pure returns (bytes32[] calldata proof) {
        /// @solidity memory-safe-assembly
        assembly {
            proof.length := 0
        }
    }

    /// @dev Returns an empty calldata bytes32 array.
    function emptyLeaves() internal pure returns (bytes32[] calldata leaves) {
        /// @solidity memory-safe-assembly
        assembly {
            leaves.length := 0
        }
    }

    /// @dev Returns an empty calldata bool array.
    function emptyFlags() internal pure returns (bool[] calldata flags) {
        /// @solidity memory-safe-assembly
        assembly {
            flags.length := 0
        }
    }
}

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

interface IAccountImplementation {
    function owner() external view returns (address);
}

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

interface IAccountProxy {
    function initialize(address _implementation) external;

    function execute(
        address target,
        uint256 value,
        bytes calldata data,
        uint256 operation
    ) external returns (bytes memory);

    function executeCall(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable returns (bytes memory);
}

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

interface IRegistry {

    // function symbolScheme(uint256 index) external view returns (uint8);

    // function tokenURI(uint256 index) external view returns (string memory);

    function createAccount(
        address implementation,
        bytes32 salt,
        uint256 chainId,
        address tokenContract,
        uint256 tokenId
    ) external returns (address);

    function account(
        address implementation,
        bytes32 salt,
        uint256 chainId,
        address tokenContract,
        uint256 tokenId
    ) external view returns (address);

}

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

import { EncodeURI } from "../EncodeURI.sol";
import { IChonkStorage } from "../interfaces/IChonkStorage.sol";
import { Ownable } from "solady/auth/Ownable.sol";
import { Utils } from "../common/Utils.sol";

// Scripty for 3D rendering
import { IScriptyBuilderV2, HTMLRequest, HTMLTagType, HTMLTag } from "../../lib/scripty/interfaces/IScriptyBuilderV2.sol";

contract MainRenderer3D is Ownable {

    // Scripty & EthFS for 3D rendering
    address immutable scriptyBuilderAddress = 0xD7587F110E08F4D120A231bA97d3B577A81Df022;
    address immutable ethfsFileStorageAddress = 0x8FAA1AAb9DA8c75917C43Fb24fDdb513edDC3245;

    // Encodes plain text as a URI-encoded string
    EncodeURI public encodeURIContract;

    // Three.js script for 3D rendering
    bytes public base64ScriptContent;

    string private constant SVG_START_STYLE = '<svg shape-rendering="crispEdges" viewBox="0 0 30 30" fill="none" xmlns="http://www.w3.org/2000/svg"><style> body{overflow: hidden; margin: 0;} svg{ max-width: 100vw; max-height: 100vh; width: 100%;} #main rect{width:1px; height: 1px;} .bg{width:30px; height: 30px;} .on { scale: 177%; transform: translate(-6px, -3px); } .off { scale: 100%; transform: translate(0px, 0px); } .button { cursor: pointer; fill: transparent; } .closed{ transform: translate(0px, 30px); } .open{ transform: translate(0px, 0px); } </style>';

    constructor() {
        _initializeOwner(msg.sender);
    }

    function generateFullSvg(
        string memory _bodySvg,
        string memory _traitsSvg,
        IChonkStorage.ChonkData memory _chonkdata
    ) internal pure returns (string memory image) {
        string memory fullSvg = string.concat(
            SVG_START_STYLE,
            generateBackgroundColorStyles(_chonkdata),
            '<g id="body">',
            _bodySvg,
            '</g>',
            '<g id="traits">',
            _traitsSvg,
            '</g></svg>'
        );

        image = string.concat(
            '"image":"data:image/svg+xml;base64,',
            Utils.encode(bytes(fullSvg )),
            '"'
        );
    }

    function generateBackgroundColorStyles(IChonkStorage.ChonkData memory _chonkdata) internal pure returns (string memory backgroundColorStyles) {
        backgroundColorStyles = string.concat(
            '<style>',
            'body, svg{ background: #', _chonkdata.backgroundColor, '; }',
            '.bg { fill: #', _chonkdata.backgroundColor, '; }',
            '</style>'
        );
    }

    function generateChonkData(IChonkStorage.ChonkData memory _chonkdata) internal pure returns (string memory chonkDataJson) {
        chonkDataJson = string.concat(
            '"chonkdata":[',
                '{ "background_color" : "#', _chonkdata.backgroundColor, '" },',
                '{ "num_items_in_backpack" : "', Utils.toString(_chonkdata.numOfItemsInBackpack), '" },',
                '{ "renderer" : "3D" },',
                '{ "body_type" : "', _chonkdata.bodyName, '" }'
           ']'
        );
    }

    function generateAttributes(string memory _traitsAttributes, IChonkStorage.ChonkData memory _chonkdata) internal pure returns (string memory fullAttributes) {
        //todo: do we need this bodyAttributes check in here?
        if (bytes(_traitsAttributes).length > 0) {
            // fullAttributes = string.concat('"attributes":[', _bodyAttributes, ',', _traitsAttributes, ']');
            fullAttributes = string.concat(
                '"attributes":[',
                _traitsAttributes,
                '],',
                generateChonkData(_chonkdata)
            );
        }
        else {
            fullAttributes = string.concat(
                '"attributes":[],',
                generateChonkData(_chonkdata)
            );
        }
    }

    function renderAsDataUri(
        uint256 _tokenId,
        string memory _bodySvg,
        string memory _traitsSvg,
        string memory _traitsAttributes,
        bytes memory _fullZmap,
        IChonkStorage.ChonkData memory _chonkdata
    ) public view returns (string memory) {
        string memory image = generateFullSvg( _bodySvg, _traitsSvg, _chonkdata);
        string memory fullAttributes = generateAttributes(_traitsAttributes, _chonkdata);

        HTMLTag[] memory headTags = new HTMLTag[](1);
        headTags[0].tagOpen = "%253Cstyle%253E";
        headTags[0]
            .tagContent = "html%257Bheight%253A100%2525%257Dbody%257Bmin-height%253A100%2525%253Bmargin%253A0%253Bpadding%253A0%257Dcanvas%257Bpadding%253A0%253Bmargin%253Aauto%253Bdisplay%253Ablock%253Bposition%253Aabsolute%253Btop%253A0%253Bbottom%253A0%253Bleft%253A0%253Bright%253A0%257D";
        headTags[0].tagClose = "%253C%252Fstyle%253E";

        // Shoutout to Sterling Crispin and BrainWorms
        HTMLTag[] memory bodyTags = new HTMLTag[](12);
        bodyTags[0].name = "gunzipScripts-0.0.1.js";
        bodyTags[0].tagType = HTMLTagType.scriptBase64DataURI;
        bodyTags[0].contractAddress = ethfsFileStorageAddress;

        bodyTags[1].name = "es-module-shims.js.Base64.gz";
        bodyTags[1].tagType = HTMLTagType.scriptGZIPBase64DataURI;
        bodyTags[1].contractAddress = ethfsFileStorageAddress;

        bodyTags[2].name = "fflate.module.js.Base64.gz";
        bodyTags[2]
            .tagOpen = "%253Cscript%253Evar%2520fflte%2520%253D%2520%2522";
        bodyTags[2].tagClose = "%2522%253C%252Fscript%253E";
        bodyTags[2].contractAddress = ethfsFileStorageAddress;

        bodyTags[3].name = "three-v0.162.0-module.min.js.Base64.gz";
        bodyTags[3].tagOpen = "%253Cscript%253Evar%2520t3%2520%253D%2520%2522";
        bodyTags[3].tagClose = "%2522%253C%252Fscript%253E";
        bodyTags[3].contractAddress = ethfsFileStorageAddress;

        bodyTags[4].name = "three-v0.162.0-OrbitControls.js.Base64.gz";
        bodyTags[4].tagOpen = "%253Cscript%253Evar%2520oc%2520%253D%2520%2522";
        bodyTags[4].tagClose = "%2522%253C%252Fscript%253E";
        bodyTags[4].contractAddress = ethfsFileStorageAddress;

        bodyTags[5].name = "importHandler.js";
        bodyTags[5].tagType = HTMLTagType.scriptBase64DataURI;
        bodyTags[5].contractAddress = ethfsFileStorageAddress;

        bodyTags[6].name = "";
        bodyTags[6].tagType = HTMLTagType.script;
        bodyTags[6]
            .tagContent = 'injectImportMap([ ["fflate",fflte],   ["three",t3], ["OrbitControls",oc] ],gunzipScripts)';

        bodyTags[7].name = "canvas";
        bodyTags[7].tagOpen = '%253Ccanvas%2520id%253D%2522theCanvas%2522%2520class%253D%2522webgl%2522%253E';
        bodyTags[7].tagClose = "%253C%252Fcanvas%253E";

        bodyTags[8].tagOpen = bytes(
            string.concat(
                "%253Cscript%253Evar%2520zMapFull%2520%253D%2527",
                  encodeURIContract.encodeURI(
                    encodeURIContract.encodeURI(string(_fullZmap))
                )
            )
        );
        bodyTags[8].tagClose = "%2527%253B%253C%252Fscript%253E"; 

        bodyTags[9].tagOpen = bytes(
            string.concat(
                "%253Cscript%253Evar%2520bgColor%2520%253D%2527",
                  encodeURIContract.encodeURI(
                    encodeURIContract.encodeURI(string.concat("#", _chonkdata.backgroundColor))
                )
            )
        );
        bodyTags[9].tagClose = "%2527%253B%253C%252Fscript%253E";

        bodyTags[10]
            .tagOpen = "%253Cscript%2520type%253D%2522module%2522%2520src%253D%2522data%253Atext%252Fjavascript%253Bbase64%252C";
        bodyTags[10].tagContent = base64ScriptContent;
        bodyTags[10].tagClose = "%2522%253E%253C%252Fscript%253E";

        HTMLRequest memory htmlRequest;
        htmlRequest.headTags = headTags;
        htmlRequest.bodyTags = bodyTags;

        bytes memory doubleURLEncodedHTMLDataURI = IScriptyBuilderV2(scriptyBuilderAddress).getHTMLURLSafe(htmlRequest);

        return generateJSON(_tokenId, fullAttributes, _chonkdata, image, doubleURLEncodedHTMLDataURI);
    }

    function generateJSON(uint256 _tokenId, string memory _attributes, IChonkStorage.ChonkData memory _chonkdata, string memory _image, bytes memory _doubleURLEncodedHTMLDataURI) internal view returns (string memory json) {
        return
            string(
                abi.encodePacked(
                    "data:application/json,",
                    encodeURIContract.encodeURI('{"name":"Chonk #'),
                    Utils.toString(_tokenId),
                    generateDescription(_chonkdata, _tokenId),
                    encodeURIContract.encodeURI(_attributes),
                    encodeURIContract.encodeURI(','),
                    encodeURIContract.encodeURI(_image),
                    encodeURIContract.encodeURI(',"animation_url":"'),
                    _doubleURLEncodedHTMLDataURI,
                    encodeURIContract.encodeURI('"}')
                )
            );
    }

    function generateDescription(IChonkStorage.ChonkData memory _chonkdata, uint256 _tokenId) internal view returns (string memory description) {
        description = string.concat(
            encodeURIContract.encodeURI('", "description":"'),
            encodeURIContract.encodeURI(_chonkdata.descriptionParts[0]),
            Utils.toString(_tokenId),
            encodeURIContract.encodeURI(_chonkdata.descriptionParts[1]),
            encodeURIContract.encodeURI('",')
        );
    }

    function setEncodeURI(address _encodeURIAddress) public onlyOwner {
        encodeURIContract = EncodeURI(_encodeURIAddress);
    }

    function setScriptContent(bytes calldata _base64EncodedString) public onlyOwner {
        base64ScriptContent = _base64EncodedString;
    }

}

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

import { ChonkTraits } from "./ChonkTraits.sol";
import { TraitCategory } from "./TraitCategory.sol";

interface IChonksMain {
    function getTBAAddressForChonkId(uint256 _chonkId) external view returns (address);
}

contract ChonkEquipHelper {

    IChonksMain public immutable chonksMain;
    ChonkTraits public immutable chonkTraits;

    error IncorrectTBAOwner();
    error IncorrectTraitType();

    constructor(address _chonksMain, address _chonkTraits) {
        chonksMain = IChonksMain(_chonksMain);
        chonkTraits = ChonkTraits(_chonkTraits);
    }

    function performValidations(
        address _tbaForChonk,
        uint256 _traitTokenId,
        TraitCategory.Name _traitType
    ) view public {
        _validateTBAOwnership(_tbaForChonk, _traitTokenId);
        _validateTraitType(_traitTokenId, _traitType);
    }

    function equipValidation(
        uint256 _chonkTokenId,
        uint256 _traitTokenId
    ) view public returns (TraitCategory.Name traitType)
    {
        address tbaForChonk = chonksMain.getTBAAddressForChonkId(_chonkTokenId);
        _validateTBAOwnership(tbaForChonk, _traitTokenId);

        traitType = chonkTraits.getTraitMetadata(_traitTokenId).traitType;
        _validateTraitType(_traitTokenId, traitType);
    }

    function _validateTBAOwnership(address _tbaForChonk, uint256 _traitTokenId) internal view {
        address ownerOfTrait = chonkTraits.ownerOf(_traitTokenId);
        if (ownerOfTrait != _tbaForChonk) revert IncorrectTBAOwner();
    }

    function _validateTraitType(uint256 _traitTokenId, TraitCategory.Name _traitType) internal view {
        TraitCategory.Name traitTypeofTokenIdToBeSet = chonkTraits.getTraitMetadata(_traitTokenId).traitType;

        if (keccak256(abi.encodePacked(uint(traitTypeofTokenIdToBeSet))) != keccak256(abi.encodePacked(uint(_traitType))))
            revert IncorrectTraitType();
    }

}

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

import { ChonkTraits } from './ChonkTraits.sol';
import { ITraitStorage } from './interfaces/ITraitStorage.sol';
import { Ownable } from 'solady/auth/Ownable.sol';
import { TraitCategory } from './TraitCategory.sol';
import { Utils } from './common/Utils.sol';

contract FirstReleaseDataMinter is Ownable {

    uint256[] public accessory =                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
    uint256[] internal accessoryProbability =  [6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 82, 86, 90, 94, 96, 98, 99, 100];

    uint256[] public head =                     [1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031];
    uint256[] internal headProbability =       [2, 14, 26, 29, 33, 35, 38, 41, 43, 45, 47, 48, 49, 50, 53, 56, 59, 62, 65, 68, 71, 72, 73, 76, 79, 82, 85, 88, 91, 94, 97, 100];

    uint256[] public hair =                     [2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036];
    uint256[] internal hairProbability =       [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 95, 96, 97, 98, 99, 100];

    uint256[] public face =                     [3000, 3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011];
    uint256[] internal faceProbability =       [2, 4, 12, 20, 28, 41, 52, 63, 74, 85, 96, 100];

    uint256[] public top =                      [4000, 4001, 4002, 4003, 4004, 4005, 4006, 4007, 4008, 4009, 4010, 4011, 4012, 4013, 4014, 4015, 4016, 4017, 4018, 4019, 4020, 4021, 4022, 4023, 4024, 4025, 4026, 4027, 4028, 4029, 4030, 4031, 4032, 4033, 4034, 4035, 4036, 4037, 4038, 4039, 4040, 4041, 4042, 4043, 4044, 4045, 4046, 4047, 4048, 4049, 4050, 4051, 4052, 4053, 4054, 4055, 4056, 4057, 4058, 4059, 4060, 4061, 4062, 4063, 4064, 4065, 4066, 4067, 4068, 4069, 4070, 4071, 4072];

    uint256[] public bottom =                   [5000, 5001, 5002, 5003, 5004, 5005, 5006, 5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, 5015, 5016, 5017, 5018, 5019, 5020, 5021, 5022, 5023, 5024, 5025, 5026, 5027, 5028, 5029, 5030, 5031, 5032, 5033, 5034, 5035, 5036, 5037, 5038, 5039, 5040, 5041, 5042, 5043, 5044];

    uint256[] public shoes =                    [6000, 6001, 6002, 6003, 6004, 6005, 6006, 6007, 6008, 6009, 6010, 6011, 6012, 6013, 6014, 6015, 6016, 6017];

    // The Main contract address
    address public chonksMain;

    // The Trait contract address
    ChonkTraits public chonkTraits;

    /// Errors

    error OnlyChonksMain();

    /// Constructor

    constructor(address _chonksMain, address _chonkTraits) {
        _initializeOwner(msg.sender);

        chonksMain = _chonksMain;
        chonkTraits = ChonkTraits(_chonkTraits);
    }

    function safeMintMany(address _toTBA, uint8 _traitCount) public returns (uint256[] memory) {
        if (msg.sender != chonksMain) revert OnlyChonksMain();

        uint256[] memory mintedIds = new uint256[](_traitCount);
        for (uint256 i; i < _traitCount; ++i) {
            // Creates a blank Trait token
            uint256 tokenId = chonkTraits.safeMint(_toTBA);
            mintedIds[i] = tokenId;

            // Initialize our Trait
            ITraitStorage.StoredTrait memory trait = chonkTraits.getStoredTraitForTokenId(tokenId);

            // Set the current epoch
            trait.epoch = chonkTraits.getCurrentEpoch();
            // Set the seed to the tokenId
            trait.seed = tokenId;
            // Set the data render contract to this contract
            trait.dataMinterContract = address(this);

            // Assign the Trait Category
            if (i == 0) {
                trait.traitType = TraitCategory.Name.Shoes;
            } else if (i == 1) {
                trait.traitType = TraitCategory.Name.Bottom;
            } else if (i == 2) {
                trait.traitType = TraitCategory.Name.Top;
            } else if (i == 3) {
                trait.traitType = TraitCategory.Name.Hair;
            }  else if (i == 4) {
                trait.traitType = TraitCategory.Name.Face;
            } else if (i == 5) {
                trait.traitType = TraitCategory.Name.Head;
            } else if (i == 6) {
                trait.traitType = TraitCategory.Name.Accessory;
            } else {
                // This should never happen
                trait.traitType = TraitCategory.Name.Accessory;
            }

            chonkTraits.setTraitForTokenId(tokenId, trait);
        }

        return mintedIds;
    }

    /// @notice Ownership will be revoked after mint period
    function addNewTrait(
        uint256 _traitIndex,
        string memory _traitName,
        TraitCategory.Name _traitType,
        bytes memory _colorMap,
        bytes memory _zMap,
        address _creatorAddress,
        string memory _creatorName
    ) public onlyOwner {
        ITraitStorage.TraitMetadata memory metadata = chonkTraits.getTraitIndexToMetadata(_traitIndex);
        metadata.traitIndex = _traitIndex;
        metadata.traitName = _traitName;
        metadata.traitType = _traitType;
        metadata.colorMap = _colorMap;
        metadata.zMap = _zMap;
        metadata.dataMinterContract = address(this);
        metadata.creatorAddress = _creatorAddress;
        metadata.creatorName = _creatorName;
        metadata.release = "1";

        chonkTraits.setTraitIndexToMetadata(_traitIndex, metadata);
    }

    // Shoutout to apex777.eth and Based OnChain Dinos:
    function _pickTraitByProbability(uint256 seed, uint256[] memory traitArray, uint256[] memory traitProbability) internal pure returns (uint256) {
        require(traitArray.length > 0, "Elements array is empty");
        require(traitArray.length == traitProbability.length, "Elements and weights length mismatch");

        for (uint256 i; i < traitProbability.length; i++) {
            if (seed < traitProbability[i]) {
                return i;
            }
        }
        // Fallback, return first element as a safe default
        return 0;
    }

    function explainTrait(
        ITraitStorage.StoredTrait memory storedTrait,
        uint128 randomness
    ) view public returns (ITraitStorage.StoredTrait memory) {
        uint256 n; // number for randomness

        storedTrait.seed = uint256(keccak256(abi.encodePacked(randomness, storedTrait.seed))) % type(uint256).max;

        storedTrait.isRevealed = randomness > 0; // if randomness is > 0, epoch & hence Chonk is revealed

        if (storedTrait.traitType == TraitCategory.Name.Accessory) {
            storedTrait.traitIndex = 0 + _pickTraitByProbability( Utils.random(storedTrait.seed, 'acccesory', 100), accessory, accessoryProbability);
        }

        if (storedTrait.traitType == TraitCategory.Name.Head) {
            storedTrait.traitIndex = 1000 + _pickTraitByProbability( Utils.random(storedTrait.seed, 'head', 100), head, headProbability);
        }

        if (storedTrait.traitType == TraitCategory.Name.Hair) {
            storedTrait.traitIndex = 2000 + _pickTraitByProbability( Utils.random(storedTrait.seed, 'hair', 100), hair, hairProbability);
        }


        if (storedTrait.traitType == TraitCategory.Name.Face) {
            storedTrait.traitIndex = 3000 + _pickTraitByProbability( Utils.random(storedTrait.seed, 'face', 100), face, faceProbability);
        }

        // tops: last 3 are rares, 1% chance of this tranche hitting
        if (storedTrait.traitType == TraitCategory.Name.Top) {
            n = Utils.random(storedTrait.seed, 'top', 100);

            if (n < 99) {
                storedTrait.traitIndex = 4000 + Utils.random(storedTrait.seed, 'top-common', top.length - 3 );
            } else {
                storedTrait.traitIndex = 4000 + (top.length - 3) + Utils.random(storedTrait.seed, 'top-rare', 3 );
            }
        }

        // bottoms: last 4 are rares, 1% chance of this tranche hitting
        if (storedTrait.traitType == TraitCategory.Name.Bottom) {
            n = Utils.random(storedTrait.seed, 'bottom', 100);

            if (n < 99) {
                storedTrait.traitIndex = 5000 + Utils.random(storedTrait.seed, 'bottom-common', bottom.length - 4 );
            } else {
                storedTrait.traitIndex = 5000 + (bottom.length - 4) + Utils.random(storedTrait.seed, 'bottom-rare', 4 );
            }
        }

        // shoes: last 4 are rares, 5% chance of this tranche hitting
        if (storedTrait.traitType == TraitCategory.Name.Shoes) {
            n = Utils.random(storedTrait.seed, 'shoes', 100);

            if (n < 95) {
                storedTrait.traitIndex = 6000 + Utils.random(storedTrait.seed, 'shoes-common', shoes.length - 4 );
            } else {
                storedTrait.traitIndex = 6000 + (shoes.length - 4) + Utils.random(storedTrait.seed, 'shoes-rare', 4 );
            }
        }

        return storedTrait;
    }

}

// SPDX-License-Identifier: MIT
// via @iamwhitelights
pragma solidity ^0.8.17;
contract EncodeURI {
    /**
     * @dev URI Encoding/Decoding Hex Table
     */
    bytes internal constant TABLE = "0123456789ABCDEF";

    /**
     * @dev URI encodes the provided string. Gas optimized like crazy.
     */
    function encodeURI(string memory str_) public pure returns (string memory) {
        bytes memory input = bytes(str_);
        uint256 inputLength = input.length;
        uint256 outputLength = 0;

        for (uint256 i = 0; i < inputLength; i++) {
            bytes1 b = input[i];

            if (
                (b >= 0x30 && b <= 0x39) ||
                (b >= 0x41 && b <= 0x5a) ||
                (b >= 0x61 && b <= 0x7a)
            ) {
                outputLength++;
            } else {
                outputLength += 3;
            }
        }

        bytes memory output = new bytes(outputLength);
        uint256 j = 0;

        for (uint256 i = 0; i < inputLength; i++) {
            bytes1 b = input[i];

            if (
                (b >= 0x30 && b <= 0x39) ||
                (b >= 0x41 && b <= 0x5a) ||
                (b >= 0x61 && b <= 0x7a)
            ) {
                output[j++] = b;
            } else {
                bytes1 b1 = TABLE[uint8(b) / 16];
                bytes1 b2 = TABLE[uint8(b) % 16];
                output[j++] = 0x25; // '%'
                output[j++] = b1;
                output[j++] = b2;
            }
        }

        return string(output);
    }
}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////

/**
  @title A generic HTML builder that fetches and assembles given JS requests.
  @author @0xthedude
  @author @xtremetom

  Special thanks to @cxkoda and @frolic
*/

import "./IScriptyHTML.sol";
import "./IScriptyHTMLURLSafe.sol";

interface IScriptyBuilderV2 is IScriptyHTML, IScriptyHTMLURLSafe {}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////

import {HTMLRequest, HTMLTagType, HTMLTag} from "./../core/ScriptyCore.sol";

interface IScriptyHTML {
    // =============================================================
    //                      RAW HTML GETTERS
    // =============================================================

    /**
     * @notice  Get HTML with requested head tags and body tags
     * @dev Your HTML is returned in the following format:
     *      <html>
     *          <head>
     *              [tagOpen[0]][contractRequest[0] | tagContent[0]][tagClose[0]]
     *              [tagOpen[1]][contractRequest[0] | tagContent[1]][tagClose[1]]
     *              ...
     *              [tagOpen[n]][contractRequest[0] | tagContent[n]][tagClose[n]]
     *          </head>
     *          <body>
     *              [tagOpen[0]][contractRequest[0] | tagContent[0]][tagClose[0]]
     *              [tagOpen[1]][contractRequest[0] | tagContent[1]][tagClose[1]]
     *              ...
     *              [tagOpen[n]][contractRequest[0] | tagContent[n]][tagClose[n]]
     *          </body>
     *      </html>
     * @param htmlRequest - HTMLRequest
     * @return Full HTML with head and body tags
     */
    function getHTML(
        HTMLRequest memory htmlRequest
    ) external view returns (bytes memory);

    // =============================================================
    //                      ENCODED HTML GETTERS
    // =============================================================

    /**
     * @notice Get {getHTML} and base64 encode it
     * @param htmlRequest - HTMLRequest
     * @return Full HTML with head and script tags, base64 encoded
     */
    function getEncodedHTML(
        HTMLRequest memory htmlRequest
    ) external view returns (bytes memory);

    // =============================================================
    //                      STRING UTILITIES
    // =============================================================

    /**
     * @notice Convert {getHTML} output to a string
     * @param htmlRequest - HTMLRequest
     * @return {getHTMLWrapped} as a string
     */
    function getHTMLString(
        HTMLRequest memory htmlRequest
    ) external view returns (string memory);

    /**
     * @notice Convert {getEncodedHTML} output to a string
     * @param htmlRequest - HTMLRequest
     * @return {getEncodedHTML} as a string
     */
    function getEncodedHTMLString(
        HTMLRequest memory htmlRequest
    ) external view returns (string memory);
}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////

import {HTMLRequest, HTMLTagType, HTMLTag} from "./../core/ScriptyCore.sol";

interface IScriptyHTMLURLSafe {
    // =============================================================
    //                      RAW HTML GETTERS
    // =============================================================

    /**
     * @notice  Get URL safe HTML with requested head tags and body tags
     * @dev Any tags with tagType = 1/script are converted to base64 and wrapped
     *      with <script src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      [WARNING]: Large non-base64 libraries that need base64 encoding
     *      carry a high risk of causing a gas out. Highly advised the use
     *      of base64 encoded scripts where possible
     *
     *      Your HTML is returned in the following format:
     *
     *      <html>
     *          <head>
     *              [tagOpen[0]][contractRequest[0] | tagContent[0]][tagClose[0]]
     *              [tagOpen[1]][contractRequest[0] | tagContent[1]][tagClose[1]]
     *              ...
     *              [tagOpen[n]][contractRequest[0] | tagContent[n]][tagClose[n]]
     *          </head>
     *          <body>
     *              [tagOpen[0]][contractRequest[0] | tagContent[0]][tagClose[0]]
     *              [tagOpen[1]][contractRequest[0] | tagContent[1]][tagClose[1]]
     *              ...
     *              [tagOpen[n]][contractRequest[0] | tagContent[n]][tagClose[n]]
     *          </body>
     *      </html>
     * @param htmlRequest - HTMLRequest
     * @return Full HTML with head and body tags
     */
    function getHTMLURLSafe(
        HTMLRequest memory htmlRequest
    ) external view returns (bytes memory);

    // =============================================================
    //                      STRING UTILITIES
    // =============================================================

    /**
     * @notice Convert {getHTMLURLSafe} output to a string
     * @param htmlRequest - HTMLRequest
     * @return {getHTMLURLSafe} as a string
     */
    function getHTMLURLSafeString(
        HTMLRequest memory htmlRequest
    ) external view returns (string memory);
}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////
//░░░░░░░░░░░░░░░░░░░░░░    CORE    ░░░░░░░░░░░░░░░░░░░░░//
///////////////////////////////////////////////////////////

import {HTMLRequest, HTMLTagType, HTMLTag} from "./ScriptyStructs.sol";
import {DynamicBuffer} from "./../utils/DynamicBuffer.sol";
import {IScriptyContractStorage} from "./../interfaces/IScriptyContractStorage.sol";

contract ScriptyCore {
    using DynamicBuffer for bytes;

    // =============================================================
    //                        TAG CONSTANTS
    // =============================================================

    // data:text/html;base64,
    // raw
    // 22 bytes
    bytes public constant DATA_HTML_BASE64_URI_RAW = "data:text/html;base64,";
    // url encoded
    // 21 bytes
    bytes public constant DATA_HTML_URL_SAFE = "data%3Atext%2Fhtml%2C";

    // <html>,
    // raw
    // 6 bytes
    bytes public constant HTML_OPEN_RAW = "<html>";
    // url encoded
    // 10 bytes
    bytes public constant HTML_OPEN_URL_SAFE = "%3Chtml%3E";

    // <head>,
    // raw
    // 6 bytes
    bytes public constant HEAD_OPEN_RAW = "<head>";
    // url encoded
    // 10 bytes
    bytes public constant HEAD_OPEN_URL_SAFE = "%3Chead%3E";

    // </head>,
    // raw
    // 7 bytes
    bytes public constant HEAD_CLOSE_RAW = "</head>";
    // url encoded
    // 13 bytes
    bytes public constant HEAD_CLOSE_URL_SAFE = "%3C%2Fhead%3E";

    // <body>
    // 6 bytes
    bytes public constant BODY_OPEN_RAW = "<body>";
    // url encoded
    // 10 bytes
    bytes public constant BODY_OPEN_URL_SAFE = "%3Cbody%3E";

    // </body></html>
    // 14 bytes
    bytes public constant HTML_BODY_CLOSED_RAW = "</body></html>";
    // 26 bytes
    bytes public constant HTML_BODY_CLOSED_URL_SAFE =
        "%3C%2Fbody%3E%3C%2Fhtml%3E";

    // [RAW]
    // HTML_OPEN + HEAD_OPEN + HEAD_CLOSE + BODY_OPEN + HTML_BODY_CLOSED
    uint256 public constant URLS_RAW_BYTES = 39;

    // [URL_SAFE]
    // DATA_HTML_URL_SAFE + HTML_OPEN + HEAD_OPEN + HEAD_CLOSE + BODY_OPEN + HTML_BODY_CLOSED
    uint256 public constant URLS_SAFE_BYTES = 90;

    // [RAW]
    // HTML_OPEN + HTML_CLOSE
    uint256 public constant HTML_RAW_BYTES = 13;

    // [RAW]
    // HEAD_OPEN + HEAD_CLOSE
    uint256 public constant HEAD_RAW_BYTES = 13;

    // [RAW]
    // BODY_OPEN + BODY_CLOSE
    uint256 public constant BODY_RAW_BYTES = 13;

    // All raw
    // HTML_RAW_BYTES + HEAD_RAW_BYTES + BODY_RAW_BYTES
    uint256 public constant RAW_BYTES = 39;

    // [URL_SAFE]
    // HTML_OPEN + HTML_CLOSE
    uint256 public constant HTML_URL_SAFE_BYTES = 23;

    // [URL_SAFE]
    // HEAD_OPEN + HEAD_CLOSE
    uint256 public constant HEAD_URL_SAFE_BYTES = 23;

    // [URL_SAFE]
    // BODY_OPEN + BODY_CLOSE
    uint256 public constant BODY_SAFE_BYTES = 23;

    // All url safe
    // HTML_URL_SAFE_BYTES + HEAD_URL_SAFE_BYTES + BODY_URL_SAFE_BYTES
    // %3Chtml%3E%3Chead%3E%3C%2Fhead%3E%3Cbody%3E%3C%2Fbody%3E%3C%2Fhtml%3E
    uint256 public constant URL_SAFE_BYTES = 69;

    // data:text/html;base64,
    uint256 public constant HTML_BASE64_DATA_URI_BYTES = 22;

    // =============================================================
    //                    TAG OPEN CLOSE TEMPLATES
    // =============================================================

    /**
     * @notice Grab tag open and close depending on tag type
     * @dev
     *      tagType: 0/HTMLTagType.useTagOpenAndClose or any other:
     *          [tagOpen][CONTENT][tagClose]
     *
     *      tagType: 1/HTMLTagType.script:
     *          <script>[SCRIPT]</script>
     *
     *      tagType: 2/HTMLTagType.scriptBase64DataURI:
     *          <script src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      tagType: 3/HTMLTagType.scriptGZIPBase64DataURI:
     *          <script type="text/javascript+gzip" src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      tagType: 4/HTMLTagType.scriptPNGBase64DataURI
     *          <script type="text/javascript+png" name="[NAME]" src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      [IMPORTANT NOTE]: The tags `text/javascript+gzip` and `text/javascript+png` are used to identify scripts
     *      during decompression
     *
     * @param htmlTag - HTMLTag data for code
     * @return (tagOpen, tagClose) - Tag open and close as a tuple
     */
    function tagOpenCloseForHTMLTag(
        HTMLTag memory htmlTag
    ) public pure returns (bytes memory, bytes memory) {
        if (htmlTag.tagType == HTMLTagType.script) {
            return ("<script>", "</script>");
        } else if (htmlTag.tagType == HTMLTagType.scriptBase64DataURI) {
            return ('<script src="data:text/javascript;base64,', '"></script>');
        } else if (htmlTag.tagType == HTMLTagType.scriptGZIPBase64DataURI) {
            return (
                '<script type="text/javascript+gzip" src="data:text/javascript;base64,',
                '"></script>'
            );
        } else if (htmlTag.tagType == HTMLTagType.scriptPNGBase64DataURI) {
            return (
                '<script type="text/javascript+png" src="data:text/javascript;base64,',
                '"></script>'
            );
        }
        return (htmlTag.tagOpen, htmlTag.tagClose);
    }

    /**
     * @notice Grab URL safe tag open and close depending on tag type
     * @dev
     *      tagType: 0/HTMLTagType.useTagOpenAndClose or any other:
     *          [tagOpen][scriptContent or scriptFromContract][tagClose]
     *
     *      tagType: 1/HTMLTagType.script:
     *      tagType: 2/HTMLTagType.scriptBase64DataURI:
     *          <script src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      tagType: 3/HTMLTagType.scriptGZIPBase64DataURI:
     *          <script type="text/javascript+gzip" src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      tagType: 4/HTMLTagType.scriptPNGBase64DataURI
     *          <script type="text/javascript+png" name="[NAME]" src="data:text/javascript;base64,[SCRIPT]"></script>
     *
     *      [IMPORTANT NOTE]: The tags `text/javascript+gzip` and `text/javascript+png` are used to identify scripts
     *      during decompression
     *
     * @param htmlTag - HTMLTag data for code
     * @return (tagOpen, tagClose) - Tag open and close as a tuple
     */
    function tagOpenCloseForHTMLTagURLSafe(
        HTMLTag memory htmlTag
    ) public pure returns (bytes memory, bytes memory) {
        if (
            htmlTag.tagType == HTMLTagType.script ||
            htmlTag.tagType == HTMLTagType.scriptBase64DataURI
        ) {
            // <script src="data:text/javascript;base64,
            // "></script>
            return (
                "%253Cscript%2520src%253D%2522data%253Atext%252Fjavascript%253Bbase64%252C",
                "%2522%253E%253C%252Fscript%253E"
            );
        } else if (htmlTag.tagType == HTMLTagType.scriptGZIPBase64DataURI) {
            // <script type="text/javascript+gzip" src="data:text/javascript;base64,
            // "></script>
            return (
                "%253Cscript%2520type%253D%2522text%252Fjavascript%252Bgzip%2522%2520src%253D%2522data%253Atext%252Fjavascript%253Bbase64%252C",
                "%2522%253E%253C%252Fscript%253E"
            );
        } else if (htmlTag.tagType == HTMLTagType.scriptPNGBase64DataURI) {
            // <script type="text/javascript+png" src="data:text/javascript;base64,
            // "></script>
            return (
                "%253Cscript%2520type%253D%2522text%252Fjavascript%252Bpng%2522%2520src%253D%2522data%253Atext%252Fjavascript%253Bbase64%252C",
                "%2522%253E%253C%252Fscript%253E"
            );
        }
        return (htmlTag.tagOpen, htmlTag.tagClose);
    }

    // =============================================================
    //                      TAG CONTENT FETCHER
    // =============================================================

    /**
     * @notice Grabs requested tag content from storage
     * @dev
     *      If given HTMLTag contains non empty contractAddress
     *      this method will fetch the content from given storage
     *      contract. Otherwise, it will return the tagContent
     *      from the given htmlTag.
     *
     * @param htmlTag - HTMLTag
     */
    function fetchTagContent(
        HTMLTag memory htmlTag
    ) public view returns (bytes memory) {
        if (htmlTag.contractAddress != address(0)) {
            return
                IScriptyContractStorage(htmlTag.contractAddress).getContent(
                    htmlTag.name,
                    htmlTag.contractData
                );
        }
        return htmlTag.tagContent;
    }

    // =============================================================
    //                        SIZE OPERATIONS
    // =============================================================

    /**
     * @notice Calculate the buffer size post base64 encoding
     * @param value - Starting buffer size
     * @return Final buffer size as uint256
     */
    function sizeForBase64Encoding(
        uint256 value
    ) public pure returns (uint256) {
        unchecked {
            return 4 * ((value + 2) / 3);
        }
    }

    /**
     * @notice Adds the required tag open/close and calculates buffer size of tags
     * @dev Effectively multiple functions bundled into one as this saves gas
     * @param htmlTags - Array of HTMLTag
     * @param isURLSafe - Bool to handle tag content/open/close encoding
     * @return Total buffersize of updated HTMLTags
     */
    function _enrichHTMLTags(
        HTMLTag[] memory htmlTags,
        bool isURLSafe
    ) internal view returns (uint256) {
        if (htmlTags.length == 0) {
            return 0;
        }

        bytes memory tagOpen;
        bytes memory tagClose;
        bytes memory tagContent;

        uint256 totalSize;
        uint256 length = htmlTags.length;
        uint256 i;

        unchecked {
            do {
                tagContent = fetchTagContent(htmlTags[i]);
                htmlTags[i].tagContent = tagContent;

                if (isURLSafe && htmlTags[i].tagType == HTMLTagType.script) {
                    totalSize += sizeForBase64Encoding(tagContent.length);
                } else {
                    totalSize += tagContent.length;
                }

                if (isURLSafe) {
                    (tagOpen, tagClose) = tagOpenCloseForHTMLTagURLSafe(
                        htmlTags[i]
                    );
                } else {
                    (tagOpen, tagClose) = tagOpenCloseForHTMLTag(htmlTags[i]);
                }

                htmlTags[i].tagOpen = tagOpen;
                htmlTags[i].tagClose = tagClose;

                totalSize += tagOpen.length;
                totalSize += tagClose.length;
            } while (++i < length);
        }
        return totalSize;
    }

    // =============================================================
    //                     HTML CONCATENATION
    // =============================================================

    /**
     * @notice Append tags to the html buffer for tags
     * @param htmlFile - bytes buffer
     * @param htmlTags - Tags being added to buffer
     * @param base64EncodeTagContent - Bool to handle tag content encoding
     */
    function _appendHTMLTags(
        bytes memory htmlFile,
        HTMLTag[] memory htmlTags,
        bool base64EncodeTagContent
    ) internal pure {
        uint256 i;
        unchecked {
            do {
                _appendHTMLTag(htmlFile, htmlTags[i], base64EncodeTagContent);
            } while (++i < htmlTags.length);
        }
    }

    /**
     * @notice Append tag to the html buffer
     * @param htmlFile - bytes buffer
     * @param htmlTag - Request being added to buffer
     * @param base64EncodeTagContent - Bool to handle tag content encoding
     */
    function _appendHTMLTag(
        bytes memory htmlFile,
        HTMLTag memory htmlTag,
        bool base64EncodeTagContent
    ) internal pure {
        htmlFile.appendSafe(htmlTag.tagOpen);
        if (base64EncodeTagContent) {
            htmlFile.appendSafeBase64(htmlTag.tagContent, false, false);
        } else {
            htmlFile.appendSafe(htmlTag.tagContent);
        }
        htmlFile.appendSafe(htmlTag.tagClose);
    }
}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////
//░░░░░░░░░░░░░░░░░░░    REQUESTS    ░░░░░░░░░░░░░░░░░░░░//
///////////////////////////////////////////////////////////

struct HTMLRequest {
    HTMLTag[] headTags;
    HTMLTag[] bodyTags;
}

enum HTMLTagType {
    useTagOpenAndClose,
    script,
    scriptBase64DataURI,
    scriptGZIPBase64DataURI,
    scriptPNGBase64DataURI
}

struct HTMLTag {
    string name;
    address contractAddress;
    bytes contractData;
    HTMLTagType tagType;
    bytes tagOpen;
    bytes tagClose;
    bytes tagContent;
}

// SPDX-License-Identifier: MIT
// Copyright (c) 2021 the ethier authors (github.com/divergencetech/ethier)

pragma solidity ^0.8.22;

/// @title DynamicBuffer
/// @author David Huber (@cxkoda) and Simon Fremaux (@dievardump). See also
///         https://raw.githubusercontent.com/dievardump/solidity-dynamic-buffer
/// @notice This library is used to allocate a big amount of container memory
//          which will be subsequently filled without needing to reallocate
///         memory.
/// @dev First, allocate memory.
///      Then use `buffer.appendUnchecked(theBytes)` or `appendSafe()` if
///      bounds checking is required.
library DynamicBuffer {
    /// @notice Allocates container space for the DynamicBuffer
    /// @param capacity_ The intended max amount of bytes in the buffer
    /// @return buffer The memory location of the buffer
    /// @dev Allocates `capacity_ + 0x60` bytes of space
    ///      The buffer array starts at the first container data position,
    ///      (i.e. `buffer = container + 0x20`)
    function allocate(uint256 capacity_)
        internal
        pure
        returns (bytes memory buffer)
    {
        assembly {
            // Get next-free memory address
            let container := mload(0x40)

            // Allocate memory by setting a new next-free address
            {
                // Add 2 x 32 bytes in size for the two length fields
                // Add 32 bytes safety space for 32B chunked copy
                let size := add(capacity_, 0x60)
                let newNextFree := add(container, size)
                mstore(0x40, newNextFree)
            }

            // Set the correct container length
            {
                let length := add(capacity_, 0x40)
                mstore(container, length)
            }

            // The buffer starts at idx 1 in the container (0 is length)
            buffer := add(container, 0x20)

            // Init content with length 0
            mstore(buffer, 0)
        }

        return buffer;
    }

    /// @notice Appends data to buffer, and update buffer length
    /// @param buffer the buffer to append the data to
    /// @param data the data to append
    /// @dev Does not perform out-of-bound checks (container capacity)
    ///      for efficiency.
    function appendUnchecked(bytes memory buffer, bytes memory data)
        internal
        pure
    {
        assembly {
            let length := mload(data)
            for {
                data := add(data, 0x20)
                let dataEnd := add(data, length)
                let copyTo := add(buffer, add(mload(buffer), 0x20))
            } lt(data, dataEnd) {
                data := add(data, 0x20)
                copyTo := add(copyTo, 0x20)
            } {
                // Copy 32B chunks from data to buffer.
                // This may read over data array boundaries and copy invalid
                // bytes, which doesn't matter in the end since we will
                // later set the correct buffer length, and have allocated an
                // additional word to avoid buffer overflow.
                mstore(copyTo, mload(data))
            }

            // Update buffer length
            mstore(buffer, add(mload(buffer), length))
        }
    }

    /// @notice Appends data to buffer, and update buffer length
    /// @param buffer the buffer to append the data to
    /// @param data the data to append
    /// @dev Performs out-of-bound checks and calls `appendUnchecked`.
    function appendSafe(bytes memory buffer, bytes memory data) internal pure {
        checkOverflow(buffer, data.length);
        appendUnchecked(buffer, data);
    }

    /// @notice Appends data encoded as Base64 to buffer.
    /// @param fileSafe  Whether to replace '+' with '-' and '/' with '_'.
    /// @param noPadding Whether to strip away the padding.
    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// See: https://datatracker.ietf.org/doc/html/rfc4648
    /// Author: Modified from Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base64.sol)
    /// Author: Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Base64.sol)
    /// Author: Modified from (https://github.com/Brechtpd/base64/blob/main/base64.sol) by Brecht Devos.
    function appendSafeBase64(
        bytes memory buffer,
        bytes memory data,
        bool fileSafe,
        bool noPadding
    ) internal pure {
        uint256 dataLength = data.length;

        if (data.length == 0) {
            return;
        }

        uint256 encodedLength;
        uint256 r;
        assembly {
            // For each 3 bytes block, we will have 4 bytes in the base64
            // encoding: `encodedLength = 4 * divCeil(dataLength, 3)`.
            // The `shl(2, ...)` is equivalent to multiplying by 4.
            encodedLength := shl(2, div(add(dataLength, 2), 3))

            r := mod(dataLength, 3)
            if noPadding {
                // if r == 0 => no modification
                // if r == 1 => encodedLength -= 2
                // if r == 2 => encodedLength -= 1
                encodedLength := sub(
                    encodedLength,
                    add(iszero(iszero(r)), eq(r, 1))
                )
            }
        }

        checkOverflow(buffer, encodedLength);

        assembly {
            let nextFree := mload(0x40)

            // Store the table into the scratch space.
            // Offsetted by -1 byte so that the `mload` will load the character.
            // We will rewrite the free memory pointer at `0x40` later with
            // the allocated size.
            mstore(0x1f, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef")
            mstore(
                0x3f,
                sub(
                    "ghijklmnopqrstuvwxyz0123456789-_",
                    // The magic constant 0x0230 will translate "-_" + "+/".
                    mul(iszero(fileSafe), 0x0230)
                )
            )

            // Skip the first slot, which stores the length.
            let ptr := add(add(buffer, 0x20), mload(buffer))
            let end := add(data, dataLength)

            // Run over the input, 3 bytes at a time.
            // prettier-ignore
            // solhint-disable-next-line no-empty-blocks
            for {} 1 {} {
                    data := add(data, 3) // Advance 3 bytes.
                    let input := mload(data)

                    // Write 4 bytes. Optimized for fewer stack operations.
                    mstore8(    ptr    , mload(and(shr(18, input), 0x3F)))
                    mstore8(add(ptr, 1), mload(and(shr(12, input), 0x3F)))
                    mstore8(add(ptr, 2), mload(and(shr( 6, input), 0x3F)))
                    mstore8(add(ptr, 3), mload(and(        input , 0x3F)))
                    
                    ptr := add(ptr, 4) // Advance 4 bytes.
                    // prettier-ignore
                    if iszero(lt(data, end)) { break }
                }

            if iszero(noPadding) {
                // Offset `ptr` and pad with '='. We can simply write over the end.
                mstore8(sub(ptr, iszero(iszero(r))), 0x3d) // Pad at `ptr - 1` if `r > 0`.
                mstore8(sub(ptr, shl(1, eq(r, 1))), 0x3d) // Pad at `ptr - 2` if `r == 1`.
            }

            mstore(buffer, add(mload(buffer), encodedLength))
            mstore(0x40, nextFree)
        }
    }

    /// @notice Appends data encoded as Base64 to buffer.
    /// @param fileSafe  Whether to replace '+' with '-' and '/' with '_'.
    /// @param noPadding Whether to strip away the padding.
    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// See: https://datatracker.ietf.org/doc/html/rfc4648
    /// Author: Modified from Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base64.sol)
    /// Author: Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Base64.sol)
    /// Author: Modified from (https://github.com/Brechtpd/base64/blob/main/base64.sol) by Brecht Devos.
    function appendUncheckedBase64(
        bytes memory buffer,
        bytes memory data,
        bool fileSafe,
        bool noPadding
    ) internal pure {
        uint256 dataLength = data.length;

        if (data.length == 0) {
            return;
        }

        uint256 encodedLength;
        uint256 r;
        assembly {
            // For each 3 bytes block, we will have 4 bytes in the base64
            // encoding: `encodedLength = 4 * divCeil(dataLength, 3)`.
            // The `shl(2, ...)` is equivalent to multiplying by 4.
            encodedLength := shl(2, div(add(dataLength, 2), 3))

            r := mod(dataLength, 3)
            if noPadding {
                // if r == 0 => no modification
                // if r == 1 => encodedLength -= 2
                // if r == 2 => encodedLength -= 1
                encodedLength := sub(
                    encodedLength,
                    add(iszero(iszero(r)), eq(r, 1))
                )
            }
        }

        assembly {
            let nextFree := mload(0x40)

            // Store the table into the scratch space.
            // Offsetted by -1 byte so that the `mload` will load the character.
            // We will rewrite the free memory pointer at `0x40` later with
            // the allocated size.
            mstore(0x1f, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef")
            mstore(
                0x3f,
                sub(
                    "ghijklmnopqrstuvwxyz0123456789-_",
                    // The magic constant 0x0230 will translate "-_" + "+/".
                    mul(iszero(fileSafe), 0x0230)
                )
            )

            // Skip the first slot, which stores the length.
            let ptr := add(add(buffer, 0x20), mload(buffer))
            let end := add(data, dataLength)

            // Run over the input, 3 bytes at a time.
            // prettier-ignore
            // solhint-disable-next-line no-empty-blocks
            for {} 1 {} {
                    data := add(data, 3) // Advance 3 bytes.
                    let input := mload(data)

                    // Write 4 bytes. Optimized for fewer stack operations.
                    mstore8(    ptr    , mload(and(shr(18, input), 0x3F)))
                    mstore8(add(ptr, 1), mload(and(shr(12, input), 0x3F)))
                    mstore8(add(ptr, 2), mload(and(shr( 6, input), 0x3F)))
                    mstore8(add(ptr, 3), mload(and(        input , 0x3F)))
                    
                    ptr := add(ptr, 4) // Advance 4 bytes.
                    // prettier-ignore
                    if iszero(lt(data, end)) { break }
                }

            if iszero(noPadding) {
                // Offset `ptr` and pad with '='. We can simply write over the end.
                mstore8(sub(ptr, iszero(iszero(r))), 0x3d) // Pad at `ptr - 1` if `r > 0`.
                mstore8(sub(ptr, shl(1, eq(r, 1))), 0x3d) // Pad at `ptr - 2` if `r == 1`.
            }

            mstore(buffer, add(mload(buffer), encodedLength))
            mstore(0x40, nextFree)
        }
    }

    /// @notice Returns the capacity of a given buffer.
    function capacity(bytes memory buffer) internal pure returns (uint256) {
        uint256 cap;
        assembly {
            cap := sub(mload(sub(buffer, 0x20)), 0x40)
        }
        return cap;
    }

    /// @notice Reverts if the buffer will overflow after appending a given
    /// number of bytes.
    function checkOverflow(bytes memory buffer, uint256 addedLength)
        internal
        pure
    {
        uint256 cap = capacity(buffer);
        uint256 newLength = buffer.length + addedLength;
        if (cap < newLength) {
            revert("DynamicBuffer: Appending out of bounds.");
        }
    }
}

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

///////////////////////////////////////////////////////////
// ░██████╗░█████╗░██████╗░██╗██████╗░████████╗██╗░░░██╗ //
// ██╔════╝██╔══██╗██╔══██╗██║██╔══██╗╚══██╔══╝╚██╗░██╔╝ //
// ╚█████╗░██║░░╚═╝██████╔╝██║██████╔╝░░░██║░░░░╚████╔╝░ //
// ░╚═══██╗██║░░██╗██╔══██╗██║██╔═══╝░░░░██║░░░░░╚██╔╝░░ //
// ██████╔╝╚█████╔╝██║░░██║██║██║░░░░░░░░██║░░░░░░██║░░░ //
// ╚═════╝░░╚════╝░╚═╝░░╚═╝╚═╝╚═╝░░░░░░░░╚═╝░░░░░░╚═╝░░░ //
///////////////////////////////////////////////////////////

interface IScriptyContractStorage {
    // =============================================================
    //                            GETTERS
    // =============================================================

    /**
     * @notice Get the full content
     * @param name - Name given to the script. Eg: threejs.min.js_r148
     * @param data - Arbitrary data to be passed to storage
     * @return script - Full script from merged chunks
     */
    function getContent(string calldata name, bytes memory data)
        external
        view
        returns (bytes memory script);
}

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "solady/=lib/solady/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "scripty/=lib/scripty/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"InvalidBodyBytes","type":"error"},{"inputs":[{"internalType":"bytes","name":"colorMap","type":"bytes"}],"name":"colorMapToSVG","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_traitsContract","type":"address"},{"internalType":"address","name":"_tbaAddress","type":"address"},{"internalType":"uint256","name":"_maxTraitsToOutput","type":"uint256"}],"name":"getBackpackSVGs","outputs":[{"internalType":"string","name":"backpackSVGs","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"colorMap","type":"bytes"}],"name":"getBodyImage","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"_pixels","type":"bytes"}],"name":"getBodyImageSvg","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_bodySvg","type":"string"},{"internalType":"string","name":"_traitsSvg","type":"string"},{"internalType":"string","name":"_traitsAttributes","type":"string"},{"internalType":"string","name":"_backpackSVGs","type":"string"},{"components":[{"internalType":"string","name":"backgroundColor","type":"string"},{"internalType":"string","name":"bodyName","type":"string"},{"internalType":"uint256","name":"numOfItemsInBackpack","type":"uint256"},{"internalType":"string[2]","name":"descriptionParts","type":"string[2]"}],"internalType":"struct IChonkStorage.ChonkData","name":"_chonkdata","type":"tuple"}],"name":"renderAsDataUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"string","name":"traitName","type":"string"},{"internalType":"string","name":"traitValue","type":"string"}],"name":"stringTrait","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"}]

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