Add Counter and Marketplace Tutorials in 3 major languages

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

@@ -81,6 +81,76 @@ def handle_advance(data):
 </code></pre>
 </TabItem>
 
+<TabItem value="Rust" label="Rust" default>
+<pre><code>
+
+```rust
+fn hex_to_string(hex: &str) -> Result<String, Box<dyn std::error::Error>> {
+    let hexstr = hex.strip_prefix("0x").unwrap_or(hex);
+    let bytes = hex::decode(hexstr).map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
+    let s = String::from_utf8(bytes).map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
+    Ok(s)
+}
+
+pub async fn handle_advance(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received advance request data {}", &request);
+    let payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+
+    let payload_string = hex_to_string(payload);
+
+    match payload_string {
+      Ok(payload_extract) => {
+        // DO SOMETHING HERE!!
+      }
+      Err(e) => {
+        throw_execption(e.to_string()).await;
+      }
+    }
+    Ok("accept")
+}
+
+async fn throw_execption( payload: String) -> Option<bool> {
+    let hex_string = {
+        let s = payload.strip_prefix("0x").unwrap_or(payload.as_str());
+        hex::encode(s.as_bytes())
+    };
+
+    let server_addr = env::var("ROLLUP_HTTP_SERVER_URL").expect("ROLLUP_HTTP_SERVER_URL not set");
+    let client = hyper::Client::new();
+
+    let response = object! {
+        "payload" => format!("0x{}", hex_string),
+    };
+    let request = hyper::Request::builder()
+    .method(hyper::Method::POST)
+    .header(hyper::header::CONTENT_TYPE, "application/json")
+    .uri(format!("{}/exception", server_addr))
+    .body(hyper::Body::from(response.dump()))
+    .ok()?;
+
+    let response = client.request(request).await;
+    match response {
+        Ok(_) => {
+            println!("Exception generation successful");
+            return Some(true);
+        }
+        Err(e) => {
+            println!("Exception request failed {}", e);
+            None
+        }
+    }
+}
+```
+
+</code></pre>
+</TabItem>
+
 </Tabs>
 
 ## Notes

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

@@ -129,6 +129,82 @@ while True:
 </code></pre>
 </TabItem>
 
+<TabItem value="Rust" label="Rust" default>
+<pre><code>
+
+```rust
+use json::{object, JsonValue};
+use std::env;
+
+pub async fn handle_advance(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received advance request data {}", &request);
+    let _payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+    // TODO: add application logic here
+    Ok("accept")
+}
+
+pub async fn handle_inspect(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received inspect request data {}", &request);
+    let _payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+    // TODO: add application logic here
+    Ok("accept")
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = hyper::Client::new();
+    let server_addr = env::var("ROLLUP_HTTP_SERVER_URL")?;
+
+    let mut status = "accept";
+    loop {
+        println!("Sending finish");
+        let response = object! {"status" => status};
+        let request = hyper::Request::builder()
+            .method(hyper::Method::POST)
+            .header(hyper::header::CONTENT_TYPE, "application/json")
+            .uri(format!("{}/finish", &server_addr))
+            .body(hyper::Body::from(response.dump()))?;
+        let response = client.request(request).await?;
+        println!("Received finish status {}", response.status());
+
+        if response.status() == hyper::StatusCode::ACCEPTED {
+            println!("No pending rollup request, trying again");
+        } else {
+            let body = hyper::body::to_bytes(response).await?;
+            let utf = std::str::from_utf8(&body)?;
+            let req = json::parse(utf)?;
+
+            let request_type = req["request_type"]
+                .as_str()
+                .ok_or("request_type is not a string")?;
+            status = match request_type {
+                "advance_state" => handle_advance(&client, &server_addr[..], req).await?,
+                "inspect_state" => handle_inspect(&client, &server_addr[..], req).await?,
+                &_ => {
+                    eprintln!("Unknown request type");
+                    "reject"
+                }
+            };
+        }
+    }
+}
+```
+
+</code></pre>
+</TabItem>
+
 </Tabs>
 
 ## Notes

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

@@ -213,7 +213,7 @@ An **Inspect** request involves making an external HTTP API call to the rollups
 
 You can make a simple inspect call from your frontend client to retrieve reports.
 
