+
+```rust
+use json::{object, JsonValue};
+use std::env;
+
+pub async fn handle_advance(
+ _client: &hyper::Client,
+ _server_addr: &str,
+ request: JsonValue,
+) -> Result<&'static str, Box> {
+ 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,
+ _server_addr: &str,
+ request: JsonValue,
+) -> Result<&'static str, Box> {
+ 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> {
+ 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.clone()};
+ 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"
+ }
+ };
+ }
+ }
+}
+```
+
+
```javascript
-async function handle_advance(data) {
- console.log("Received advance request data " + JSON.stringify(data));
-
- const inputPayload = data["payload"];
+import { stringToHex, hexToString } from "viem";
+const emitNotice = async (inputPayload) => {
+ let hexPayload = stringToHex(inputPayload); // convert payload from string to hex
try {
await fetch(rollup_server + "/notice", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
- body: JSON.stringify({ payload: inputPayload }),
+ body: JSON.stringify({ payload: hexPayload }),
});
} catch (error) {
//Do something when there is an error
}
+}
+async function handle_advance(data) {
+ console.log("Received advance request data " + JSON.stringify(data));
+ const payload = hexToString(data.payload); // convert input from hex to string for processing
+ await emitNotice(payload);
return "accept";
}
+
```
```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:
- # Emits 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")
```
+
+```python
+# Voucher creation process
+import requests
+import json
+from os import environ
+from eth_utils import function_signature_to_4byte_selector
+from eth_abi import decode, encode
+
+rollup_server = environ["ROLLUP_HTTP_SERVER_URL"]
+
+def emit_voucher(function_signature, destination, types, values):
+ selector = function_signature_to_4byte_selector(function_signature)
+ encoded_params = encode(types, values)
+ payload = "0x" + (selector + encoded_params).hex()
+ response = requests.post(rollup_server + "/voucher", json={"payload": payload, "destination": destination, "value": '0x' + encode(["uint256"], [0]).hex()})
+ if response.status_code == 200 or response.status_code == 201:
+ logger.info(f"Voucher emitted successfully with data: {payload}")
+ else:
+ logger.error(f"Failed to emit Voucher with data: {payload}. Status code: {response.status_code}")
+
+
+emit_voucher("mint(address)", "0x784f0c076CC55EAD0a585a9A13e57c467c91Dc3a", ["address"], [data["metadata"]["msg_sender"]])
+```
+
+
+
+```javascript
+import { stringToHex, encodeFunctionData, erc20Abi } from "viem";
+
+async function handle_advance(data) {
+ console.log("Received advance request data " + JSON.stringify(data));
+ const sender = data["metadata"]["msg_sender"];
+ 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: '0x',
+ };
+
+ 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
+ }
+};
+
+```
+
+