Staging batch 4

.vscode/ltex.hiddenFalsePositives.en-US.txt

@@ -1,3 +1,4 @@
 {"rule":"BASE_BASIS","sentence":"^\\QThis guide covers the Cartesi+Espresso integration and how to upgrade Cartesi application such that inputs can be submitted via Espresso instead of the regular base layer.\\E$"}
 {"rule":"MORFOLOGIK_RULE_EN_US","sentence":"^\\QIntegrating Cartesi and Chronicle offers Cartesi applications access to onchain and offcahin data like, price feed without developers having to set up additional systems or intermediaries.\\E$"}
 {"rule":"MORFOLOGIK_RULE_EN_US","sentence":"^\\QPrevado Id:\\E$"}
+{"rule":"MORFOLOGIK_RULE_EN_US","sentence":"^\\QThe Devnet environment functions similarly to a mainnet.\\E$"}

cartesi-rollups_versioned_docs/version-2.0/getting-started/architecture.md → cartesi-rollups_versioned_docs/version-2.0/api-reference/architecture.md

@@ -26,6 +26,49 @@ A decentralized application (dApp) built on Cartesi incorporates several key ele
 
 - Frontend: The application’s user-facing interface, typically implemented as a web application or a command-line interface tool.
 
+## What is a Blockchain Rollup?
+
+A rollup is a blockchain scalability solution that offloads complex computations "off-chain," meaning they run on a separate computing environment (execution layer) outside the base layer, such as Ethereum.
+
+When employing rollups, the blockchain receives and logs transactions. In rare instances of an active attack or the involvement of a malicious agent, parties may disagree with a computation’s outcomes, and the blockchain will resolve these disputes. However, it's important to note that disagreements are not expected to occur under normal circumstances.
+
+
+Users interact with a rollup through transactions on the base layer. They send messages (inputs) to the rollup on-chain smart contracts to define a computation to be processed and, as such, advance the state of the computing environment on the execution layer. Interested parties run an off-chain component (a node on the execution layer) that watches the blockchain for inputs, understanding, and executing the state updates.
+
+Once in a while, the state is checkpointed on the chain; at this point, it is considered finalized and can thus be accepted by any smart contract on the base layer.
+
+Ensuring this operation is secure is vital, meaning that the execution layer node must somehow prove the new state to the base layer.
+
+Consider this question: _"How does Ethereum know that the data posted by an off-chain L2 node is valid and was not submitted maliciously?"_
+
+The answer depends on the rollup implementation, which falls within one of two categories according to the type of proof used:
+
+1. **Zero-knowledge Rollups (ZK Rollups)**, which use validity proofs.
+
+2. **Optimistic Rollups (ORs)**, which use fraud proofs.
+
+### Zero-knowledge Rollups (ZK Rollups)
+
+In ZK rollups, which use validity proof schemes, every state update is accompanied by a cryptographic proof created off-chain, attesting to its validity. The update is only taken if the proof successfully passes verification on-chain. Validity proofs(ZK Rollups) bring the enormous benefit of instant finality—as soon as a state update appears on-chain, it can be fully trusted and acted upon.
+
+The choice, however, also brings less than ideal properties: generating ZK proofs for general-purpose computations is, when possible, immensely expensive, and each on-chain state update must pay the extra gas fee for including and verifying a validity proof.
+
+### Optimistic Rollups (ORs)
+
+Optimistic Rollups, which use fraud-proof schemes, work by a different paradigm. State updates come unaccompanied by proofs; they’re proposed and, if not challenged, confirmed on-chain. Challenging a state update proposal using fraud proofs has two categories: **non-interactive** and **interactive**.
+
+Non-interactive refers to the fact that the challengers can prove that a state update is invalid in one step. With interactive fraud proofs, the claimer and challenger must, mediated by the blockchain, partake in something similar to a verification game.
+
+The assumption that state updates will likely be honest often gives solutions like this the name of Optimistic Rollups.
+
+This optimism is reinforced by financial incentives that reward honest behavior. Furthermore, any proposed false state will only be accepted if it remains undisputed for a prolonged period.
+
+
+The main advantage of Optimistic Rollups is that they are much cheaper than ZK Rollups. Posting a state update on-chain is minimal, and challenging a state update is also low.
+
+The main disadvantage is that state updates take time to finalize and are not entirely accepted immediately. During this period, they are considered "optimistic" and can be challenged.
+
+
 ## Cartesi Rollups
 
 Cartesi's Optimistic Rollups adopt interactive fraud proofs to handle disputes.
@@ -37,6 +80,8 @@ Transactions and computations occur off-chain, leading to more intricate logic w
 Cartesi's architecture specializes in app-specific rollups(appchains). Each dApp has its dedicated rollup for off-chain computation, enhancing scalability and performance. 
 
 
