The Tally Protocol: Scaling Ethereum With Untapped GPU Power

How to run large, powerful apps on the Ethereum blockchain, using hardware we already have.

Here’s a major blind spot in blockchain: is there a better use of the GPUs in the Ethereum world?

The answer is yes. We currently deploy ridiculous amounts of GPU hash power for proof-of-work calculations, but the Ethereum Virtual Machine (EVM) functions like a simple, slow CPU.

This is by design. But it means the network gets choked by games like CryptoKitties. And it’s freaking people out.

Scaling solutions like sharding or off-chain payment channels speed up peer-to-peer payments. But if we want blockchain to live up to its biggest promises, we need a solution that can coordinate large ecosystems with diverse governance models, managing huge numbers of actions all happening at once.

The good news is—a lot of that is just number crunching. And GPUs are very good at that.

That’s why Cardstack is creating Tally: a Layer 2 protocol that lets dApps harness GPU power to perform heavy-duty calculations. Think data analysis, complex logic, machine learning, AI algorithms. We do this by rewarding GPUs with a fair cut of a dApp ecosystem’s value in return for performing this useful work behind the scenes.

From an end user’s perspective, every click, every transaction, every confirmation would use these number crunching capabilities, reducing only what’s absolutely necessary onto the blockchain for finality. This would achieve the type of consumer experience in terms of speed and smarts that everyone’s waiting for.

A little more background

A blockchain transaction is basically a price you pay to ensure whatever you just transacted is final. After 10 confirmations on Bitcoin, you know that transaction is final. On Ethereum, given the way a smart contract works, once you have the token, it’s final. Current dApps typically perform many transactions that are final in the course of the user experience. That’s extremely taxing and it wastes the capacity of this global ledger.

The way to scale a blockchain app is to try and reduce the number of instances of finality, and still maintain a decentralized, trustless model so people can’t just break the rules and steal your money. Layer 2 solutions, like Raiden and Lightning, are ways to delay the finality. Don’t close my tab yet, let me get a couple more drinks, then when the bar closes up or you decide to leave, you close the tab.

The problem is, many of these Layer 2 solutions don’t support the smart-contract based logic that allows for the complex governance and payment models that dApps need to become truly powerful.

Tally has a more ambitious goal: to keep the benefits of smart contracts, while doing as little on-chain work as possible.

Tally: the basic concept

Let’s start with the simplest possible topology for a Tally-implemented number crunching system that can process the immediate results, before settling back on-chain for finality.

For example: you are trying to build a dApp that implements blockchain-based voting. Assume you have one million voters. The simplest way to do this is to ask each voter to cryptographically sign a message indicating their preference for a particular candidate. Instead of every voter immediately putting their vote on-chain for finality, we can have a GPU-powered oracle read the votes and crunch the numbers before reporting the results back to a smart contract.

But imagine that this election decides who gets access to a large portion of the tokens in the ecosystem. This makes the oracle extremely vulnerable to attacks.

The solution is to move to a decentralized arrangement where there are multiple, possibly hundreds or thousands of vote-tallying oracles, working in anonymity to prevent collusion, each with a proven and locked stake in the network, of which one or a few are randomly selected through a sortition scheme to report the results. Suddenly, hacking the election would require a lot more resources.

What we want to do pay the oracles a percentage of the value at stake in return for securing the network. Now, as the value of the election grows, the oracles will share in it, raising the cost of an attack.

Here’s the key insight: when you give a cut of the pool to these agents, they stop becoming oracles and in effect become miners, where their economic interest to secure the network is aligned with the participants of the network. We call them analytic miners.

And if you think of blockchain as a series of elections to confirm new blocks — then this voting example can be generalized to into a whole new way thinking about blockchain.

Tally is a consensus algorithm rooted in the principles of statistics. Using Schelling points, we can give decentralized miners a strong incentive to run the same software as everyone else, to source the same raw data, and to get the same results. Once we have that, we can safely use a central point of tendency (such as mean, median, mode) from the miners’ results as a form of consensus.

Returning to our original thesis: today’s proof-of-work miners are literally printing money with their GPUs. But as the value of dApps and the specialized economies they facilitate becomes greater, it makes sense for dApps to share a portion of their value with miners in exchange for this huge, untapped supply of hash power.

Here’s why this matters: for the Tally protocol to succeed in Ethereum’s ecosystem, we don’t need new hardware and new roles. We have enough.

All we have to do is help decentralized apps rewrite a part of their smart contract logic as GPU-friendly algorithms, and give economic incentives to GPU miners to use their hardware to count millions of votes per second. And then, write the results of who the winners are, with a single transaction on the Ethereum blockchain.

There, we just scaled an Ethereum dApp to a million transactions per second.

Some concluding thoughts

We often marvel at how little attention Facebook and Google are paying to blockchain, but the reverse is also true. There isn’t enough appreciation in the crypto community for things like parallelizable machine learning, pattern recognition, large-scale log processing and graph-based network analysis — in other words, how digital superpowers govern their own private networks.

Fortunately, all the recent innovations in these areas are all available as open-source toolkits, many of them implemented in GPU-friendly libraries that the blockchain world can co-opt overnight. And if we can attract the right kind of expertise from the machine learning world, the data science world — we will find that many of the goals set forth in our whitepapers are actually very good fits for the toolsets that Silicon Valley has perfected over the last decade.

We are working on a proof-of-concept of Tally that tackles the software metering and billing problem (how do you effectively measure the use of software?) by analyzing the dependencies between applications and open-source libraries. Software is the world we’re from, so we think it’s right to use our first attempt with Tally to distribute wealth fairly to open-source makers and creators.

But we see this underlying technique as something that can be used as a template for many of the other decentralized ecosystems that we hear about every day.

Proof-of-work mining has given the crypto community the most powerful global network of computing power the world has ever seen. Instead of letting the media joke about how much power it consumes, let’s get our heads together to figure out how we could use these resources to do useful computation work.

Within the walls of digital superpowers like Google, AWS, and Facebook, researchers and engineers are pouring huge resources into figuring out how to capture our attention, measure our interest, reshape our world views, and monetize our every behavior. But they’re not invincible.

Let’s take the idealism that we have, leverage the data learning and machine learning tools given to us by these companies, tap into our powerful global network of economically-aligned miners, and build a more fair and transparent software system that can hopefully make the digital world a better place.

For more on Tally, read this blog post by Cardstack lead developer Ed Faulkner.

To learn about how Tally uses Merkle trees to scale payments, read this blog post by Cardstack senior blockchain developer Hassan Abdel-Rahman.