the charts by jvmi project has been the most ambitious project i've endeavored to build as an nft artist. throughout this journey, i've encountered numerous challenges and made countless discoveries, but the reveal mechanism has always been a foundational element of the project.

what is an nft reveal?

in the world of blockchain-based digital art, an nft reveal is when an artist finalizes the artwork behind the nft they're creating. this typically happens in one of two ways:

• instantly after the nft is minted

• a day or two after all nfts in a collection are minted
  

the reveal has always been one of the most thrilling aspects of the nft collection lifecycle for me. in fact, one of my primary motivations behind creating charts by jvmi was to bring something fresh to how collectors experience their nfts revealing. i wanted to implement something unprecedented in the space.

the concept: dynamic charts that unfold over time

once i was confident in the general structure of the artwork, the idea for the reveal mechanism became obvious: the bars in the chart should reveal one day at a time, simulating the real-world market dynamics we've all grown accustomed to.

imagine owning a chart that gradually reveals itself over a week, each day adding a new data point—just like watching a crypto chart unfold in real-time. that excitement, that anticipation of what might happen next, is exactly what i wanted to capture.

this presented a unique technical challenge that required me to implement a system with the following characteristics:

• fully self-sustaining - i should have zero influence over the values being generated

• automated - it should occur at precisely the same time every day

• fully onchain - it should operate without external dependencies requiring metadata to exist partially offchain

with these constraints in mind, i began building.

a technical deep dive into the system

behind the charts by jvmi project is a smart contract mechanism designed to reveal each bar of the chart over seven consecutive days. here's how it works:

the seed generation

// Every day at 12pm PST, this captures the current blockchain state
function updateGenesisTokenSeeds() external {
    bytes32 seed = blockhash(block.number - 1);
    s_genesisTokenSeeds[s_genesisTokenSeedsIndex] = seed;
    s_genesisTokenSeedsIndex++;
}

every day at exactly 12pm pst, a chainlink automation system triggers this function, which:

• captures the latest block hash on the base network at that precise moment

• stores it as the "seed" for that day's reveal

• this process repeats for 7 consecutive days, creating 7 unique seeds

the block hash is essentially a cryptographic fingerprint of the latest block on the blockchain—unpredictable and impossible to manipulate.

turning seeds into chart values

// This transforms the seeds into chart bar heights
function generateValuesFromSeeds(uint256 tokenId, bytes32 tokenSeed) public view returns (uint8[7] memory) {
    uint8[7] memory values;
    
    for (uint256 i = 0; i < 7; i++) {
        if (i < s_genesisTokenSeedsIndex) {
            bytes32 combinedSeed = keccak256(abi.encodePacked(tokenId, tokenSeed, s_genesisTokenSeeds[i]));
            values[i] = uint8(uint256(combinedSeed) % 100) + 1;
        }
    }
    
    return values;
}

when your nft is displayed:

• your token's unique id is combined with the day's seed

• this mixture is cryptographically hashed to create a random-but-deterministic number

• this number is converted to a value between 1-100

• this value determines the height of each bar in your chart

each day, as a new seed is added, another bar in your chart reveals itself. after 7 days, your complete chart is visible. the suspense builds day by day, just like watching a real market develop.

what this system accomplishes

this reveal mechanism creates something truly unique in the nft space:

• genuine surprise - nobody (not even me) knows what any chart will look like in advance

• true immutability - the values can't be manipulated once the contract is deployed

• complete automation - the entire process happens automatically and transparently on-chain

• dynamic storytelling - each chart reveals day by day, creating a week-long narrative for collectors

the experience mirrors the anticipation and emotional journey of watching actual market charts develop over time, which is at the very core of what this project is attempting to illustrate through art & code.

the collector experience

for collectors, this means:

• checking back daily to see how your chart evolves

• experiencing the emotional rollercoaster of seeing bars go up or down

• sharing the journey with other collectors as everyone's charts reveal simultaneously

• owning an nft that tells a unique story through its reveal process

in the end, charts by jvmi isn't just about the final artwork—it's about the journey of watching your unique chart take shape, capturing the essence of what makes markets so captivating in the first place

• i've open sourced the entire smart contract codebase here