DOCSEARCHbyAlgolia
Submit Docs

Cartesi Rollups API and Smart Contracts

website·Indexed 35 days ago

https://docs.cartesi.io/

Documentation for Cartesi Rollups, covering the GraphQL API for querying inputs, notices, reports, and vouchers, as well as Solidity smart contracts including CartesiDApp and InputBox. Includes details on cursor-based pagination, response formats, and functions for managing dApp state, executing vouchers, and depositing ERC20, ERC721, and ERC1155 tokens.

Tokens
202.2K
Snippets
760
Records
1.2K
Agent score
68%

What's inside Cartesi

  1. Overview of the Cartesi Honeypot application

    The Honeypot is a Cartesi application designed to demonstrate the capabilities of the PRT (Persistent Runtime) fraud-proof system in a real-world scenario, focusing on application logic and state management.

  2. Overview of the Cartesi State Transition Function (STF)

    Cartesi applications operate within the Cartesi Machine, a deterministic alternative virtual machine based on the RISC-V ISA. The State Transition Function (STF) manages how inputs—typically read from the Ethereum base layer—change the state of both the Cartesi Machine and the Ethereum layer. The STF's integrity is maintained through the machine's state snapshots and a fraud-proof system based on Merkle proofs of the state hashes.

  3. Overview of Cartesi Compute SDK

    Cartesi Compute SDK allows dApps to run complex or data-intensive computations off-chain in a full Linux environment while maintaining decentralization. Instead of executing logic on-chain (which is limited by block gas limits), participants agree on results off-chain. The blockchain is used only as a 'supreme court' for dispute resolution via an interactive verification algorithm, ensuring that arbitration costs remain negligible even for large computations.

  4. Introduction to Cartesi's Fraud Proof System

    Cartesi's Fraud Proof System enables secure and decentralized verification of off-chain computations. The implementation focuses on the Permissionless Refereed Tournament (PRT) and is applied in the Honeypot App. This system is intended for researchers and builders implementing fraud proofs.

  5. Overview of Cartesify Web3 Client

    Cartesify is a Web3 client designed for interacting with the Cartesi Machine. It allows developers to send transactions to the machine, query data, and interact with backend systems via a REST-like interface.

  6. Overview of the Rollmelette framework for Cartesi

    Rollmelette is a high-level framework designed to simplify the development of Cartesi applications using the Go programming language. It provides a high-level API for interacting with the Cartesi Machine, specifically streamlining the processes of sending inputs, retrieving outputs, and managing assets.

  8. Overview of the Cartesi Machine

    The Cartesi Machine is a deterministic, isolated virtual machine based on the RISC-V ISA that runs a full Linux OS to execute a dApp's backend. It functions similarly to an AWS Lambda function by abstracting infrastructure and allowing the use of any Linux-compatible programming language and library. To ensure reproducibility and verifiability of off-chain computations, the machine is self-contained and cannot make external requests.

  9. Overview of ERC20 TestToken on Anvil Devnet

    The TestToken is an OpenZeppelin-based ERC20 token deployed on the anvil devnet. It is owned by the default anvil wallet 0xFBdB734EF6a23aD76863CbA6f10d0C5CBBD8342C, which is pre-minted with 10,000,000,000 units for testing purposes. Note that transactions and token balances reset every time the anvil devnet is restarted or the application is stopped using the Cartesi CLI.

  11. Overview of Cartesi Tournament Dispute Resolution

    Cartesi uses core tournament contracts to implement an asynchronous PRT-style dispute resolution mechanism. This system resolves disputes among N parties in O(log N) depth using chess-clock timing and asynchronous pairing (claims are matched as they arrive without a prebuilt bracket).

    Concrete implementations include:

    • SingleLevelTournament: For single-level disputes.
    • TopTournament: The root of multi-level instances.
    • MiddleTournament: Intermediate levels.
    • BottomTournament: The leaf level where actual state transitions are performed.

  12. Overview of the DaveConsensus Contract

    The DaveConsensus contract (also known as PRT-Rollups Consensus) is the consensus layer for applications using Dave-style tournaments (e.g., PRT) for verification. It validates a single application whose inputs must come from a pre-configured InputBox contract. It manages epochs—sequentially numbered half-open block-number intervals [a, b)—and links input ingestion, epoch progression, and tournament-based verification.