-To perform an Inspect call, send an HTTP POST request to `<address of the node>/inspect/<application name>` with a payload in the request body. For example:
+To perform an Inspect call, make a HTTP POST request to `<address of the node>/inspect/<application name>` with a payload in the request body. For example:
 
 ```shell
 curl -X POST http://localhost:8080/inspect/<application name> \

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

@@ -77,6 +77,55 @@ def handle_advance(data):
 </code></pre>
 </TabItem>
 
+<TabItem value="Rust" label="Rust" default>
+<pre><code>
+
+```rust
+pub async fn handle_advance(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received advance request data {}", &request);
+    let payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+
+
+    emit_notice(payload).await;
+    Ok("accept")
+}
+
+async fn emit_notice(payload: String) -> Option<bool> {
+    let server_addr = env::var("ROLLUP_HTTP_SERVER_URL").expect("ROLLUP_HTTP_SERVER_URL not set");
+    let client = hyper::Client::new();
+
+    let response = object! {
+        "payload" => payload,
+    };
+    let request = hyper::Request::builder()
+    .method(hyper::Method::POST)
+    .header(hyper::header::CONTENT_TYPE, "application/json")
+    .uri(format!("{}/notice", server_addr))
+    .body(hyper::Body::from(response.dump()))
+    .ok()?;
+
+    let response = client.request(request).await;
+    match response {
+        Ok(_) => {
+            println!("Notice generation successful");
+            return Some(true);
+        }
+        Err(e) => {
+            println!("Notice request failed {}", e);
+            None
+        }
+    }
+}
+```
+
+</code></pre>
+</TabItem>
 </Tabs>
 
 :::note querying notices

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

@@ -75,6 +75,50 @@ def handle_advance(data):
 </code></pre>
 </TabItem>
 
+<TabItem value="Rust" label="Rust" default>
+<pre><code>
+
+```rust
+pub async fn handle_advance(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received advance request data {}", &request);
+    let payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+
+    let server_addr = env::var("ROLLUP_HTTP_SERVER_URL").expect("ROLLUP_HTTP_SERVER_URL not set");
+    let client = hyper::Client::new();
+
+    let response = object! {
+        "payload" => payload,
+    };
+    let request = hyper::Request::builder()
+    .method(hyper::Method::POST)
+    .header(hyper::header::CONTENT_TYPE, "application/json")
+    .uri(format!("{}/report", server_addr))
+    .body(hyper::Body::from(response.dump()))
+    .ok()?;
+
+    let response = client.request(request).await;
+    match response {
+        Ok(_) => {
+            println!("Report generation successful");
+            Ok("accept")
+        }
+        Err(e) => {
+            println!("Report request failed {}", e);
+            Err("Report request failed {}")
+        }
+    }
+}
+```
+
+</code></pre>
+</TabItem>
+
 </Tabs>
 
 :::note querying reports

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

@@ -98,6 +98,97 @@ emit_voucher("mint(address)", "0x784f0c076CC55EAD0a585a9A13e57c467c91Dc3a", ["ad
 
 </code></pre>
 </TabItem>
+
+<TabItem value="Rust" label="Rust">
+<pre><code>
+
+```rust
+async fn emit_voucher( voucher: JsonValue) -> Option<bool> {
+    let server_addr = env::var("ROLLUP_HTTP_SERVER_URL").expect("ROLLUP_HTTP_SERVER_URL not set");
+    let client = hyper::Client::new();
+
+    let request = hyper::Request::builder()
+    .method(hyper::Method::POST)
+    .header(hyper::header::CONTENT_TYPE, "application/json")
+    .uri(format!("{}/voucher", server_addr))
+    .body(hyper::Body::from(voucher.dump()))
+    .ok()?;
+
+    let response = client.request(request).await;
+
+    match response {
+        Ok(_) => {
+            println!("Voucher generation successful");
+            return Some(true);
+        }
+        Err(e) => {
+            println!("Voucher request failed {}", e);
+            None
+        }
+    }
+}
+
+fn structure_voucher(
+    function_signature: &str,
+    destination: &str,
+    args: Vec<Token>,
+    value: u128,
+) -> JsonValue {
+    let selector = &id(function_signature)[..4];
+
+    let encoded_args = encode(&args);
+
+    let mut payload_bytes = Vec::new();
+    payload_bytes.extend_from_slice(selector);
+    payload_bytes.extend_from_slice(&encoded_args);
+
+    let payload = format!("0x{}", hex::encode(payload_bytes));
+
+    let response = object! {
+        "destination" => format!("{}", destination),
+        "payload" => format!("{}", payload),
+        "value" => format!("0x{}", hex::encode(value.to_be_bytes())),
+    };
+
+    return response;
+}
+
+pub async fn handle_advance(
+    _client: &hyper::Client<hyper::client::HttpConnector>,
+    _server_addr: &str,
+    request: JsonValue,
+) -> Result<&'static str, Box<dyn std::error::Error>> {
+    println!("Received advance request data {}", &request);
+    let payload = request["data"]["payload"]
+        .as_str()
+        .ok_or("Missing payload")?;
+
+    let sender = request["data"]["metadata"]["msg_sender"]
+        .as_str()
+        .ok_or("Missing msg_sender in metadata")?
+        .to_string();
+
+    let erc_20_token: &str = "0x784f0c076CC55EAD0a585a9A13e57c467c91Dc3a"; // Sample ERC20 token address
+
+    let amount = 10;
+
+    let args = vec![
+        Token::Address(sender.parse().unwrap()),
+        Token::Uint(amount.into()),
+    ];
+    let function_sig = "transfer(address,uint256)";
+
+    let voucher = structure_voucher(function_sig, erc_20_token, args, 0);
+    emit_voucher(voucher).await;
+
+    Ok("accept")
+}
+
+```
+
+</code></pre>
+</TabItem>
+
 </Tabs>
 
 :::note create a voucher