docs(fix) squashed fixup commits here

Author: Nonnyjoe

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

@@ -54,7 +54,7 @@ emit_voucher("mint(address)", "0x784f0c076CC55EAD0a585a9A13e57c467c91Dc3a", ["ad
 <pre><code>
 
 ```javascript
-import { stringToHex, encodeFunctionData, erc20Abi } from "viem";
+import { stringToHex, encodeFunctionData, erc20Abi, zeroHash } from "viem";
 
 async function handle_advance(data) {
   console.log("Received advance request data " + JSON.stringify(data));
@@ -70,7 +70,7 @@ async function handle_advance(data) {
   let voucher = {
     destination: erc20Token,
     payload: call,
-    value: '0x',
+    value: zeroHash,
   };
 
   await emitVoucher(voucher);

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

@@ -52,10 +52,96 @@ The application’s off-chain layer often requires knowledge of its address to f
 
 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.
 
+Below is a sample JavaScript code with the implementations to transfer tokens to whoever calls the application, notice that the `const call` variable is an encoded function data containing the token contract ABI, function name and also arguments like recipient and amount, while the actual `voucher` structure itself contains a destination (erc20 token contract where the transfer execution should occur), the payload (encoded function data in `call`) and finally a value field which is initialized to `0` meaning no Ether is intended to be sent alongside this transfer request.
+
+```javascript
+import { stringToHex, encodeFunctionData, erc20Abi, hexToString, zeroHash } from "viem";
+
+const rollup_server = process.env.ROLLUP_HTTP_SERVER_URL;
+console.log("HTTP rollup_server url is " + rollup_server);
+
+async function handle_advance(data) {
+  console.log("Received advance request data " + JSON.stringify(data));
+
+  const sender = data["metadata"]["msg_sender"];
+  const payload = hexToString(data.payload);
+  const erc20Token = "0x784f0c076CC55EAD0a585a9A13e57c467c91Dc3a"; // Sample ERC20 token address
+
+    const call = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [sender, BigInt(10)],
+  });
+
+  let voucher = {
+    destination: erc20Token,
+    payload: call,
+    value: zeroHash,
+  };
+
+  await emitVoucher(voucher);
+  return "accept";
+}
+
+const emitVoucher = async (voucher) => {
+  try {
+    await fetch(rollup_server + "/voucher", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(voucher),
+    });
+  } catch (error) {
+    //Do something when there is an error
+  }
+};
+```
+
 ### Withdrawing Ether
 
 To execute Ether withdrawal it is important to emit a voucher with the necessary details as regarding whom you intend to send the Ether to and also the amount to send, nevertheless since the Application contract Executes vouchers by making a [safeCall](https://github.com/cartesi/rollups-contracts/blob/cb52d00ededd2da9f8bf7757710301dccb7d536d/src/library/LibAddress.sol#L18C14-L18C22) to the destination, passing a value (Ether amount to send along with the call) and a payload (function signature to call), it's acceptable to leave the payload section empty if you do not intend to call any functions in the destination address while sending just the specified value of Ether to the destination address. If you intend to call a payable function and also send Ether along, you can add a function signature matching the payable function you intend to call to the payload field.
 
+Below is another sample JavaScript code, this time the voucher structure has been modified to send ether to an address instead of calling a function in a smart contract, notice there is no `encodedFunctionData`, so the payload section is initialized to zeroHash.
+
+```javascript
+import { stringToHex, encodeFunctionData, erc20Abi, hexToString, zeroHash, parseEther } from "viem";
+
+const rollup_server = process.env.ROLLUP_HTTP_SERVER_URL;
+console.log("HTTP rollup_server url is " + rollup_server);
+
+async function handle_advance(data) {
+  console.log("Received advance request data " + JSON.stringify(data));
+
+  const sender = data["metadata"]["msg_sender"];
+  const payload = hexToString(data.payload);
+
+
+  let voucher = {
+    destination: sender,
+    payload: zeroHash,
+    value: numberToHex(BigInt(parseEther("1"))).slice(2),
+  };
+
+  await emitVoucher(voucher);
+  return "accept";
+}
+
+const emitVoucher = async (voucher) => {
+  try {
+    await fetch(rollup_server + "/voucher", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(voucher),
+    });
+  } catch (error) {
+    //Do something when there is an error
+  }
+};
+```
+
 :::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.
 :::

cartesi-rollups_versioned_docs/version-2.0/development/building-and-running-an-application.md

@@ -35,6 +35,7 @@ Cartesi CLI has templates for the following languages – `cpp`, `cpp-low-level`
 :::note Libraries for simplifying development
 We have high-level framework and alternative templates that simplify development and enhances input management, providing a smoother and more efficient experience.
 For Go use Rollmelette, for Rust use Crabrolls, for Python use python-Cartesi and for Typescript/Javascrips use Deroll.
+Visit this [page](../resources/community-tools.md) to learn more about these and other available tools.
 :::
 
 ## Implementing your application Logic
@@ -61,7 +62,7 @@ Below is a sample application that has been modified to include the logic to sim
 
 ```javascript
 
