the charts project began as an exploration of how i can represent market dynamics in an artistic form. in my previous post, i discussed how i built an entirely onchain, day-by-day reveal system. today, i'm excited to share another innovative mechanism within the project: the burn to elevate system.

understanding palette hierarchy

when you minted a charts nft, you received one of the five genesis palettes:

these palettes determine the colors of your chart, but they're just the beginning of what's possible.

i've designed a tier system where collectors can elevate their charts to craft increasingly rare palettes

how elevation works

the elevation process is simple but strategic: you select one chart to elevate and another chart to burn. both charts must be from the same tier. when you perform this action, your elevated chart moves up to the next tier and receives a new palette from that tier & generates a new pattern.

the magic of this system is the way each burn creates ripples of unpredictability throughout the entire collection. i've implemented a collective randomness mechanism that perfectly mirrors the chaotic yet interconnected nature of crypto markets themselves.

collective randomness: a market parody

the most unique aspect of the elevation system is the way randomness is determined. unlike traditional nft mechanics where outcomes are isolated, in charts, every elevation action affects the entire collection.

here's how it works:

// from MetadataRenderer.sol
function elevate(uint256 elevateTokenId, uint256 burnTokenId) external onlyNFTContract {
    // validation logic...
    
    // generate new palette
    uint8 newTier = elevateTier + 1;
    uint8 newPalette = MetadataUtils.calculateElevatedPalette(newTier, globalSeed);
    
    // set token palette
    tokenPalettes[elevateTokenId] = newPalette;
    tokenPalettes[burnTokenId] = 0;
    // set token seed
    tokenSeeds[elevateTokenId] = globalSeed;
    tokenSeeds[burnTokenId] = 0;
    // update global seed
    globalSeed = Utils.generateNextSeed(globalSeed, elevateTokenId);
    
    // ...
}

each time someone elevates a chart, it updates a global seed in the contract. this global seed influences the outcome of all future elevations in the collection. in essence, when you elevate your chart, you're not just changing your own nft—you're subtly influencing the outcomes for every collector who comes after you.

this system is an artistic parody of market manipulation in crypto spaces, where actions of individual traders can cascade into widespread market effects. just as a whale's move might influence countless smaller traders, each elevation in charts sends ripples through the collection's ecosystem.

strategic elements for collectors

what does this mean for you as a collector?

1. unpredictable results - there's no way to perfectly game the system, as you can't predict when others will elevate (palette and values are random)

2. your future tier is known - you will know the tier that your outcome will result in based on the tier of the charts you decide to burn

3. community influence - your actions will randomly affect other collectors' outcomes

the palette you receive from a particular tier is determined by this communal randomness:

// from MetadataUtils.sol
function calculateElevatedPalette(uint8 tier, bytes32 seed) internal pure returns (uint8) {
    if (tier == Constants.ELEVATED_TIER) {
        uint8 randomValue = uint8(uint256(keccak256(abi.encodePacked(seed))) % 4);
        if (randomValue == 0) return Constants.RGB;
        if (randomValue == 1) return Constants.CMY;
        if (randomValue == 2) return Constants.WARM;
        if (randomValue == 3) return Constants.COOL;
    }
    if (tier == Constants.ULTRA_TIER) {
        uint8 randomValue = uint8(uint256(keccak256(abi.encodePacked(seed))) % 2);
        if (randomValue == 0) return Constants.CHROMATIC;
        if (randomValue == 1) return Constants.PASTEL;
    }
    if (tier == Constants.ELITE_TIER) {
        return Constants.GREYSCALE;
    }
    revert("Invalid tier");
}

this same mechanism also influences the chart values themselves - the data points that determine how your chart is drawn. each elevation creates a new random seed that's used to generate these values, ensuring that every elevated chart tells a unique visual story.

the result

the mechanism ensures complete randomness while creating an interactive element among collectors. it's random because there's no way to know with certainty if someone else will elevate before you, thus altering your results. yet it's not entirely chaotic - there's a system and logic to it that mirrors the semi-predictable, semi-random nature of real markets. you will be able to predictably move up the ranks (tier) when you burn your charts.

blending art + code

in building charts, i wanted to innovate on the very idea of what a digital piece of art means to the world. the elevation system is a step forward in creating an interconnected ecosystem where each action resonates through the entire collection.

this approach fundamentally changes what it means to collect and interact with nfts. your chart isn't just an isolated piece of digital art - it's part of a living, breathing ecosystem that responds to the collective actions of its community.

as with real markets, timing, strategy, and a bit of luck all play a role in the outcome.

you can elevate your charts here

— jvmi 🏎💨