This is an investment thesis for the Vercel3 startup we’re building.

First thing to recognise - crypto is here to stay. Users like to own things, and they like to speculate on assets. So far, we have memecoins everywhere (Dogecoin, Einsteinium) and early mainstream adoption for finance - albeit, using legacy fiat currencies like USDC. Although NFT’s are mainstream, they realistically aren’t more than a property registry right now.

What is the biggest challenge facing crypto? It’s not the technology, it’s the UX. Let me give you a number of problems:

• a user needs to install a wallet to use your app. ❌

• which wallet do they install? this depends on the chain ❌

• user needs to buy the chain-native currency. ETH, MATIC, and bridge it from wherever they bought it ❌❌

• if they want a global username (ENS), they need to go through another UX flow to make this happen ❌

This is just the beginning. What are the UX problems for the developer on an EVM chain?

• They have to write their own contract deployment scripts. Dangerous and WTF. ❌

• They have to write their own contract upgrade logic. Using hairy stuff like OpenZeppelin. Double WTF. ❌❌

• They have to write their own setup to store contract artifacts (ABI’s), addresses (network, address), and deployment metadata (deploy block). This can then be used to share with other repos - the indexer (subgraph) and frontend. Usually written for NPM/JS. ❌❌

• They have to manually track all of this inside Git. What happens when a bug is discovered in an old version of the contract? It means manually checking out the old code. ❌

• They have to setup a separate deployer account. Load it with tokens. Share around the key manually to different developers on their team. ❌❌

• For developers leveraging their protocol, they too need to manually integrate these contract addresses + ABI’s into their own deployments. And keep track of which versions were used. ❌

Finally, let’s look at the future of blockspace. The point of blockspace is to build credibly neutral infrastructure, that runs atop this machine we call blockchain. A blockchain is a combination of a microservices layer (smart contracts, VM’s) and a strongly consistent database.

Verifiable vs. Decentralized.

The key feature of blockchains is verifiability. Unlike a centralized API, we can verify the results of writing to and reading from this database. Admittedly, crypto is a joke, and only very recently did verifiable RPC actually become a thing - I wrote my own eth-verifiable-rpc, and Helios is the forerunner here. But this has always been the core property.

A closely linked idea to verifiability is decentralization. What does decentralization even mean? We argue online about these abstract ideas - Solana isn’t decentralized!!! It’s a centralized ponzi. These are stupid debates stemming from a context-dependent word. Decentralized, with respect to who? Solana is decentralized, with respect to running your database on a centralized cloud provider like AWS. Admittedly, Solana might just be running on 3 public clouds (AWS, Azure, GCP) - but this is still distributing trust among 3 entities instead of just 1. Ethereum is much more decentralized - Ethereum is decentralized with respect to the nation state actor - like USA, UK, etc. It is very hard to censor or capture Ethereum, since it runs all over the world - and there is much data that Ethereum stakers are indeed, run on home computers worldwide (although execution nodes are a different matter).

Up until 2022, decentralized infrastructure and verifiable infrastructure have tended to refer to the same thing, but that table is about to be flipped. “Who cares where your node is running if you give me a [ZK] proof and I can verify it?” is something Mike from Lyra said when I was telling him about this - previously, in order to trust a blockchain, you have to run a full node, and basically pay the cost. Trust, but verify. But what if you could verify it without running a node? Is that even possible?

ZK proof revolution.

Enter, ZK proofs. In early 2022, I was building a social network called Gliss. Gliss fit the bill for a real crypto idea - it wasn’t just a port of an art gallery onto a blockchain. It was reimagining if everyone’s attention online was a token with its own unique price. And so your influence was a token itself, as a basket of the attention tokens that your followers were paying you. Very different - and requiring more computation than Polygon could even support. After all - how could you sell a basket of >1K tokens in a single atomic tx? Impossible on rollups. But I had heard about this idea of ZK proofs being much more efficient. And so I dug deep. I joined the Starkware Discord, and started asking questions. Within 10 minutes I was chatting to a Frenchman named Louis, who I would later learn is a fucking legend in the community. He called me up and I’ll always remember him saying this in a French accent - “ok, so what I am goiing to do, is give you a grant for $10,000 dollars. what this will do is align us both” from that moment I was set.