-import { stringToHex, encodeFunctionData, erc20Abi, hexToString } from "viem";
+import { stringToHex, encodeFunctionData, erc20Abi, hexToString, zeroHash } from "viem";
 
 const rollup_server = process.env.ROLLUP_HTTP_SERVER_URL;
 console.log("HTTP rollup_server url is " + rollup_server);
@@ -85,7 +86,7 @@ async function handle_advance(data) {
   let voucher = {
     destination: erc20Token,
     payload: call,
-    value: '0x',
+    value: zeroHash,
   };
 
   await emitVoucher(voucher);

cartesi-rollups_versioned_docs/version-2.0/development/creating-an-application.md

@@ -6,86 +6,98 @@ resources:
     title: CartesiScan
 ---
 
-Running your application creates a docker container containing all required services, and exposes your application node on port `6751`, then an anvil network specific to your application on port `6751/anvil`. The node also logs all outputs received by your backend.
+Running an application locally mimics the process of deploying an application to production on a testnet or mainnet environment. When working locally, your application’s smart contracts are deployed to an Anvil network, which acts as a local Ethereum environment. The main difference is that your application node runs on your own machine using Docker, rather than on a remote server. Running an application involves two main phases: first, you build your application, and then you deploy it to your local development network (devnet). This process allows you to test and debug your application in an environment that closely resembles the real blockchain, making it easier to catch issues early and ensure a smooth deployment to production later.
 
-Here are the prerequisites to run the node:
+## Building the application
 
-- Docker Engine must be active.
-- Cartesi machine snapshot successfully built with `cartesi build`.
+“Building” in this context compiles your application into RISC-V architecture, this architecture enables computation done by your application to be reproducible and verifiable. While "Running" encompasses the process of publishing your application to your local node running on docker and also deploying the necessary contracts for your application to a local Anvil devnet.
 
-To start the node, run:
+With the Docker engine running, CD into your application and build by running:
 
 ```shell
-cartesi run
+cartesi build
 ```
 
-Response:
+The successful execution of this step will log this in your terminal:
 
 ```shell
-[+] Pulling 4/0
- ✔ proxy Skipped - Image is already present locally                                       0.0s 
- ✔ database Skipped - Image is already present locally                                    0.0s 
- ✔ rollups-node Skipped - Image is already present locally                                0.0s 
- ✔ anvil Skipped - Image is already present locally                                       0.0s 
-✔ demo-application starting at http://127.0.0.1:6751
-✔ anvil service ready at http://127.0.0.1:6751/anvil
-✔ rpc service ready at http://127.0.0.1:6751/rpc
-✔ inspect service ready at http://127.0.0.1:6751/inspect/demo-application
-✔ demo-application machine hash is 0xa3ca2e40420f3c2424ca95549b6c16fd9b11c27d76b8ef9ae9bf78cde36829fc
-✔ demo-application contract deployed at 0xa083af219355288722234c47d4c8469ca9af6605
-(l) View logs   (b) Build and redeploy  (q) Quit
-```
-
-This command runs your backend compiled to RISC-V and packages it as a Cartesi machine. It is therefore important that after every code update, the application needs to be rebuilt then the run command executed again, the Cartesi CLI makes this process very easy and all you need do is hit the `<b>` button on your keyboard to trigger a rebuild and run command.
-
-:::troubleshoot troubleshooting common errors
-
-#### Error: Depth Too High
 
-```shell
-Attaching to 2bd74695-prompt-1, 2bd74695-validator-1
-2bd74695-validator-1  | Error: DepthTooHigh { depth: 2, latest: 1 }
-2bd74695-validator-1  | Error: DepthTooHigh { depth: 2, latest: 1 }
+         .
+        / \
+      /    \
+\---/---\  /----\
+ \       X       \
+  \----/  \---/---\
+       \    / CARTESI
+        \ /   MACHINE
+         '
+
+[INFO  rollup_http_server] starting http dispatcher service...
+[INFO  rollup_http_server::http_service] starting http dispatcher http service!
+[INFO  actix_server::builder] starting 1 workers
+[INFO  actix_server::server] Actix runtime found; starting in Actix runtime
+[INFO  rollup_http_server::dapp_process] starting dapp: dapp
+Sending finish
+
+Manual yield rx-accepted (1) (0x000020 data)
+Cycles: 69709199
+69709199: 9e0420c0fda1a5dc9256b3f9783b09f207e5222a88429e91629cc2e495282b35
+Storing machine: please wait
 ```
 
-This indicates that the node is reading blocks too far behind the current blockchain state.
+### Memory
 
-#### Solution
+To change the default memory size for the Cartesi Machine, you can personalize it by adding a specific label in your Dockerfile.
 
-Create or modify a `.cartesi.env` file in your project directory and set:
+The line below lets you define the memory size in megabytes (MB):
 
-```shell
-TX_DEFAULT_CONFIRMATIONS=1
+```dockerfile
+LABEL io.cartesi.rollups.ram_size=128Mi
 ```
 
-This adjustment should align the node's block reading with the blockchain's current state.
-
+:::note environment variables
+You can create a `.cartesi.env` in the project's root and override any variable controlling the rollups-node.
 :::
 
-### Overview of Node Services
+## Deploying the application to devnet
 
-The `cartesi run` command activates several services essential for node operation: some of these services are not activated by default and can be activated by adding them to the `--service` flag when starting your application. The below command starts your application with all available services:
+Running the deployment command compiles your application and publishes it to the node running in the devnet environment. It also deploys the required authority and application contracts to the local Anvil network.
 
-```shell
-cartesi run --services explorer,graphql,bundler,paymaster,passkey
-```
+You can deploy multiple applications to this environment. For each application, you can either create a new authority contract or link it to an existing one.
 
-Each of these services runs independently and can be activated or deactivated at will by simply including or removing them from the list of services while running your application. Below is a breakdown of these services and their default URL's.
+Prerequisites for Deployment
+Before deploying your application, ensure the following:
 
-- **Anvil Chain**: Runs a local blockchain available at `http://localhost:6751/anvil`.
+- Docker Engine is active.
+- The Devnet environment is running.
+- A Cartesi machine snapshot has been successfully built using `cartesi build`.
 
-- **GraphQL Playground**: An interactive IDE at `http://localhost:6751/graphql` for exploring the GraphQL server.
+Once these prerequisites are met, proceed to deploy your application by running:
 
-- **Explorer**: Monitors Rollups application activity and manages transactions via `http://localhost:6751/explorer`.
+```shell
+cartesi deploy
+```
 
-- **Inspect**: A diagnostic tool accessible at `http://localhost:6751/inspect/<app_name>` to inspect the node’s state.
+This command compiles your backend to RISC-V, packages it as a Cartesi machine, then publishes it to the node running on the devnet.
 
-- **Bundler**: A server accessible at `http://localhost:6751/bundler/rpc` to enable account abstraction by providing an alternative mempool for receiving and bundling user operations.
+During deployment, you'll have to specify:
 
-- **Paymaster**: An account abstraction implementation that works hand in hand with the bundler to sponsor gas fees for transactions handled by the bundler, available at `http://localhost:6751/paymaster`.
+- Private key or Mnemonic to fund the deployment.
+- The authority owner address.
+- The application owner address.
+- An application name (making it easier to identify your application instead of relying on the contract address).
 
-- **Passkey**: Runs a local passkey server, that enables account generation and interaction with application without a traditional wallet, available at `http://localhost:6751/passkey`
+Once the deployment is complete, you should have logs similar to the following:
 
-:::note Testing tools
-[NoNodo](https://github.com/Calindra/nonodo) is a Cartesi Rollups testing tool that works with host machine applications, eliminating the need for Docker or RISC-V compilation.
-:::
+```shell
+✔ Cartesi machine template hash 0x9e0420c0fda1a5dc9256b3f9783b09f207e5222a88429e91629cc2e495282b35
+✔ Wallet Mnemonic
+✔ Mnemonic test test test test test test test test test test test junk
+✔ Account 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 9994.000195973381758124 ETH
+✔ Authority Owner 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
+✔ Application Owner 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
+✔ Application 0x1Db6DdECF18095847f7099cfAc43A2671326d21c
+✔ Machine snapshot /var/lib/cartesi-rollups-node/snapshots/0x9e0420c0fda1a5dc9256b3f9783b09f207e5222a88429e91629cc2e495282b35/
+✔ Application Name counter
+✔ Registration counter
+```