Feed 10,000 CryptoPunks to a micro transformer stuffed into the Ethereum mainnet and let the model redraw them.

Written by: @tiger_web3

In the past few days, I scanned 20 Slonks on OpenSea. This project launched on May 1, and today marks 5 days since then, with the floor price rising from the mint price to 0.062 ETH, trading 318 ETH in the last 24 hours.

Let me talk about what it is, why I bought it, and what I expect.

In short: Feed 10,000 CryptoPunks to a micro transformer stuffed into the Ethereum mainnet and let the model redraw them.

You heard it right; he really did stuff an AI model into a smart contract.

AI art has always been criticized for having some flaws, making it immediately obvious that it was created by AI, and the author precisely leveraged this point.

He had the model on this smart contract mimic CryptoPunks, and there would always be some errors, contrary to common sense, the more errors there are, the higher the score.

The slogan is slop is the art. The most criticized term in the AI era has now become the project name.

So the tokens generated through the V4 hook of the NFT are called $slop.

There are three important numbers on each NFT:

The first: original number.

It indicates which punk from 1 to 10,000 the AI mimicked.

The second: slop value.

This number represents how many cells the AI got wrong. Each card is 24×24, totaling 576 cells, so the maximum slop value is 576. For example, 287 means "287 out of 576 cells are wrong." This number is the most important attribute of the entire game; the higher it is, the more mistakes were made in the drawing.

The third: level.

• Default 0; merging once increases the level by one.
• The whole game revolves around these three numbers.

In the game, you can do three things.

The first: merge.

Take two cards of the same level, burn one, and the remaining one levels up.

What happens in detail: the AI averages the "impressions" of these two cards in its mind and redraws one. The result will be——definitely a greater difference compared to the original drawing.

In other words, the lower the similarity to the card you merged with, the less it resembles the original punks. The more dissimilar in pixels, the higher the slop score.

The slop value can be exchanged for tokens to sell, and of course, you will also receive a higher-level NFT.

The cost: merging is irreversible; the burnt card is gone forever.

The second: split into tokens (contract launching tomorrow).

The game will eventually issue a token called $SLOP. You can "split" a card to exchange for tokens——

The rules are very straightforward: whatever the slop is on the card, that's how many tokens you get. A card with 287 slop exchanges for 287 $SLOP, and a card with 450 slop exchanges for 450.

This action transforms an "indivisible painting" into "tokens that can be dispersed and circulated." Tokens can be sold for ETH on Uniswap and can be used for the next action.

Why do this? The simplest logic is arbitrage. If a card sells for 0.06 ETH on OpenSea but splitting it into tokens yields 0.10 ETH, then it should be split.

When choosing cards, the ones with high slop are valuable——they have a high token content.

The third: use tokens to draw a card back (not yet opened).

Burning tokens can "draw" a card from the game.

But the drawn card is not new; it's one that someone else previously split. The game has stored them, and the AI will redraw it——so the same punk number may look completely different when redrawn.

There's a 50% chance it will be drawn properly, with low slop; a 49% chance it will be half normal and half chaotic; and there's a 1% chance the AI will completely go crazy——resulting in a drawing with slop close to maximum, looking like nothing at all. This 1% is like a lottery and could be worth a lot of money.

The price is not fixed. It's a Dutch auction, starting at 576 tokens, decreasing by 1 every so often, with a minimum of 100. But if someone buys, it immediately bounces back to 576 to start decreasing again. So it's best to rush in when it's expensive, wait for a bargain, but while you wait, someone else might draw it away first.

What interests me the most isn't the narrative but the engineering implementation.

It really put the neural network on the blockchain. A 22.7 KB transformer, with weights divided into 9 blocks stored in 9 non-functioning contracts using the SSTORE2 model. Every time you mint or merge, it runs forward inference in the EVM and draws SVG on the spot.

Vocab size is 10,000, embedding is 10 dimensions, and there are 18 attention heads. The configuration is small but is indeed running.

Total supply of $SLOP is 5,760,000, exactly 10,000×576.

The mechanism is like this: sending one Slonk into the void, the contract automatically counts how many flawed pixels it has and gives you an equivalent amount of $SLOP. Burning $SLOP can draw a new one back from the void; the new one is a noise-dominated redraw of the original punk.

Using NFTs cut into pixels as tokens, I've not seen this cutting method in other projects.

Its design is quite self-coherent.

First, NFT collectors can collect according to their preferences. Some like rare types from the original CryptoPunk, while others prefer the confusing results after multiple merges.

People can spontaneously create art on-chain, which in itself is a kind of innovation. There is also no need for IPFS hosting in this way.

Additionally, for players treating this as gamefi, they can calculate arbitrage and find the fun in collecting cards.

There are technical breakthroughs and design innovations, while also catering to different players' varying needs.

The only drawback is that it's not so intuitive to understand, but often fun games have some entry barriers, and once played, there may be a group of loyal fans.