Cartesi Network and CTSI

Update on November 26, 2020: Cartesi's side chain (presented below) is from now on called Noether. This is a tribute to the German mathematician Amalie Emmy Noether, who made many important contributions to abstract algebra.
No-ether is also a wordplay suggesting that data storage should be orders of magnitude cheaper on Cartesi's side chain than on Ethereum.

As blockchain projects mature and our understanding of the technology progresses, it becomes ever more clear what challenges impede its mainstream adoption:

• Convenience — developing and using a blockchain application is still an overwhelming task, involving a very difficult learning curve and consequently significantly reducing general interest in the technology;
• Scalability — Blockchains need to perform as well as centralized technology in order to be able to compete with it.

Cartesi is a project that attacks these two problems at once, by creating an infrastructure that is at the same time scalable and compatible with battle-tested technologies.

In our article On Linux and Blockchains, we explain in detail how Cartesi will make blockchain infrastructure compatible with the industry standards of software development, onboarding experienced developers into the decentralized world, without the need to learn idiosyncratic processes and programming languages.

Let us explain below how we tackle the second problem, namely the scalability issues faced by blockchains.

Scalability

Pick as an example any important centralized application, such as Uber, Tweeter, Spotify, or Fortnite. They all involve a large number of powerful servers, receiving millions of messages every minute and storing/processing hundreds of terabytes of data. Meanwhile, decentralized solutions such as Augur, Decentraland, or Cryptokitties are limited to very few expensive transactions per minute, dealing with limited computational capabilities and reduced storage. There is no question that blockchain technology cannot compete on equal grounds with their centralized counterparts.

In order to understand what we propose as a solution to this challenge, we need first to break the problem into smaller pieces, since in fact scalability is composed of many parts:

• Computation — How complex can the logic of a program be? This is analogous to the CPU power of a server;
• Transactions — How many messages can we send and confirm into the system per unit of time? This is analogous to the bandwidth of the network;
• Storage — How many terabytes of data can we store in our server?

Looking at current figures, blockchains struggle to keep up with centralized servers. A very good guideline to measure this problem is the “rule of one million”. This essentially says that blockchains have a one-million-fold disadvantage in each of the above items when compared with their centralized analogs. This is obviously not sustainable in a competitive environment, where every little improvement can make the difference between success and failure.

Although oftentimes the three issues mentioned above are treated as a single problem, under the umbrella of “scalability”, each requires its own technological solution. To understand this, recall how these problems were tackled in the centralized world at the end of the last century: fast CPUs, broadband modems, and large-capacity disks. In the blockchain world, this could not be different: we need to treat these issues separately because they are of very different natures.

We have already addressed the computational limitations of blockchains. This is explained in great detail in our piece On Linux and Blockchains. There we give a brief overview of how we put some beautiful theoretical Computer Science to work and give the blockchain the analogous of a super-computer. With the Cartesi Core, instead of being one million times slower than centralized solutions, DApps can now run at lightning speeds, while maintaining all the security and decentralization guarantees of a blockchain. Our computation solution is already available for developers on our public Github repositories and we have already shown how it can be used in practice by developing a fully decentralized and computational intensive game on Ethereum.

Having solved the limitations of blockchains in terms of computation, our next step is to unleash its power in terms of transactions. This will be done in our upcoming project: the Cartesi Side Chain, which we describe in the remainder of this piece.

Cartesi Side Chain

The problem of scaling the number of transactions in a distributed ledger has received significant attention from both researchers and enterprises. We have now a very good understanding of the gains provided by each solution and which technologies compromise decentralization in exchange for efficiency.

From all the proposed alternatives, we believe that Data Localization is the most promising and uncompromising solution to this problem. This is being attempted for instance by the Ethereum blockchain through their Sharding effort. We, however, believe that a more tailored approach should give us much better performance and other guarantees that Ethereum’s Sharding alone cannot provide. This is why we will develop the Cartesi Side Chain.

We will soon publish a whitepaper with a detailed explanation of how the Cartesi Side Chain will work. For now, let us describe its main requirements and on which points its design can be flexible in order to scale it even further:

• Powerful — Just as everyone expects their internet to have a good bandwidth, we need to have a good volume of transactions per second if we expect to see a viable alternative to centralized services;
• Data Only — Since the Cartesi Core solves the problem of computational scalability on blockchains, we can focus on the problem of Data Availability now. As soon as transactions are available to all interested parties, processing them can be done essentially for free;
• Local — Just like Ethereum’s Sharding proposition, we also believe that not everyone needs to store and transmit all transactions on the network. However, our Locality solution is flexible and decided by the users instead of fixed in the protocol;
• Cost-effective — Transaction cost cannot hamper the use of decentralized applications. By combining several technologies together, we expect to bring the price down to the point that it no longer impedes adoption;
• Proof of Stake — We cannot rely on Proof of Work for the security of our transaction solution as this brings major questions about its sustainability and security. Instead, we will implement a Proof of Stake consensus algorithm;
• Garbage Collection — We don’t need to keep all processed transactions available forever. This would greatly limit the system, without bringing any real benefits. Note however that there is a big problem when we clean-up old data and make it unavailable: it becomes much harder for new users to join the network, since they cannot reconstruct the history from genesis. This problem is mitigated by our Data Availability Protocol solution that we will describe in a later article;
• Embedding — There is no need for the Cartesi Chain to be a blockchain of its own, with all the complexity that this brings to its design. Cartesi is inherently a second layer solution and, as such, it can use the underlying blockchain for the heavy lifting of its protocol. This makes it very easy to solve complicated problems, such as the ordering of packages, timing attacks, randomization, elections, and so on.

These are the guiding principles that we are using to design and build the Cartesi Side Chain. Its Proof of Stake algorithm will run on Cartesi Tokens (CTSI), giving the system the required security and decentralization guarantees.

Soon we will release an article explaining how we will achieve a high staking rate for our protocol, while at the same time guaranteeing limited inflation on the system as a whole. Stay tuned for more!

The Cartesi Token

Having described the main design principles and features of the Cartesi Side Chain, we now turn to its main ingredient: the Cartesi Token.

We are currently developing a Proof of Stake blockchain running on top of Ethereum and maintained by a network of Node Operators. The Cartesi Token will be essential for this system to work as it provides:

• Staking — Since block generators will be selected in proportion to their stakes in the economy, there needs to be a way to query and lock everyone’s balance in the system.
• Election of block producers — The miners will be selected to propose blocks in proportion to their token balance, so that the network is run by a pulverized community of stakeholders.
• Slashing — Bad behavior is disincentivized by locking and potentially slashing the tokens of dishonest actors.
• Transaction fees — Although we are designing our Side Chain to be orders of magnitude cheaper than the underlying main chain, users or DApp developers still need to pay for their transactions to be processed, transmitted and temporarily stored by others. These fees will be paid to Node Operators with the Cartesi Token.
• Challenge computations — The Cartesi Token will also be important in order to challenge computation results posted on the blockchain. This will work as an exit mechanism that guarantees the correct execution of DApps and discourages bad behavior.

All these aspects of the Cartesi Token will be further explained in our coming articles on the Cartesi Side Chain and Cartesi Roll-ups.

Important Links:

Website: https://cartesi.io
Twitter: https://twitter.com/cartesiproject
Telegram: https://t.me/cartesiproject
Discord: https://discordapp.com/invite/Pt2NrnS
GitHub: https://github.com/cartesi