@tangle-network/starter-foundry 0.5.3 → 0.7.0

package/registry/families/risczero-zkvm/files/Cargo.toml

@@ -0,0 +1,23 @@
+[workspace]
+resolver = "2"
+members = ["host", "methods"]
+exclude = ["methods/guest"]  # guest is built by risc0-build, not as a workspace member
+
+[workspace.package]
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[workspace.dependencies]
+risc0-zkvm = "2.1"
+serde = { version = "1", features = ["derive"] }
+bincode = "1.3"
+
+[profile.release]
+lto = true
+codegen-units = 1
+
+# Release-mode optimizations that keep proof generation fast without
+# blowing up binary size.
+[profile.dev]
+opt-level = 0

package/registry/families/risczero-zkvm/files/README.md

@@ -0,0 +1,66 @@
+# RISC Zero zkVM starter
+
+General-purpose Rust zkVM. Prove arbitrary Rust programs; optionally
+delegate to the Bonsai proving network for fast cloud proofs.
+
+## Layout
+
+```
+Cargo.toml                 # workspace root, resolver="2", members = [host, methods]
+rust-toolchain.toml        # pinned stable
+host/
+  Cargo.toml               # std Rust — runs prover + verifier
+  src/main.rs              # entry point
+  src/prover.rs            # prove() / verify() wrappers
+methods/
+  Cargo.toml               # build-dep: risc0-build
+  build.rs                 # embeds compiled guest into methods crate
+  src/lib.rs               # auto-generated GUEST_ELF + GUEST_ID exports
+  guest/
+    Cargo.toml             # guest is NOT a workspace member
+    src/main.rs            # runs IN the zkVM — pure compute
+```
+
+## Run
+
+```bash
+# First install the risc0 toolchain (one-time).
+curl -L https://risczero.com/install | bash
+rzup install
+
+# Build + prove + verify locally (slow — minutes).
+cargo run --release
+
+# For fast cloud proofs, set Bonsai env vars:
+export BONSAI_API_URL=https://api.bonsai.xyz/
+export BONSAI_API_KEY=<your key>
+cargo run --release
+```
+
+## Replacing the example circuit
+
+1. Edit `methods/guest/src/main.rs` — change `Input`/`Output` and replace
+   the addition logic with what you want proven.
+2. Mirror the struct changes in `host/src/prover.rs` so the host can
+   serialize/deserialize inputs and outputs.
+3. Rebuild: `cargo run --release` — the risc0-build build.rs
+   auto-recompiles the guest when it changes.
+
+## On-chain verification
+
+For EVM: use RISC Zero's Groth16 verifier + wrap the STARK receipt.
+See [risc0-ethereum](https://github.com/risc0/risc0-ethereum) for the
+Solidity verifier + R0 Steel examples of reading Ethereum state inside
+a proof.
+
+## Gotchas
+
+- **Guest std is constrained** — no net, no fs, no SystemTime, limited
+  float. If your compute needs those, you're using the wrong zkVM (or
+  you need to pre-compute outside and pass results in via `env::read`).
+- **Proof sizes are hundreds of KB**. Never bundle into a JSON response.
+  Store the receipt in S3/IPFS, pass a reference.
+- **BONSAI_API_KEY is a prover credential**. Belongs in secret storage,
+  not source control.
+- **Image ID changes on every guest recompile**. Don't hardcode — always
+  use `methods::GUEST_ID` so verify stays in sync.

package/registry/families/risczero-zkvm/files/host/main.rs