+
+
 ![img](../../../static/img/v1.5/architecture-overview.jpg)
 
 ## Cartesi Machine
@@ -160,3 +205,14 @@ The validation process ensures the integrity of the off-chain computations:
 - The application frontend can fetch proofs for specific outputs within a closed epoch.
 
 - These proofs can validate outputs on-chain, such as validating notices or executing vouchers.
+
+## Introducing Dave — an interactive fraud-proof system
+
+[Dave](https://github.com/cartesi/dave) is Cartesi's dispute resolution algorithm designed to address shortcomings in existing fraud-proof protocols. Traditional fraud-proof systems often face challenges such as delay attacks and vulnerability to Sybil attacks, where malicious nodes can disrupt operations by continuously challenging transactions or overwhelming honest validators.
+
+Dave introduces an approach where the resources required to defend against disputes grow logarithmically with the number of opponents. This means that defending against challenges remains affordable for a single honest node, even in the face of multiple attackers.
+
+With Dave, a single honest participant can effectively defend their claims on-chain, ensuring the integrity of transactions without relying on trust in validators. Based on the [Permissionless Refereed Tournaments algorithm](https://arxiv.org/abs/2212.12439), this protocol empowers anyone to validate rollups and uphold correct states on-chain, enhancing transaction security and reliability.
+
+Similar to how a consensus algorithm is crucial for achieving agreement on a single state of the blockchain among all nodes in a base-layer chain, Dave plays a fundamental role in ensuring the integrity and trustworthiness of state transitions within Cartesi Rollups.
+

cartesi-rollups_versioned_docs/version-2.0/api-reference/backend/notices.md

@@ -56,22 +56,16 @@ async function handle_advance(data) {
 <pre><code>
 
 ```python
-def handle_advance(data):
-   logger.info(f"Received advance request data {data}")
-
-   status = "accept"
-   try:
-       inputPayload = data["payload"]
-       # Send the input payload as a notice
-       response = requests.post(
-           rollup_server + "/notice", json={"payload": inputPayload}
-       )
-       logger.info(
-           f"Received notice status {response.status_code} body {response.content}"
-       )
-   except Exception as e:
-       # Emit report with error message here
-   return status
+# Notice creation Process from a message string
+def emit_notice(message):
+    notice_payload = {"payload": "0x" + message.encode("utf-8").hex()}
+    response = requests.post(rollup_server + "/notice", json=notice_payload)
+    if response.status_code == 200 or response.status_code == 201:
+        logger.info(f"Notice emitted successfully with data: {notice_payload}")
+    else:
+        logger.error(f"Failed to emit Notice with data: {notice_payload}. Status code: {response.status_code}")
+
+emit_notice("hello world")
 ```
 
 </code></pre>

cartesi-rollups_versioned_docs/version-2.0/api-reference/contracts/application-factory.md

@@ -6,11 +6,7 @@ resources:
     title: Application Factory contract
 ---
 
-The **ApplicationFactory** contract is a tool for reliably deploying new instances of the [`Application`](../contracts/application.md) contract with or without a specified salt value for address derivation.
-
-Additionally, it provides a function to calculate the address of a potential new `CartesiDApp` contract based on input parameters.
-
-This contract ensures efficient and secure deployment of `Application` contracts within the Cartesi Rollups framework.
+The **ApplicationFactory** contract allows anyone to reliably deploy a new [`IApplication`](https://github.com/cartesi/rollups-contracts/blob/v2.0.0/src/dapp/IApplication.sol) contract.
 
 ## Functions
 

cartesi-rollups_versioned_docs/version-2.0/development/asset-handling.md

@@ -48,7 +48,7 @@ Users can deposit assets to a Cartesi Application, but only the Application can
 
 Vouchers are crucial in allowing applications in the execution layer to interact with contracts in the base layer through message calls. They are emitted by the off-chain machine and executed by any participant in the base layer. Each voucher includes a destination address and a payload, typically encoding a function call for Solidity contracts.
 
-Next, the off-chain machine uses the address of the application on the base layer to generate a voucher for execution at the [`executeVoucher()`](../api-reference/json-rpc/application.md/#executevoucher) function of the `CartesiDApp` contract. This address is known to the offchain machine because it is embedded in the metadata of every input sent to the application, though the developer will need to implement extra logic fetch this address from the metadata then properly store and retrieve it when needed in situations like generating the above Voucher.
+By calling [`relayDAppAddress()`](../api-reference/json-rpc/relays/relays.md), function of the `DAppAddressRelay` contract, it adds the dApp’s address as a new input for the Cartesi dApp to process. Next, the off-chain machine uses this address to generate a voucher for execution at the [`executeVoucher()`](../api-reference/json-rpc/application.md/#executevoucher) function of the `CartesiDApp` contract.
 
 :::note epoch length
 By default, Cartesi nodes close one epoch every 7200 blocks. You can [manually set the epoch length](./cli-commands.md/#run) to facilitate quicker asset-handling methods.
@@ -58,7 +58,7 @@ Here are the function signatures used by vouchers to withdraw the different type
 
 | Asset    | Destination    | Function signature                                                                                                                          |
 | :------- | :------------- | :------------------------------------------------------------------------------------------------------------------------------------------ |
-| Ether    | dApp contract  | `withdrawEther(address,uint256)` [:page_facing_up:](../api-reference/json-rpc/application.md/#withdrawether)                                |
+| Ether    | dApp contract  | `withdrawEther(address,uint256)` [:page_facing_up:](../api-reference/json-rpc/application.md/#withdrawether)                            |
 | ERC-20   | Token contract | `transfer(address,uint256)` [:page_facing_up:](https://eips.ethereum.org/EIPS/eip-20#methods)                                               |
 | ERC-20   | Token contract | `transferFrom(address,address,uint256)` [:page_facing_up:](https://eips.ethereum.org/EIPS/eip-20#methods)                                   |
 | ERC-721  | Token contract | `safeTransferFrom(address,address,uint256)` [:page_facing_up:](https://eips.ethereum.org/EIPS/eip-721#specification)                        |

cartesi-rollups_versioned_docs/version-2.0/getting-started/index.md

@@ -28,7 +28,7 @@ In its simplest form, the Cartesi framework integrates tightly with the base lay
 
 ## Example
 
-Below is a simple Node.js example demonstrating how to read an input and reply with a [notice](../api-reference/backend/notices.md) (a type of output).
+Below is a simple Node.js example demonstrating how to read an input and reply with a [notice](./api-reference/backend/notices.md) (a type of output).
 
 ```javascript
 const { ethers } = require("ethers");
@@ -54,7 +54,7 @@ let finish = { status: "accept" };
 
 ```
 
-Cartesi dApps are implemented as infinite loops that manage their transaction cycles through HTTP POST requests to the `/finish` endpoint to ensure flexibility across different programming languages and stacks. You can learn more about this abstraction [here](../api-reference/backend/introduction.md).
+Cartesi dApps are implemented as infinite loops that manage their transaction cycles through HTTP POST requests to the `/finish` endpoint to ensure flexibility across different programming languages and stacks. You can learn more about this abstraction [here](./api-reference/backend/introduction.md).
 
 In the Cartesi Rollup framework, all inputs sent to the base layer trigger an "advance_state" [request](../development/send-inputs.md#initiate-an-advance-request), which alters the state of the Cartesi Machine and consequently the Rollup. Since inputs originate on-chain, they are hex-encoded following the EVM message standard.
 

cartesi-rollups_versioned_docs/version-2.0/resources/community-tools.md

@@ -0,0 +1,182 @@
+---
+id: community-tools
+title: Community tools
+---
+
+Several tools created and maintained by the community streamline the dApp creation process on Cartesi Rollups.
+
+## Deroll
+
+Introducing Deroll, a powerful TypeScript framework designed to simplify the development of dApps on Cartesi.
+
+- **Features**:
+	- Simplifies dApp development with intuitive methods.
+	- Handles advance and inspect requests easily.
+	- Comprehensive wallet functionality for ERC20, ERC721 and ERC-1155 token standards.
+	- Integrated router for complex routing logic.
+
+- **Getting Started**:
+	- Create a new Deroll project by running:
+		```bash
+		npm init @deroll/app
+		```
+
+- **Resources**:
+	- [Deroll Documentation](https://deroll.dev)
+	- [Deroll GitHub Repository](https://github.com/tuler/deroll)
+
+---
+
+## NoNodo
+
+NoNodo is a cutting-edge development tool for Cartesi Rollups that allows applications to run directly on the host machine, bypassing Docker or RISC-V compilation.
+
+- **Features**:
+	- Run applications directly on the host machine for faster performance.
+	- No Docker or RISC-V Required.
+
+- **Getting Started**:
+	- Install NoNodo by running:
+		```bash
+		npm install -g @nonodo/cli
+		```
+- **Resources**:
+	- [NoNodo GitHub Repository](https://github.com/Calindra/nonodo)
+
+---
+
+## Cartesify
+
+Cartesify is a robust Web3 client designed for seamless interaction with the Cartesi Machine.
+
+- **Features**:
+	- Send transactions to the Cartesi Machine.
+	- Query data efficiently.
+	- Engage with backend systems using a REST-like interface.
+
+- **Resources**:
+	- [Cartesify GitHub Repository](https://github.com/Calindra/cartesify)
+
+---
+
+## Tikua
+
+Tikua is a versatile JS Cartesi package designed for seamless integration with any visual library, whether in browser or terminal environments.
+
+- **Features**:
+	- Integrates smoothly with any visual library on both Browser and Terminal.
+	- Supports any provider or network with extensive configurability.
+	- Handles multi-chain applications.
+	- Provides warnings for unsupported provider chains.
+	- Retrieve machine results.
+
+- **Resources**:
+
+	- [Tikua GitHub Repository](https://github.com/doiim/tikua)
+
+
+---
+
+## Rollmelette
+
+Rollmelette is a high-level framework that simplifies building Cartesi applications using the Go programming language.
+
+- **Features**:
+	- Simplifies the development of Cartesi applications.
+	- Provides a high-level API for interacting with the Cartesi Machine.
+	- Simplifies sending inputs, retrieving outputs and asset handling 
+	- Supports the Go programming language.
+
+- **Resources**:
+	- [Rollmelette GitHub Repository](https://github.com/rollmelette/rollmelette)
+
+---
+
+## Crabrolls
+
+Introducing Crabroll, a powerful Rust framework designed to simplify the development of rust applications on Cartesi.
+
+- **Features**:
+	- Simplifies dApp development with intuitive methods.
+	- Handles advance and inspect requests easily.
+	- Comprehensive wallet functionality for ERC20, ERC721 and ERC-1155 token standards.
+
+- **Getting Started**:
+	- Create a new crabrolls project by running:
+		```bash
+		git clone git@github.com:crabrolls-cartesi/template.git
+		```
+
+- **Resources**:
+	- [Crabrolls Documentation](https://crabrolls-cartesi.github.io/crabrolls/)
+	- [Crabrolls GitHub Repository](https://github.com/crabrolls-cartesi/crabrolls)
+
+---
+
+## Python-Cartesi 
+
+Python-Cartesi is a high-level framework that simplifies the development of Cartesi applications using Python.
+
+- **Features**:
+	- Simplifies the development of Cartesi applications.
+	- Prioritizes testing, equipping developers with tools to write tests for DApps within a local Python environment.
+	- Allows full control over inputs and outputs for scenarios where high-level tools may be insufficient 
+	- Supports the Python programming language.
+
+- **Getting Started**:
+	- Install Python-Cartesi by running:
+		```bash
+		pip install python-cartesi
+		```
+- **Resources**:
+	- [Python-Cartesi GitHub Repository](https://github.com/prototyp3-dev/python-cartesi)
+
+---
+
+## TypeScript-SQLite template
+
+A backend application built with TypeScript and SQLite, designed to complement a corresponding frontend project.
+
+- **Features**:
+	- TypeScript and SQLite for backend development.
+	- Integration with React for the frontend.
+	- Ethers.js for seamless blockchain interaction.
+	- Template designed for easy project initiation.
+
+- **Resources**:
+	- [TypeScript-SQLite GitHub Repository](https://github.com/doiim/cartesi-ts-sqlite)
+	- [Pre-deployed demo available on the Sepolia Network](https://doiim.github.io/cartesi-ts-react-sqlite/).
+
+---
+
+## Python-Wallet
+
+A Python-based wallet implementation for Cartesi dApps designed to handle various types of assets.
+
+- **Features**:
+	- Simplifies asset handling for Cartesi dApps.
+	- Deposit assets into the dApp.
+	- Transfer assets within the dApp.
+	- Withdraw assets from the dApp.
+
+- **Resources**:
+	- [Python-Wallet GitHub Repository](https://github.com/jplgarcia/python-wallet/tree/main)
+	- [Full example](https://github.com/jplgarcia/python-wallet/blob/main/dapp.py)
+---
+## CartDevKit
+
+CartDevKit is an all-in-one package for building on Cartesi.
+
+- **Features**:
+	- CLI tool for easy project setup.
+	- Templates for backend, frontend and Cartesify.
+
+- **Getting Started**:
+	- Create a new project:
+		```bash
+		npx cartdevkit@latest create mydapp
+		```
+
+- **Resources**:
+	- [CartDevKit GitHub Repository](https://github.com/gconnect/cartdev-kit)
+	- [CartDevKit Documentation](https://africlab.gitbook.io/cartdevkit)

cartesi-rollups_versioned_docs/version-2.0/tutorials/calculator.md

@@ -18,7 +18,7 @@ The backend will be written using Python. For added flexibility, feel free to ex
 
 Install these to set up your environment for quick building:
 
-- Cartesi CLI: A simple tool for building applications on Cartesi. [Install Cartesi CLI for your OS of choice](../development/installation.md).
+- Cartesi CLI: A simple tool for building applications on Cartesi. [Install Cartesi CLI for your OS of choice](../getting-started/installation.md).
 
 - Docker Desktop 4.x: The tool you need to run the Cartesi Machine and its dependencies. [Install Docker for your OS of choice](https://www.docker.com/products/docker-desktop/).