I dove so deep into STARK’s that I wrote a twitter thread that was retweeted by Paradigm themselves. Literally the most intellectually stimulating read of my entire life - I sat down at 12pm on a weekday, and for 6hrs, just sat at my computer, reading and publishing my thoughts. Like a wild ADHD beast, I was hunting and gathering for understanding - my tools of choice are Sourcegraph - a sort of way to Google and navigate any Github repo, and Twitter - a way to atomise thoughts. The entire way through I was driven by understanding - what is Cairo, what are STARK’s, how does this differ to a normal blockchain, how do you even prove computation? How does storage work?

So let me summarise the core takeaways of the ZK revolution:

1. There are two models for verifiable computation - (1) replicated state machines and (2) prover-verifier computation.

2. All existing L1 blockchains thusfar are examples of #1 - Bitcoin, Ethereum, Polygon, Solana, Polkdadot. A replicated state machine costs O(N) - every node must replicate every transaction by re-running all of its N steps verbatim.

3. Prover-verifier architecture is entirely different. In the prover-verifier architecture, a prover generates a proof of a computation, and anyone else can verify that proof.

4. STARK proofs can prove computation in O(log N) steps. That’s the first takeaway - a STARK can essentially “compress” a computation with an exponential speedup.

5. STARK proofs can aggregate the verification of other proofs - thereby making it possible to send a proof which verifies a set of proofs, which themselves verify a set of proofs…and have a 20kB blob which verifies the entire Bitcoin blockchain. Yes, that’s possible - see ZeroSync.

6. This is called recursive proofing and it’s profound. It enables on-chain deep neural networks, horizontal-scaling for decentralized databases, L3’s, and so on…

7. Different ZK protocols (Groth16, Plonky2, Nova, Halo2) have different space-time tradeoffs - fast proofing, big proof, slow proofing, small proof, etc - and be composed. To make the UX good, proofs will be generated using a fast-but-big ZK protocol, generating lots of data, but then will be slowly aggregated into smaller bundles using slow-but-small ZK protocols - much like how images are “progressively” rendered on websites. Remco has drawn a fantastic real-life example of this on Twitter.

8. ZK and AI both use the same underlying hardware - the GPU - since they both rely on heavily parallel computation models. Although ASIC’s are inevitable, as always. It’s going to be exciting to see polynomial commitments accelerated in phones.

The magical thing about proofs is that we can prove anything. Even an entire blockchain. We can verify that proof really cheaply. In fact, we can even verify proofs of an entire blockchain - on another blockchain. Which can be used for bridging. But I digress. Why>?

What is blockspace even for?

People don’t really have any imagination anymore. The idea of crypto is rehypothecating what is valuable. The reason that gamers hate crypto is because, fair enough, they don’t think that you should shove the idea of microtranscations and every item being able to be bought, down their throat, because it’s not fun. A game mechanic ought to be fun.

The fun of blockchains is credibly neutral infrastructure, for the internet, where we can build games of value. For example:

• A market is a simple game, where two people meet and make predictions on how valuable an object is to them and others in future, and if they find a common price, they swap.

• Yield farming is a game, kinda similar to a ponzi, but there are no lies. Everyone knows the rules of the game - get-in, get-out at the right time, try not to get rugged.

• Nouns is a game where people try to see how far they can meme a brand into being cool with the cool kids. ie. Paris Hilton showing her Bored Ape on Jimmy Falon’s Show. The core mechanic of Nouns is that to have a vote, you have to buy a Nouns NFT. And every day, one NFT is auctioned off (emergent governance). The price of the auction is basically the future expectation of the value of the Nouns brand.

