Presenting Cartesi Q3 Milestones

As of 2022 Descartes has now been renamed as Cartesi Compute.

Cartesi keeps advancing vigorously on research and development, committed to bringing vast possibilities for the future of the DApp ecosystem. Shortly, we will provide important updates covering the team’s expansion, the DApp Incubation Program, new strategic partnerships, and critical advances on development.

This post provides a summary of the technical progress done in regards to the roadmap in Q3 2020.

Proof-of-stake prototype & mining on Testnet

The PoS prototype and mining are working and deployed on Testnet. The prototype allows one to run a node, test the staking of Ropsten CTSI, and get Ropsten CTSI rewards from the mine.

You can check the implementation, learn how to download and run a node, and stake Ropsten CTSI by following the instructions our Github repository.

If you missed what Cartesi’s PoS system is about, here is a quick recap. We are currently developing a Proof of Stake blockchain running on top of Ethereum and maintained by a network of Node Operators, called Cartesi Sidechain. CTSI is essential for this system to work as it provides the use cases of staking, block producer election, slashing, and paying for transaction fees. For more information, read this article.

As described on our roadmap, the sidechain will achieve completion in 2021. However, the algorithm that allows for staking and the selection of block producers is a dependency that was meant to be ready before the sidechain itself.

In Q4, staking (with CTSI from the mine reserve) will be available on Mainnet. That will come together with the explorer portal which will provide users a thorough overview of Cartesi’s network and the ability to stake CTSI by delegating work to node runner organizations.

Furthermore, in the following days, we are publishing an article that explains staking in more detail. That will include practical information on how CTSI from the mine reserve will be distributed and how node operators and stakers will be rewarded as the system is deployed on Mainnet in Q4.

High-level Google Remote Procedure Call (GRPC) for Roll-ups

This work has been accomplished and you can check the code here and here.

You may wonder what this piece is about. In its current state, Cartesi Compute does not support a stateful Cartesi Machine. Instead, it works by running a single computational task that is defined by smart contracts and runs off-chain on the Cartesi Compute nodes. Albeit stateless, it allows for a large array of applications that require the execution of heavy computation in a decentralized way.

With optimistic roll-ups, Cartesi takes a great step further, with the ability to preserve state off-chain. This essentially allows for smart-contracts running directly on top of Cartesi Compute, which is akin to having a decentralized Linux server, highly boosting the productivity and possibilities of smart contract developers.

The GRPC interface for Roll-ups relies on Cartesi Machine's new support to the replacement of input drives. In summary, whenever a new transaction needs to be processed, its data is passed on to the machine in the form of a new drive. The machine wakes up, advances its state by processing the input, and halts. The evolution of machine states is kept deterministic, provable, and then enforceable by honest validator nodes when the roll-ups are implemented on-chain.

Infrastructure reevaluation

This milestone comprises a set of software design and architecture decisions that have been successfully concluded.

Most of this work was anticipated and done earlier in Q2, and resulted in the Cartesi Compute API specification itself. This big set of changes was not meant to be implemented that early and instead, we would provide API documentation of Cartesi referring to the same infrastructure like the one we used to build Creepts.

We were not satisfied. At some point in Q2, we realized that the former design of Cartesi required from DApp developers a significant amount of knowledge about the internal modules of the system and that would impose a difficulty of coding that deemed unacceptable.

That led us to an unexpected task force of architecture redesign and profound changes in the codebase. Most of this work was anticipated and done in Q2 itself. To deliver the API documentation in Q2, the team worked hard (amidst the extra difficulties brought about the pandemic) to provide a much better packaging of the tech.

The team’s sprint was worth it. We finished the process with something clear and easy to use, we decided to brand it as Cartesi Compute.

The remaining aspects of the infrastructure reevaluation task included:

• The specification of the dehashing device, a powerful new feature that allows the Cartesi Machines to look up blocks and access to any data in the blockchain. DApps will be able to introspect the chain and use any arbitrary information as input data for any off-chain logic. As an example, you can imagine accessing the gas price at any point in history or any third-party transaction data without the need of oracles.
• We have specified a new architecture for the off-chain Cartesi Node including many improvements, such as better scalability, optimization of interactions with the blockchain node (local or remote), better handling of exceptional behavior (e.g. disconnections and power-offs), improved processing of blockchain events and more. This new design is now being implemented and it should be ready to replace our current infrastructure by Q4.
• We have implemented and released a proxy smart contract to govern the relationship between Cartesi Users and Cartesi Nodes. This infrastructure allows users to run nodes in many different ways: locally, remotely, or even from a third-party provider. In the latter case, there is no need to share any private keys nor to transfer tokens to said provider. This user/worker relationship is a milestone for the future release of our anticipated Platform as a Service.

Release of tournament API documentation

Due to the changes brought about by the Cartesi Compute project and no immediate demand for the tournament API, the activities on this product have been discontinued.

Those who followed our progress from last year will know Creepts was developed on top of the infrastructure that preceded Cartesi Compute. The system included a (decentralized) tournament infrastructure that could be generalized for other games and competitions.

With the profound simplifications brought about by the Cartesi Compute API, we decided to discontinue the previous tournament infrastructure and its documentation. Although one can use the Creepts project on Github as a template to create tournaments, we encourage developers to instead build their tournament-based games directly on top of Cartesi Compute, which is well documented on our documentation portal. That should be a relatively simple development effort.

If you are a developer and want to create a competition DApp (or any other DApp on Cartesi), we will be glad to assist you on our Discord channel. Using Cartesi Compute to create your competition is straightforward and the team is happy to support.

In case you want to create a product, we encourage you to apply for the DApp Incubation Program before October 12th.

We also encourage anyone with questions to join our development community on Discord!

Cartesi Ecosystem Links:

Website: https://cartesi.io

Creepts: https://creepts.cartesi.io/

Twitter: https://twitter.com/cartesiproject

Telegram Community: https://t.me/cartesiproject

Discord: https://discordapp.com/invite/Pt2NrnS

GitHub: https://github.com/cartesi