Custom Contracts

From the beginning, Superpositions has been about hidden potential — images generated from quantum data, their meaning emerging only when observed. But I wanted to push this idea further. What if the quantum data itself remained concealed, locked away until the holder of the work chose to reveal it?

This led to an unusual problem: how do I create a “lock” in a digital medium where everything is, by default, transparent?

This idea of a lock ties directly to the rest of the project, which consists of several sealed envelopes that the holder can choose to open. Breaking the data’s lock would be nicely mirror breaking an envelope's seal. But how could I make this work?

One idea was to use an NFT. I imagined a "primary" NFT holding the data and a second NFT functioning as a "lock." To reveal the data, the holder would destroy (or "burn," in NFT terms) the lock. As long as the lock NFT existed, the primary NFT would keep the data hidden. But once the lock was gone, the data would be accessible.

An NFT’s “smart contract” (i.e., program) determines what it can do. But I couldn’t find any existing public NFT contracts that enabled the lock functionality I was looking for. Still, I was encouraged when I found examples of NFTs that respond to external conditions. For instance, the aside-eth project features NFTs that react to phenomena such as stock market values. Perhaps I could take a similar approach but use a second NFT as the external condition.

I quickly realized I would need a custom contract. But with no experience working with NFTs at that level, the prospect felt daunting. So I reached out to a couple of different platforms to see if they could develop a contract to meet my needs.

The conversations were productive, though new complications arose at every step. For instance, most NFT data isn’t stored “on-chain.” Instead, the NFT typically holds a URL pointing to a data file elsewhere. This is because on-chain storage is expensive — minting an NFT containing all my data could cost hundreds of dollars.

At one point, we thought we had found a solution — until we realized that anyone monitoring the platform’s stream of mints could examine the NFT and its data.

It was starting to look like an NFT-based approach wasn’t feasible — or at least not within my project’s timeline. I could take a less technical route, like placing a flash drive in the envelope. But that would mean losing a key reason for using an NFT in the first place: on-chain data is duplicated across all copies of the blockchain, a feature deeply tied to the project’s conceptual foundations.

At this point, with a mix of sadness and panic, I decided to see what I could do myself.

And while I remain skeptical and wary of modern AI, I haven’t ignored it in my work. So I turned to ChatGPT to see if it might offer any advice.

My query: Could you help me write a custom smart Etherium contract and mint some tokens with it? This is something I've never done before. How hard is it to do?

ChatGPT: Creating a custom Ethereum smart contract to mint tokens is a great way to dive into blockchain development. It might seem daunting at first, but with modern tools and libraries, it’s very approachable—even for beginners with some programming background. Here’s an overview of what’s involved and a sample walkthrough…

GPT to the rescue!? Maybe I had expected to be told that what I wanted was impossible. But the response, which included sample code, instantly made this seem solvable.

So I dove in. First, I spent a little more time explaining to ChatGPT exactly what I wanted to accomplish. Next I was pasting the code it generated into Remix, the tool for compiling and minting custom contracts. There was a side trip into the world of test networks (to avoid making a "forever“ on-chain error), Sepolia and faucets. But everything went smoothly – much better than one of my earlier attempts at collaborative coding.

And it was quick. Less than two hours after starting I had minted a custom contract with my data was able to view it on Etherscan. All with ChatGPT as my copilot, answering my questions along the way.

Wow! (Which was also the reactions from a couple friends after I told them what I'd just done.)

The final contract turned out to be much simpler than my original primary-and-lock NFT setup. Instead of two NFTs, I created a single one that stores the data. By using a unique wallet for each instance, the NFTs aren’t traceable back to me. And by placing the NFT’s address in a sealed envelope, I’ve hidden it from view entirely. Opening the envelope is equivalent to burning the lock.

In retrospect, I’m surprised by how passive I was when first approaching the NFT component of this project. After all, I’ve long argued that technical proficiency shouldn’t be a prerequisite for working with new technologies. We all have the agency to shape tech to our own needs. So why didn’t I follow my own advice?

Maybe it’s because, in the past, I’ve typically started with public-domain code when engaging with unfamiliar technologies. And for some reason, I assumed there wasn’t anything out there to use as a foundation for my own custom contract — which was wrong. If nothing existed, ChatGPT wouldn’t have known about it.

This isn’t meant to be a post about the power of modern AI—its flaws and dangers remain. But it is a reminder that we can use these tools to remove barriers to participation. And that, through participation, we become more comfortable.

This project reinforced something I’ve always believed: technology isn’t something to be passively accepted — it’s something we can shape to fit our needs. And the more we engage with it, the more we realize that the barriers we perceive are often more about mindset than actual limitation.