Disclosure: The views and opinions expressed here belong solely to the author and do not represent the views and opinions of crypto.news’ editorial.
Don’t you hate it when you see yet another layer-1 launch, claiming one million, 10 million, or even 100 million TPS? “How can I cash in on the hype?” you ask. Well, today is your lucky day! Here’s a step-by-step guide on building your very own 1 billion TPS layer-1 network that’ll leave those posers in the dust.
You might also like: From crypto projects to digital asset companies: It’s time to level up web3 comms | Opinion
Step 1: Get a supercomputer and run EVM on it
A single high-end machine can run transactions in the Ethereum Virtual Machine (EVM) to ~100k TPS—a pretty well-documented technical fact. But to reach this level of throughput, you do need to bypass the Patricia Merkle Trie during reads and writes to permanent state, in order to remove a major throughput bottleneck that limits the standard EVM to just under 100 TPS. This mechanism in the EVM exists to ensure that the network, sorry, the single machine, is able to correctly handle any state rollbacks and network reorganizations…anyway, who cares, it’s slow, it’s gone, don’t worry about it.
We’re using the EVM because being EVM-compatible, or better yet, EVM-equivalent, is pretty important these days, since it has become a standard in web3 development. The majority of the world’s web3 applications are written in Solidity or other languages that compile into the EVM bytecode. This way, you can attract more developers to build on your new 1 billion TPS network. Trust me, bro, “EVM-equivalent” totally sells.
Step 2: Forget the network
A single machine is also a network on its own, technically speaking. Why complicate this side hustle with more than one machine?
Besides, having other machines on the network just slows things down. If you have a network filled with different machines run by different people, they now suddenly have to agree with each other on what happens on the network. This involves communicating information across the network, coming up with mechanisms to agree on what’s happening, and then reaching a consensus before making progress. Sounds slow af. This consensus mechanism is just a lot of wasteful overhead. Who needs it?
Let’s just stick with a single machine. Check out all these hot projects called layer-2s; their networks are all just a single machine. If you worry about being called out for being centralized, simply create a number of other machines on the network and assign them fancy names, such as “data availability nodes” or similar. Everyone’s doing it.
Step 3: Make 100 shards
Get ready, this is where we elevate your game, with sharding.
You take your network of one machine and make 100 copies of it; we’ll call this sharding, very on-trend. Technically speaking, a sharded network’s state is only temporarily sharded across machines and will eventually be partially or fully synchronized to guarantee consistency during cross-shard transactions. In adversarial environments such as crypto, machines across shards are often shuffled to prevent collusion.
But let’s not get technical. These 100 copies don’t need to synchronize anything; they don’t even need to communicate with each other. It’s a network of 100 shards!
If you’re keeping score, we now have 100 shards * 100k TPS = 10 million TPS!
Step 4: Ditch the EVM
Did we say EVM-equivalent is all the rage? That’s old news. Now it’s all about being the EVM-killer.
EVM is just so slow. It’s a stack-based interpreted virtual machine that was designed to be fully agnostic to the underlying hardware architecture and operating systems, to maximize repeatability and execution correctness, so that a large group of disparate machines can safely and securely operate on the same network. But man, is it slow.
Let’s go with something sexy like WASM-JIT. It’s highly performant, mature, and most major programming languages can be compiled into WASM. Since it does compile to native register-based machine code that targets specific hardware architectures, it is inherently less portable than a purely stack-based VM like EVM. In real-world implementations, WASM-JIT can outperform the EVM up to 100x in execution speeds.
Ditch the EVM, we now have 10 million TPS * 100 = 1 billion TPS.
You did it!
Stay tuned, and we’ll teach you how to further elevate your 1 billion TPS layer-1 network even further with unrealistically-optimistic concurrency!
Read more: Beyond the hype: Web3 is in dire need of a rebrand | Opinion
Steven Pu
Steven Pu is the co-founder of Taraxa, a purpose-built, fast, scalable, and device-friendly layer-1 public ledger designed to help democratize reputation by making informal data trustworthy. Prior to Taraxa, Steven launched multiple ventures and products in IoT and mobile healthcare. He was also a Partner at Monitor Deloitte’s strategy practice, spearheaded their digital strategy line of business, serving Fortune 500 companies with hundreds of millions in upside impact. Steven also had the honor of co-authoring the book “Next Blockchain” with Makoto Yano, vice-minister of Japan’s Ministry of Economics, Trade, and Industry. Steven holds undergraduate and master’s degrees in Electrical Engineering from Stanford University.