@@ -0,0 +1,25 @@
+// RISC Zero host entry point. Invokes the guest, pulls the receipt, and
+// verifies it end-to-end. Run with `cargo run --release`.
+//
+// For local proving (default): uses your CPU. Slow — seconds-to-minutes
+// depending on cycle count.
+// For Bonsai cloud proving: set BONSAI_API_URL + BONSAI_API_KEY; the
+// default_prover() call auto-delegates.
+
+mod prover;
+
+use anyhow::Result;
+
+fn main() -> Result<()> {
+    let input = prover::Input { a: 3, b: 4 };
+    let (output, receipt_bytes) = prover::prove(input)?;
+    println!("Proved: {} + {} = {}, product = {}", 3, 4, output.sum, output.product);
+    println!("Receipt: {} bytes", receipt_bytes.len());
+
+    // Round-trip: deserialize and re-verify. In production, this is what
+    // your verifier service does on receipt submission.
+    let reverified = prover::verify(&receipt_bytes)?;
+    assert_eq!(output.sum, reverified.sum);
+    println!("Re-verified receipt ✓");
+    Ok(())
+}

package/registry/families/risczero-zkvm/files/host/prover.rs

@@ -0,0 +1,48 @@
+// Prover wrapper — invokes the guest ELF via default_prover(), extracts the
+// committed output from the receipt journal, returns both the output and a
+// serialized receipt ready for transport or on-chain verification.
+
+use anyhow::{Context, Result};
+use methods::{GUEST_ELF, GUEST_ID};
+use risc0_zkvm::{default_prover, ExecutorEnv};
+use serde::{Deserialize, Serialize};
+
+// Must match the guest's Input/Output shape — keep in sync.
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Input {
+    pub a: u64,
+    pub b: u64,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Output {
+    pub sum: u64,
+    pub product: u64,
+}
+
+pub fn prove(input: Input) -> Result<(Output, Vec<u8>)> {
+    let env = ExecutorEnv::builder()
+        .write(&input)
+        .context("write input")?
+        .build()
+        .context("build env")?;
+
+    // default_prover() picks local CPU prover or Bonsai based on env vars:
+    //   BONSAI_API_URL + BONSAI_API_KEY → remote (fast)
+    //   (unset) → local (slow, dev-only)
+    let prover = default_prover();
+    let prove_info = prover.prove(env, GUEST_ELF).context("prove")?;
+    let receipt = prove_info.receipt;
+
+    let output: Output = receipt.journal.decode().context("decode journal")?;
+    let receipt_bytes = bincode::serialize(&receipt).context("serialize receipt")?;
+
+    Ok((output, receipt_bytes))
+}
+
+pub fn verify(receipt_bytes: &[u8]) -> Result<Output> {
+    let receipt: risc0_zkvm::Receipt = bincode::deserialize(receipt_bytes).context("deserialize")?;
+    receipt.verify(GUEST_ID).context("verify receipt")?;
+    let output: Output = receipt.journal.decode().context("decode journal")?;
+    Ok(output)
+}

package/registry/families/risczero-zkvm/files/host-Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "host"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[[bin]]
+name = "host"
+path = "src/main.rs"
+
+[dependencies]
+risc0-zkvm = { workspace = true }
+methods = { path = "../methods" }
+serde = { workspace = true }
+bincode = { workspace = true }
+anyhow = "1"

package/registry/families/risczero-zkvm/files/methods/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "methods"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[build-dependencies]
+risc0-build = "2.1"
+
+[package.metadata.risc0]
+methods = ["guest"]

package/registry/families/risczero-zkvm/files/methods/build.rs

@@ -0,0 +1,6 @@
+// Build script — embeds the compiled guest ELF into the methods crate as
+// `GUEST_ELF` + `GUEST_ID` constants. Host imports both.
+
+fn main() {
+    risc0_build::embed_methods();
+}

package/registry/families/risczero-zkvm/files/methods/guest/main.rs

@@ -0,0 +1,38 @@
+// Guest program — runs INSIDE the RISC Zero zkVM on a RISC-V target.
+// No std::net, no std::fs, no std::time::SystemTime, limited float.
+// Pure compute + serde + crypto + hashing.
+
+#![no_main]
+
+use risc0_zkvm::guest::env;
+use serde::{Deserialize, Serialize};
+
+risc0_zkvm::guest::entry!(main);
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Input {
+    pub a: u64,
+    pub b: u64,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Output {
+    pub sum: u64,
+    pub product: u64,
+}
+
+pub fn main() {
+    let input: Input = env::read();
+
+    // Your provable logic goes here. Replace this with a hash check, a
+    // signature verification, a state-transition validator, or whatever
+    // your protocol needs proven.
+    let output = Output {
+        sum: input.a.saturating_add(input.b),
+        product: input.a.saturating_mul(input.b),
+    };
+
+    // Committed values land in the receipt's journal — publicly verifiable
+    // alongside the proof.
+    env::commit(&output);
+}

package/registry/families/risczero-zkvm/files/methods/guest-Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "guest"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "guest"
+path = "src/main.rs"
+
+[dependencies]
+risc0-zkvm = { version = "2.1", default-features = false, features = ["std"] }
+serde = { version = "1", features = ["derive"] }

package/registry/families/risczero-zkvm/files/methods/src-lib.rs

@@ -0,0 +1,3 @@
+// Auto-generated by risc0-build at compile time — embeds the guest ELF +
+// image ID. Imports go `use methods::{GUEST_ELF, GUEST_ID};`.
+include!(concat!(env!("OUT_DIR"), "/methods.rs"));

package/registry/families/risczero-zkvm/files/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+components = ["rustfmt", "clippy"]

package/registry/families/risczero-zkvm/files/validate-risczero.mjs

@@ -0,0 +1,41 @@
+import fs from "node:fs/promises";
+
+const required = [
+  "Cargo.toml",
+  "methods/Cargo.toml",
+  "methods/build.rs",
+  "methods/src/lib.rs",
+  "methods/guest/Cargo.toml",
+  "methods/guest/src/main.rs",
+  "host/Cargo.toml",
+  "host/src/main.rs",
+  "host/src/prover.rs",
+];
+
+for (const path of required) {
+  try {
+    await fs.access(path);
+  } catch {
+    throw new Error(`risczero-zkvm scaffold missing required file: ${path}`);
+  }
+}
+
+const workspace = await fs.readFile("Cargo.toml", "utf8");
+if (!workspace.includes("[workspace]")) {
+  throw new Error("Cargo.toml missing [workspace] table");
+}
+if (!workspace.includes('resolver = "2"')) {
+  throw new Error('Cargo.toml missing resolver = "2"');
+}
+
+const guestCargo = await fs.readFile("methods/guest/Cargo.toml", "utf8");
+if (!guestCargo.includes("risc0-zkvm")) {
+  throw new Error("methods/guest/Cargo.toml missing risc0-zkvm dep");
+}
+
+const hostCargo = await fs.readFile("host/Cargo.toml", "utf8");
+if (!hostCargo.includes("risc0-zkvm") || !hostCargo.includes("methods")) {
+  throw new Error("host/Cargo.toml missing risc0-zkvm or methods dep");
+}
+
+console.log("risczero-zkvm starter ok");

package/registry/families/risczero-zkvm/manifest.json

@@ -0,0 +1,109 @@
+{
+  "id": "risczero-zkvm",
+  "description": "RISC Zero zkVM workspace — general-purpose Rust zkVM with host + guest split. Prove arbitrary Rust programs, optionally via the Bonsai proving network. Pairs with EVM smart contracts through R0 Steel for reading on-chain state inside proofs.",
+  "tags": [
+    "zk",
+    "zkvm",
+    "rust",
+    "risc-zero",
+    "risczero",
+    "bonsai",
+    "r0-steel",
+    "proofs"
+  ],
+  "taxonomy": {
+    "language": "rust",
+    "runtime": "native",
+    "surface": "zkvm"
+  },
+  "slots": {},
+  "defaults": {
+    "projectType": "zkvm",
+    "guestName": "guest"
+  },
+  "files": [
+    {
+      "source": "files/Cargo.toml",
+      "target": "Cargo.toml"
+    },
+    {
+      "source": "files/rust-toolchain.toml",
+      "target": "rust-toolchain.toml"
+    },
+    {
+      "source": "files/host-Cargo.toml",
+      "target": "host/Cargo.toml"
+    },
+    {
+      "source": "files/host/main.rs",
+      "target": "host/src/main.rs"
+    },
+    {
+      "source": "files/host/prover.rs",
+      "target": "host/src/prover.rs"
+    },
+    {
+      "source": "files/methods/Cargo.toml",
+      "target": "methods/Cargo.toml"
+    },
+    {
+      "source": "files/methods/build.rs",
+      "target": "methods/build.rs"
+    },
+    {
+      "source": "files/methods/src-lib.rs",
+      "target": "methods/src/lib.rs"
+    },
+    {
+      "source": "files/methods/guest-Cargo.toml",
+      "target": "methods/guest/Cargo.toml"
+    },
+    {
+      "source": "files/methods/guest/main.rs",
+      "target": "methods/guest/src/main.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/validate-risczero.mjs",
+      "target": "validate-risczero.mjs"
+    }
+  ],
+  "tieredKeywords": {
+    "tier1": [
+      "risc zero",
+      "risc0",
+      "risczero",
+      "r0 steel",
+      "zkr0"
+    ],
+    "tier2": [
+      "bonsai",
+      "bonsai prover",
+      "bonsai proving",
+      "risc zero prover",
+      "risc zero zkvm",
+      "risc zero coprocessor",
+      "risc zero rollup",
+      "r0 steel evm"
+    ],
+    "archetypes": [
+      "prove rust programs with risc zero",
+      "risc zero coprocessor for ethereum",
+      "bonsai-powered zk service",
+      "r0 steel evm state proof",
+      "risc zero rollup",
+      "zkvm for rust programs"
+    ]
+  },
+  "validationChecks": [
+    { "type": "file-exists", "path": "Cargo.toml" },
+    { "type": "file-exists", "path": "methods/Cargo.toml" },
+    { "type": "file-exists", "path": "methods/guest/Cargo.toml" },
+    { "type": "file-exists", "path": "methods/guest/src/main.rs" },
+    { "type": "file-exists", "path": "host/Cargo.toml" },
+    { "type": "file-exists", "path": "host/src/main.rs" }
+  ]
+}

package/registry/families/ros2-node-py/files/README-ros2.md

@@ -0,0 +1,46 @@
+# {{serviceName}} — ROS2 rclpy node
+
+Minimal ROS2 Python package with a publisher + subscriber demo, wired to a
+colcon-buildable package layout. Targets Jazzy Jalisco (Ubuntu 24.04) with
+Humble Hawksbill (Ubuntu 22.04) back-compat.
+
+## Quickstart
+
+Source your ROS2 distro first (e.g. `source /opt/ros/jazzy/setup.bash`).
+
+```sh
+# Drop this package into a colcon workspace:
+mkdir -p ~/ros2_ws/src
+cp -r . ~/ros2_ws/src/{{packageName}}
+cd ~/ros2_ws
+rosdep install --from-paths src --ignore-src -r -y
+colcon build --packages-select {{packageName}}
+source install/setup.bash
+
+# Launch publisher + subscriber:
+ros2 launch {{packageName}} bringup.launch.py
+```
+
+## Nodes
+
+| Node | Topic | Direction | Msg type |
+|---|---|---|---|
+| `minimal_publisher` | `/cmd_vel` | publishes | `geometry_msgs/Twist` |
+| `minimal_subscriber` | `/odom` | subscribes | `nav_msgs/Odometry` |
+
+Publishing cadence: 2 Hz. Adjust the `create_timer` interval in
+`{{packageName}}/minimal_publisher.py` for real drive loops (≥20 Hz typical).
+
+## Gotchas
+
+- **DDS domain ID**: if multiple ROS2 processes collide on the same network,
+  set `ROS_DOMAIN_ID=<0-232>` so each project gets an isolated graph.
+- **Overlay sourcing**: always `source install/setup.bash` _after_ `colcon build`
+  in a fresh shell. Forgetting this is the #1 "why can't ros2 run find my
+  package" error.
+- **Message type mismatch**: `geometry_msgs/Twist` vs `geometry_msgs/msg/Twist`
+  — the Python import path is `from geometry_msgs.msg import Twist`; the
+  YAML `msg/` segment matters for cli tools + launch files.
+- **Launch file discovery**: `ros2 launch {{packageName}} bringup.launch.py`
+  requires the launch file to ship via `setup.py`'s `data_files` — verify
+  `launch/bringup.launch.py` is listed.

package/registry/families/ros2-node-py/files/package.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>{{packageName}}</name>
+  <version>0.1.0</version>
+  <description>{{packageName}} — ROS 2 Python node starter (minimal publisher + subscriber + launch).</description>
+  <maintainer email="dev@example.com">starter-foundry</maintainer>
+  <license>Apache-2.0</license>
+
+  <buildtool_depend>ament_python</buildtool_depend>
+
+  <depend>rclpy</depend>
+  <depend>std_msgs</depend>
+  <depend>geometry_msgs</depend>
+  <depend>sensor_msgs</depend>
+  <depend>nav_msgs</depend>
+  <depend>nav2_msgs</depend>
+  <depend>tf2_ros</depend>
+
+  <test_depend>ament_copyright</test_depend>
+  <test_depend>ament_flake8</test_depend>
+  <test_depend>ament_pep257</test_depend>
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

package/registry/families/ros2-node-py/files/resource-marker

@@ -0,0 +1 @@
+

package/registry/families/ros2-node-py/files/setup.cfg

@@ -0,0 +1,5 @@
+[develop]
+script_dir=$base/lib/{{packageName}}
+
+[install]
+install_scripts=$base/lib/{{packageName}}

package/registry/families/ros2-node-py/files/setup.py

@@ -0,0 +1,32 @@
+from setuptools import find_packages, setup
+
+package_name = "{{packageName}}"
+
+setup(
+    name=package_name,
+    version="0.1.0",
+    packages=find_packages(exclude=["test"]),
+    data_files=[
+        # ament index registration — required for `ros2 pkg list` to find this package.
+        ("share/ament_index/resource_index/packages", ["resource/" + package_name]),
+        # package.xml must be installed so rosdep / rcl can read it.
+        ("share/" + package_name, ["package.xml"]),
+        # Launch files — installed under share/<pkg>/launch so `ros2 launch <pkg> ...` works.
+        ("share/" + package_name + "/launch", ["launch/bringup.launch.py"]),
+    ],
+    install_requires=["setuptools"],
+    zip_safe=True,
+    maintainer="starter-foundry",
+    maintainer_email="dev@example.com",
+    description="{{packageName}} — minimal ROS 2 Python node (cmd_vel publisher + /odom subscriber).",
+    license="Apache-2.0",
+    tests_require=["pytest"],
+    entry_points={
+        "console_scripts": [
+            # ros2 run {{packageName}} publisher
+            "publisher = {{packageName}}.minimal_publisher:main",
+            # ros2 run {{packageName}} subscriber
+            "subscriber = {{packageName}}.minimal_subscriber:main",
+        ],
+    },
+)

package/registry/families/ros2-node-py/files/validate-ros2-py.mjs

@@ -0,0 +1,96 @@
+import fs from "node:fs/promises";
+
+// Hermetic validator — asserts the scaffold shape WITHOUT invoking colcon,
+// rosdep, ament, or any ROS 2 binary. Consumers of this starter run
+// colcon build themselves after sourcing /opt/ros/<distro>/setup.bash.
+
+const [pkgXml, setupPy, setupCfg, pubSrc, subSrc, launchFile] = await Promise.all([
+  fs.readFile("package.xml", "utf8"),
+  fs.readFile("setup.py", "utf8"),
+  fs.readFile("setup.cfg", "utf8"),
+  fs.readFile("{{packageName}}/minimal_publisher.py", "utf8"),
+  fs.readFile("{{packageName}}/minimal_subscriber.py", "utf8"),
+  fs.readFile("launch/bringup.launch.py", "utf8"),
+]);
+
+// package.xml must declare ament_python + the rclpy/geometry/nav deps that
+// match the source code's imports. If any are missing, `rosdep install`
+// will fail on a fresh clone.
+if (!pkgXml.includes("<build_type>ament_python</build_type>")) {
+  throw new Error("package.xml missing ament_python build_type export");
+}
+for (const dep of ["rclpy", "std_msgs", "geometry_msgs", "sensor_msgs", "nav2_msgs"]) {
+  if (!pkgXml.includes(`<depend>${dep}</depend>`)) {
+    throw new Error(`package.xml missing <depend>${dep}</depend>`);
+  }
+}
+
+// setup.py — entry_points are the ONLY path `ros2 run <pkg> <script>` uses
+// for ament_python packages. Missing entry_points => silent no-op.
+if (!setupPy.includes("entry_points")) {
+  throw new Error("setup.py missing entry_points block");
+}
+if (!setupPy.includes("console_scripts")) {
+  throw new Error("setup.py entry_points missing console_scripts");
+}
+if (!setupPy.includes("minimal_publisher:main") || !setupPy.includes("minimal_subscriber:main")) {
+  throw new Error("setup.py console_scripts missing publisher/subscriber entry points");
+}
+if (!setupPy.includes("resource/")) {
+  throw new Error("setup.py missing resource index registration in data_files");
+}
+if (!setupPy.includes("share/" + '"') && !setupPy.includes("share/\" + package_name")) {
+  // Tolerate either templating style; just require the share/<pkg> path.
+  if (!setupPy.includes("/launch")) {
+    throw new Error("setup.py missing launch data_files install path");
+  }
+}
+
+// setup.cfg — develop/install must point script_dir at lib/<pkg> so
+// console_scripts land where ros2 run expects them.
+if (!setupCfg.includes("script_dir") || !setupCfg.includes("install_scripts")) {
+  throw new Error("setup.cfg missing script_dir / install_scripts overrides");
+}
+
+// minimal_publisher — must subclass rclpy.node.Node, construct a
+// geometry_msgs/Twist publisher on /cmd_vel, and run a timer loop.
+if (!pubSrc.includes("import rclpy")) {
+  throw new Error("minimal_publisher.py does not import rclpy");
+}
+if (!pubSrc.includes("from rclpy.node import Node") && !pubSrc.includes("rclpy.node.Node")) {
+  throw new Error("minimal_publisher.py does not import rclpy.node.Node");
+}
+if (!pubSrc.includes("Twist")) {
+  throw new Error("minimal_publisher.py does not publish geometry_msgs/Twist");
+}
+if (!pubSrc.includes("create_publisher") || !pubSrc.includes("create_timer")) {
+  throw new Error("minimal_publisher.py missing create_publisher / create_timer calls");
+}
+if (!pubSrc.includes("rclpy.init") || !pubSrc.includes("rclpy.spin") || !pubSrc.includes("rclpy.shutdown")) {
+  throw new Error("minimal_publisher.py missing rclpy lifecycle (init/spin/shutdown)");
+}
+
+// minimal_subscriber — must subscribe to /odom with nav_msgs/Odometry.
+if (!subSrc.includes("import rclpy")) {
+  throw new Error("minimal_subscriber.py does not import rclpy");
+}
+if (!subSrc.includes("Odometry")) {
+  throw new Error("minimal_subscriber.py does not subscribe to nav_msgs/Odometry");
+}
+if (!subSrc.includes("create_subscription")) {
+  throw new Error("minimal_subscriber.py missing create_subscription call");
+}
+
+// launch file — must be valid Python launch description. Required by
+// `ros2 launch <pkg> bringup.launch.py`.
+if (!launchFile.includes("LaunchDescription")) {
+  throw new Error("launch/bringup.launch.py does not define a LaunchDescription");
+}
+if (!launchFile.includes("Node(")) {
+  throw new Error("launch/bringup.launch.py does not instantiate any launch_ros.actions.Node");
+}
+if (!launchFile.includes("generate_launch_description")) {
+  throw new Error("launch/bringup.launch.py missing generate_launch_description() entrypoint");
+}
+
+console.log("ros2 python node ok");