DeFi is now a matter of 1-to-N progress - we have exchanges, oracles, perps, options, etc in place - it’s just rebuilding these on different tech stacks now. What is remaining is - quite literally - everything else. Value is intersubjective, and the majority of the blockchain’s potential is in expressing that - there are only like 200+ fiat currencies, but there are 8B people on this planet. Everything will have a price. The 0-to-1 innovation is figuring out new ways of bringing new value on-chain, and reorienting capitalism.

The basic learning from “fashion repeats itself” is that what people find valuable changes over time, and if you look at a JPEG of a rock being worth $1m, then it shows you this fact very squarely. You could say it’s a product of a low interest rate environment, but then why do NFT’s still have value, even now? How many more times does this have to repeat before people realize that it’s not a ponzi? I cast my eyes back to what Reggie James wrote in 2021:

Live by the medium, die by the medium. It’s not a ponzi. It’s that when everything is a measurable market, you see how fast people can move on. And that is a very different environment to get used to.

The core of blockchain’s potential to the world is not an open database. It’s giving speculation as a superpower to the masses. It’s making it possible for anything to become fine art (NFT), sellable on the worldwide art markets (OpenSea), verified for no cost, and - this is the important part - feels as real and as hard as something physical.

When it comes to designing systems, it makes more sense to think of the need for a blockchain as “does this thing have a price?” or “does it interact with a thing that has a price?”. If it doesn’t, then you don’t need a blockchain. For example:

• indexers - don’t need a blockchain.

• dapps - don’t need a blockchain for hosting. Just use IPFS.

• games with physics - maybe need a blockchain, if the physics is part of a game mechanism which unlocks something of value

Again, the blockchain is all about games of value. If the thing you’re building isn’t a game with things of value, then it probably doesn’t need a blockchain. Because a blockchain is about a system of rules, running atop a credibly-neutral infrastructure. [1]

The case for more blockspace.

And so, the more blockspace there is, the more bandwidth we have to experiment with value. This means putting more things on-chain - hot takes, items, lore, etc. And developing new games with them - ie. meme perpetuals. And building new networks - consider a stablecoin backed by a subculture.

However, none of this will happen without two things: (1) more blockspace and (2) better UX.

What if we solved both?

A Vercel for L3’s - combining deep tech and UX.

Imagine spinning up an L3 blockchain, as simply as deploying a frontend on Vercel.

You write some contracts, connect your Github, and everything just gets spun up flawlessly. No faffing around with writing deployment scripts or upgradeable proxies, it is done for you. Continuous deployment for blockchain.

All of your contracts are automatically tracked and managed in a contract registry. No need to verify on Etherscan. It’s all centrally available, deployment registry is mirrored on-chain, so that third-party developers can integrate 10x faster.

Serverless blockchains.

The idea is writing a blockchain node in a serverless way. Instead of a big monolithic piece of software that you usually scale using “clusters”, you can scale much easier using this idea of serverless functions. The core of a blockchain is a state transition - basically taking a transaction, the current state, and a state transition function (e.g. the EVM), and running transition(state_t, tx) → state_t+1 to get the new state.

We can load all the blockchain state from a cloud database, run the VM with the tx, and then save the new state leaves. Afterwards, we generate a proof of it. For example, using Kakarot we can prove any run of the EVM. And we mirror that proof on P2P networks, so anyone can run a permissionless node.

“Who cares where your node is running if you give me a [ZK] proof and I can verify it?”

Imagine the convenience and speed of centralized databases, with the verifiability and programmability properties of blockchains. That is what we want to build.

What about UX?

This is the user journey for a mainstream user of a crypto social app:

1. Visit Take. Realise you have to have a wallet.

2. Download suggested wallet.

3. Setup wallet.

4. Figure out which gas token you need.

5. Buy the gas token. Maybe register for a CEX. Or use Apple Pay.

6. Back to Take. Now switch chains (!).

7. Swap back to wallet. Switch chain UX.

8. Back to Take.

I’m literally building a social network and I can tell you, this is insanely fucking bad UX. It’s never going to go mainstream this way, let alone Metamask - which is the most horrid, confusing information design of anything I’ve ever used.

What if we removed all of this complexity? Imagine this flow:

1. Visit Take.

2. Sign in with Apple / Ethereum.

3. Use app.

That’s what we should build. To understand what this looks like under the hood:

Solving UX - virtual wallets.

Remove the need for connecting a wallet - sign in with ethereum OR sign in with web2 (Google, FB, email). We create virtual wallets on the server for all web2 accounts - same same but different. Users can at any time opt to send their assets to their self-sovereign wallet. We don’t care.

Solving UX - different fee models.

This begins with the idea - what if users didn’t have to pay for txs?

It ends with - what if users could pay for txs differently? What if they could access a chain if they owned a certain NFT? Or what if the project begins as “free” and once it becomes big enough, then a fee token is added and it “progressively decentralizes”?

There is a whole design space for fees which is much more compatible with the mainstream market, and a lot more forward-thinking than simply gas station and relayer networks. I think ImmutableX put it best in their post from 2022:

Solving DX - private games.

One of the harder parts of building on-chain games is - how do you have private information? Like in Age of Empires, how do you have fog of war, so you don’t know where the other player is.

This is something we can solve, and make delightful for developers to use. So that anyone can develop DarkForest-like games without handling ZK proofs.

Solving DX - state channels.

TODO: Loaf can you help flesh this out

Solving DX - testnets for PR’s.

One thing that people don’t realise is that testnets have always sucked. What is weird is that if you look at Vercel, they have "staging” deployments for every PR. We could totally do this - deploy a new blockchain for every PR, since they are just lightweight “serverless” functions.

Solving DX - built-in indexers.

Since the blockchain node is decomposed into serverless functions, the database is in the cloud, we have all of the ABI’s and contract code - we could automatically generate indexes of data.

Solving DX - built-in bridging.

In the wireframes above, I mention built-in bridging using Herodotus. Bridging shouldn’t be something that developers have to build - it should be built-in to the platform.

Summary.

• Mainstream adoption is blocked by blockspace, wallet UX, and cost right now.

• Blockspace can be unleashed by building serverless chains, that are verifiable through proofs.

• Developers are constrained by focusing on handrolled deployment pipelines, upgrade logic, getting testnet tokens.

• Product experiences are ruined by multi-hop user journeys, getting tokens, swapping between apps, with confusing messaging.

• Ecosystems are blocked by information sharing - contract artifacts and addresses.

We can solve all of these things by building a single platform that combines:

• An automatic way to spin up L3’s - verifiable infrastructure, thanks to ZK proofs.

• A continuous deployment pipeline for smart contracts - that abstracts away upgrades, tracking deployments and ABI’s.

• A managed wallets service - that allows users to login with web2 (Google, Apple), instead of installing/managing a wallet app.

• Different fee models - allowing users to pay without gas tokens, or NFT-gated blockchains (ie. Loot Realms NFT’s).

Why not?

How does this compete?

Spinning up L2’s/L3’s:

• Polygon Edge - $400k to setup your own blockchain.

• StarkNet - no L3’s yet. Proprietary prover network. Slow moving.

• OPCraft - manual, CLI-based stack for deploying a chain

• Avalanche - manual, CLI-based stack for deploying a chain.

• Cosmos - manual, CLI-based stack for deploying a chain.

• Constellation - monolithic model, no testnet chains etc.

• ImmutableX - not a generalised compute runtime. Not as easily composable.

Wallets:

• All of the above require third-party services to solve the wallet UX in some way or another - Magic.link + ZeroDev.

The core insight: no-one is integrating at all layers of the stack - blockchain (L3), protocol (contracts, deployment), application (wallet, fees). We can do this and make a killer platform.

What’s the business model?

• SaaS play.

• Take a % of the blockchain volume - ie. issued token, transaction value (like ImmutableX).

What’s the MVP?

• EVM deployment pipeline (done)

• Serverless EVM

• UI

• Whole stack integration

---

Footnotes:

[1] an interesting perspective on this is the paper by Graeber - It is Value Which Brings Universes Into Being.