@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/families/agent-swarm-ts/files/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/server.ts",
+    "start": "tsx src/server.ts",
+    "test": "vitest run",
+    "validate": "node validate-swarm.mjs"
+  },
+  "dependencies": {
+    "@langchain/core": "^0.3.0",
+    "@langchain/langgraph": "^0.2.0",
+    "@langchain/openai": "^0.3.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.9.0",
+    "vitest": "^2.1.0"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/agent-swarm-ts/files/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowJs": true,
+    "lib": ["ESNext"]
+  },
+  "include": ["src/**/*.ts", "validate-swarm.mjs"]
+}

package/registry/families/agent-swarm-ts/files/validate-swarm.mjs

@@ -0,0 +1,28 @@
+import fs from "node:fs/promises";
+
+const [supervisor, researcher, writer, pkgSource] = await Promise.all([
+  fs.readFile("src/supervisor.ts", "utf8"),
+  fs.readFile("src/agents/researcher.ts", "utf8"),
+  fs.readFile("src/agents/writer.ts", "utf8"),
+  fs.readFile("package.json", "utf8"),
+]);
+
+const pkg = JSON.parse(pkgSource);
+if (pkg.name !== "{{packageName}}") {
+  throw new Error(`package.json name should be "{{packageName}}", got "${pkg.name}"`);
+}
+if (!pkg.dependencies?.["@langchain/langgraph"]) {
+  throw new Error("package.json missing @langchain/langgraph — swarm needs the orchestrator");
+}
+
+if (!supervisor.includes("StateGraph") && !supervisor.includes("createSupervisor")) {
+  throw new Error("src/supervisor.ts missing LangGraph StateGraph or createSupervisor call");
+}
+if (!researcher.includes("export")) {
+  throw new Error("src/agents/researcher.ts must export the researcher agent");
+}
+if (!writer.includes("export")) {
+  throw new Error("src/agents/writer.ts must export the writer agent");
+}
+
+console.log("agent-swarm-ts starter ok");

package/registry/families/agent-swarm-ts/manifest.json

@@ -0,0 +1,174 @@
+{
+  "id": "agent-swarm-ts",
+  "description": "Multi-agent swarm family \u2014 supervisor/worker orchestration with shared state, tool-routing, and handoff protocols. Based on LangGraph state machines or CrewAI role-based crews. For products where one LLM call isn't enough: research assistants that delegate to search/code/analysis sub-agents, customer support with triage + specialist agents, document pipelines with extract/analyze/summarize roles.",
+  "tags": [
+    "agent",
+    "multi-agent",
+    "swarm",
+    "langgraph",
+    "crewai",
+    "supervisor",
+    "typescript"
+  ],
+  "taxonomy": {
+    "language": "typescript",
+    "runtime": "node",
+    "surface": "api"
+  },
+  "slots": {
+    "database": {
+      "options": [
+        "database:sqlite",
+        "database:postgres",
+        "database:mongodb",
+        "database:convex"
+      ],
+      "default": "database:postgres"
+    },
+    "auth": {
+      "options": [
+        "auth:none",
+        "auth:better-auth",
+        "auth:clerk"
+      ],
+      "default": "auth:none"
+    }
+  },
+  "defaults": {
+    "projectType": "multi-agent",
+    "serviceName": "starter-foundry-swarm",
+    "port": 8098,
+    "orchestrator": "langgraph"
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/tsconfig.json",
+      "target": "tsconfig.json"
+    },
+    {
+      "source": "files/validate-swarm.mjs",
+      "target": "validate-swarm.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src/supervisor.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/agents/researcher.ts"
+    },
+    {
+      "type": "file-exists",
+      "path": "src/agents/writer.ts"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-swarm.mjs"
+      ],
+      "expect": "agent-swarm-ts starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "pnpm run dev",
+      "pnpm test"
+    ],
+    "entrypoints": [
+      "src/supervisor.ts",
+      "src/agents/",
+      "src/state.ts",
+      "package.json"
+    ],
+    "preview": {
+      "path": "/health"
+    },
+    "extensionPoints": [
+      "src/agents/",
+      "src/state.ts",
+      "src/tools/"
+    ]
+  },
+  "keywords": [
+    "multi-agent",
+    "multi agent",
+    "agent swarm",
+    "supervisor agent",
+    "langgraph-js",
+    "langgraphjs",
+    "typescript multi-agent",
+    "agent handoff",
+    "specialist agents",
+    "agent team",
+    "role-based agents"
+  ],
+  "scoring": {
+    "boost": {
+      "langgraph-js": 3
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "multi-agent",
+      "multi agent",
+      "agent swarm",
+      "langgraph-js",
+      "langgraphjs",
+      "typescript multi-agent"
+    ],
+    "tier2": [
+      "supervisor agent",
+      "agent handoff",
+      "specialist agents",
+      "agent team"
+    ],
+    "archetypes": [
+      "research assistant with sub-agents",
+      "triage and specialist support",
+      "document pipeline agents",
+      "planner and executor agents"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Multi-agent orchestration with supervisor/worker handoffs. Use when ONE LLM call isn't enough \u2014 research agents that delegate to search/analyze/summarize roles, triage+specialist support, document pipelines. For a single agent with tool use, use `agent-service-ts` instead.",
+    "firstSteps": [
+      "Set the router API key: `export OPENAI_API_KEY=$TANGLE_ROUTER_KEY` \u2014 agents call via router.tangle.tools, NOT OpenAI directly.",
+      "Add a new specialist: create `src/agents/<name>.ts` exporting a `run<Name>(state)` function. Register it in supervisor.ts's node graph.",
+      "Extend `SwarmState` in src/state.ts when adding fields the new agent reads/writes. Use the Annotation<T>({ reducer }) pattern \u2014 reducers determine how updates merge.",
+      "The supervisor is rule-based (src/supervisor.ts). Swap to an LLM-driven supervisor by replacing `supervise()` with an LLM call if the routing is non-obvious.",
+      "Test end-to-end: `curl -X POST http://localhost:{{port}}/run -d '{\"task\": \"your task\"}'` \u2014 kicks off researcher \u2192 writer."
+    ],
+    "gotchas": [
+      "LangGraph's Annotation reducers fire on EVERY state update. Accidentally returning {messages: state.messages} duplicates history. Return only the FIELDS you're changing.",
+      "The `END` marker terminates the graph. The supervisor must set `nextAgent: \"END\"` when work is done \u2014 otherwise the graph loops forever.",
+      "ChatOpenAI needs `configuration.baseURL` set to router.tangle.tools \u2014 without it calls go to api.openai.com and fail/cost unexpectedly.",
+      "Shared state = tight coupling. If a new agent needs a field that no other agent reads, DON'T put it in SwarmState \u2014 use private module-scope instead."
+    ],
+    "architectureNotes": [
+      "StateGraph flow: START \u2192 supervisor \u2192 (researcher | writer | END). Each specialist edges back to supervisor, enabling re-routing.",
+      "LangGraph checkpointing (MemorySaver, SqliteSaver) lets you pause/resume sessions. Enable via `graph.compile({ checkpointer })` for long-running workflows."
+    ],
+    "placeholders": [
+      {
+        "path": "src/agents/researcher.ts",
+        "description": "Placeholder researcher agent returning generic bullet notes. Replace system prompt + tool surface for the product's actual research domain."
+      },
+      {
+        "path": "src/agents/writer.ts",
+        "description": "Placeholder writer converting notes to prose. Replace system prompt for the product's target voice/format."
+      },
+      {
+        "path": "src/supervisor.ts",
+        "description": "Rule-based supervisor (has-notes? \u2192 writer; else \u2192 researcher). Replace with product-specific routing or an LLM-driven supervisor for non-linear flows."
+      }
+    ]
+  }
+}

package/registry/families/angular-ts/files/package.json

@@ -12,5 +12,13 @@
   "devDependencies": {
     "@angular/cli": "^19.0.0",
     "@angular/compiler-cli": "^19.0.0"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
   }
 }

package/registry/families/aptos-move/files/README.md

@@ -0,0 +1,45 @@
+# {{projectName}}
+
+Aptos Move package. This is the **Aptos** dialect of Move (resource-based, `aptos_framework::` imports, named addresses) — not Sui Move.
+
+## Prerequisites
+
+Install the Aptos CLI: https://aptos.dev/tools/aptos-cli/install-cli/
+
+```bash
+brew install aptos   # macOS
+# or: curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
+```
+
+## Commands
+
+```bash
+# Compile (type-checks + builds bytecode)
+aptos move compile --named-addresses {{projectName}}=default
+
+# Run Move unit tests
+aptos move test --named-addresses {{projectName}}=default
+
+# Publish to devnet (after `aptos init --network devnet`)
+aptos move publish --named-addresses {{projectName}}=default
+
+# Call an entry function on-chain
+aptos move run \
+  --function-id default::{{moduleName}}::initialize \
+  --named-addresses {{projectName}}=default
+```
+
+## Structure
+
+- `Move.toml` — package manifest, pins AptosFramework rev
+- `sources/{{moduleName}}.move` — the module (resources, entry funs, views)
+- `tests/{{moduleName}}Tests.move` — Move unit tests with `#[test]`
+
+## Differences from Sui Move
+
+If you're coming from Sui, the mental model is different:
+
+- **Ownership**: Aptos stores resources under account addresses via `move_to` / `borrow_global`. Sui uses object-centric `transfer::transfer` / `object::new`.
+- **Imports**: Aptos uses `aptos_framework::account`, `aptos_framework::coin`, etc. Sui uses `sui::object`, `sui::tx_context`.
+- **Init**: Aptos modules don't have a Sui-style `init` function that runs on publish. Use a `public entry fun initialize(account: &signer)` that a deployer calls once.
+- **Tests**: Aptos test annotation is `#[test(account = @addr)]`. Sui is `#[test]` + manual `test_scenario` setup.

package/registry/families/aptos-move/files/validate-aptos.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+
+const [manifestSource, moduleSource, testSource] = await Promise.all([
+  fs.readFile("Move.toml", "utf8"),
+  fs.readFile("sources/{{moduleName}}.move", "utf8"),
+  fs.readFile("tests/{{moduleName}}Tests.move", "utf8")
+]);
+
+if (!manifestSource.includes('name = "{{projectName}}"')) {
+  throw new Error("Move.toml missing expected package name");
+}
+
+if (!manifestSource.includes("AptosFramework")) {
+  throw new Error("Move.toml missing AptosFramework dependency (this is the Aptos Move dialect, not Sui)");
+}
+
+if (!moduleSource.includes("module {{projectName}}::{{moduleName}}")) {
+  throw new Error("Move module path mismatch");
+}
+
+if (!moduleSource.includes("aptos_framework::")) {
+  throw new Error("Module missing aptos_framework:: import — did you scaffold a Sui Move module by mistake?");
+}
+
+if (!moduleSource.includes("public entry fun")) {
+  throw new Error("Move module missing public entry function");
+}
+
+if (!/#\[test/.test(testSource)) {
+  throw new Error("Move tests missing #[test] attribute");
+}
+
+console.log("aptos move starter ok");

package/registry/families/aptos-move/manifest.json

@@ -0,0 +1,106 @@
+{
+  "id": "aptos-move",
+  "description": "Aptos Move contract starter — Move.toml with aptos-framework dep, resource + entry function module, Move unit tests.",
+  "tags": [
+    "aptos",
+    "move",
+    "contracts",
+    "crypto"
+  ],
+  "taxonomy": {
+    "language": "move",
+    "runtime": "aptos",
+    "surface": "contracts"
+  },
+  "defaults": {
+    "projectType": "contracts",
+    "moduleName": "HelloAptos",
+    "aptosFrameworkRev": "mainnet"
+  },
+  "files": [
+    {
+      "source": "files/validate-aptos.mjs",
+      "target": "validate-aptos.mjs"
+    },
+    {
+      "source": "files/.gitignore",
+      "target": ".gitignore"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "Move.toml"
+    },
+    {
+      "type": "file-exists",
+      "path": "sources/{{moduleName}}.move"
+    },
+    {
+      "type": "file-exists",
+      "path": "tests/{{moduleName}}Tests.move"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-aptos.mjs"
+      ],
+      "expect": "aptos move starter ok"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "aptos move compile",
+      "aptos move test",
+      "aptos move publish --named-addresses {{projectName}}=default"
+    ],
+    "entrypoints": [
+      "Move.toml",
+      "sources/{{moduleName}}.move",
+      "tests/{{moduleName}}Tests.move"
+    ],
+    "preview": null,
+    "extensionPoints": [
+      "sources/{{moduleName}}.move",
+      "tests/{{moduleName}}Tests.move"
+    ]
+  },
+  "keywords": [
+    "aptos",
+    "aptos move",
+    "aptos framework",
+    "move module aptos",
+    "aptos contract",
+    "aptos dapp",
+    "aptos token",
+    "aptos coin",
+    "aptos nft"
+  ],
+  "scoring": {
+    "boost": {
+      "aptos": 4
+    }
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "aptos",
+      "aptos move",
+      "aptos framework",
+      "aptos contract",
+      "aptos dapp",
+      "move module aptos"
+    ],
+    "tier2": [
+      "aptos token",
+      "aptos coin",
+      "aptos nft",
+      "aptos staking",
+      "aptos defi"
+    ]
+  }
+}

package/registry/families/arkworks-prover/files/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "arkworks-prover"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[[bin]]
+name = "arkworks-prover"
+path = "src/main.rs"
+
+[dependencies]
+ark-ff = "0.5"
+ark-ec = "0.5"
+ark-bn254 = "0.5"
+ark-relations = "0.5"
+ark-r1cs-std = "0.5"
+ark-groth16 = "0.5"
+ark-snark = "0.5"
+ark-std = { version = "0.5", features = ["std"] }
+ark-serialize = "0.5"
+anyhow = "1"
+
+[profile.release]
+lto = true
+codegen-units = 1

package/registry/families/arkworks-prover/files/README.md

@@ -0,0 +1,77 @@
+# Arkworks prover starter
+
+Rust primitive layer for ZK. Hand-rolled R1CS constraints, explicit curve +
+proof system choice. The layer UNDERNEATH Noir / SP1 / RISC Zero — use
+when those are too coarse (research, novel curves, bespoke proof systems).
+
+## When not to use this
+
+| Goal | Use |
+|---|---|
+| Prove a small-to-medium thing | [zk-noir](../../layers/capability/zk-noir) |
+| Prove arbitrary Rust | [risczero-zkvm](../risczero-zkvm) or [sp1-zkvm](../sp1-zkvm) |
+| Go-native prover service | [zk-gnark](../../layers/capability/zk-gnark) |
+| Learn ZK for the first time | anything except arkworks |
+
+## Layout
+
+```
+Cargo.toml                # binary crate with ark-* deps pinned to 0.5
+rust-toolchain.toml       # pinned stable
+src/
+  main.rs                 # setup → prove → verify happy-path demo
+  circuit.rs              # ConstraintSynthesizer impl — your circuit logic
+  prover.rs               # Groth16 wrappers over BN254
+```
+
+## Run
+
+```bash
+cargo run --release
+# Setup complete — pk/vk generated (dev only)
+# Proved knowledge of (3, 4) such that sum == 7
+# Verified ✓
+# Rejected tampered public input ✓
+```
+
+## Constraint discipline
+
+- **Every Var** — private via `FpVar::new_witness`, public via
+  `FpVar::new_input`. Bare `Fr` values can't combine with Vars directly.
+- **Every relation is an enforce_* call**. `let sum = &a + &b;` creates
+  an intermediate Var but adds NO constraint. `sum.enforce_equal(&expected)?;`
+  is what actually binds the prover.
+- **Conditional logic** via `Boolean::select(&cond, &if_true, &if_false)`.
+  No Rust pattern-matching in circuit; every branch evaluates.
+- **Hashing** via `ark-crypto-primitives` (Poseidon, Pedersen) or
+  `ark-sponge`.
+
+## Trusted setup
+
+`dev_setup` is fine for tests + local dev. For production:
+
+1. Run a ceremony (Perpetual Powers of Tau for Groth16).
+2. Serialize pk/vk via ark-serialize `CanonicalSerialize::serialize_compressed`.
+3. Load at runtime from disk/IPFS. Never regenerate in production paths.
+
+## Swap the proof system
+
+This starter uses ark-groth16. To switch:
+
+- **Marlin**: `cargo add ark-marlin` — universal trusted setup, no
+  per-circuit ceremony.
+- **Plonk**: `cargo add ark-plonk` — universal SRS, EVM-friendly.
+- **Nova**: `cargo add ark-nova` — folding scheme, transparent
+  (no trusted setup), unique for incrementally-verifiable computation.
+
+Each rewires the prove/verify calls but the circuit stays the same.
+
+## Gotchas
+
+- **Field overflow** — BN254 scalars are ~254 bits. u64 values are always
+  safe; big-int / packed bytes need explicit reduction.
+- **API drift** — ark-* minor bumps (0.4 → 0.5) reliably break. Pin exact
+  versions in Cargo.toml and commit Cargo.lock.
+- **Forgetting enforce_equal** — circuit builds, proof generates, verifier
+  accepts anything. Look for any intermediate Var that's never consumed by
+  an enforce_*.

package/registry/families/arkworks-prover/files/rust-toolchain.toml

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

package/registry/families/arkworks-prover/files/src/circuit.rs

@@ -0,0 +1,39 @@
+//! Arkworks circuit — implements `ConstraintSynthesizer`. Every relation
+//! the prover must satisfy is added via calls on the constraint-system
+//! handle (`cs`). Bare Rust expressions DO NOT constrain — if the only
+//! line mentioning your variable is `let x = &a + &b;`, no constraint
+//! exists. You must follow with `x.enforce_equal(...)` or similar.
+
+use ark_ff::PrimeField;
+use ark_r1cs_std::{alloc::AllocVar, eq::EqGadget, fields::fp::FpVar};
+use ark_relations::r1cs::{ConstraintSynthesizer, ConstraintSystemRef, SynthesisError};
+
+/// Proves knowledge of (a, b) such that a + b == expected_sum.
+/// - `a`, `b`: private witnesses (prover knows, verifier does not)
+/// - `expected_sum`: public input (verifier supplies at verify time)
+pub struct SumCircuit<F: PrimeField> {
+    pub a: Option<F>,
+    pub b: Option<F>,
+    pub expected_sum: Option<F>,
+}
+
+impl<F: PrimeField> ConstraintSynthesizer<F> for SumCircuit<F> {
+    fn generate_constraints(self, cs: ConstraintSystemRef<F>) -> Result<(), SynthesisError> {
+        let a_var = FpVar::new_witness(cs.clone(), || {
+            self.a.ok_or(SynthesisError::AssignmentMissing)
+        })?;
+        let b_var = FpVar::new_witness(cs.clone(), || {
+            self.b.ok_or(SynthesisError::AssignmentMissing)
+        })?;
+        let expected_var = FpVar::new_input(cs, || {
+            self.expected_sum.ok_or(SynthesisError::AssignmentMissing)
+        })?;
+
+        // enforce_equal is what binds the prover. Without this call the
+        // proof would be trivial and useless.
+        let sum_var = &a_var + &b_var;
+        sum_var.enforce_equal(&expected_var)?;
+
+        Ok(())
+    }
+}

package/registry/families/arkworks-prover/files/src/main.rs

@@ -0,0 +1,31 @@
+//! Arkworks prover — dev example. Runs setup + prove + verify end-to-end
+//! with a trivial sum-circuit. Replace the circuit module with your
+//! application-specific constraints.
+
+mod circuit;
+mod prover;
+
+use anyhow::Result;
+
+fn main() -> Result<()> {
+    // Dev setup. DO NOT use this in production — it generates fresh
+    // trusted-setup parameters in-process, which exposes the toxic
+    // waste to whatever process runs it. Real deployments load pk/vk
+    // from a ceremony (Powers of Tau) or use a universal-setup system.
+    let artifacts = prover::dev_setup()?;
+    println!("Setup complete — pk/vk generated (dev only)");
+
+    let proof = prover::prove(&artifacts.pk, 3, 4, 7)?;
+    println!("Proved knowledge of (3, 4) such that sum == 7");
+
+    let ok = prover::verify(&artifacts.pvk, &proof, 7)?;
+    assert!(ok, "honest proof should verify");
+    println!("Verified ✓");
+
+    // Tamper check — pass a wrong public input.
+    let tampered = prover::verify(&artifacts.pvk, &proof, 8)?;
+    assert!(!tampered, "wrong public input must be rejected");
+    println!("Rejected tampered public input ✓");
+
+    Ok(())
+}

package/registry/families/arkworks-prover/files/src/prover.rs

@@ -0,0 +1,47 @@
+//! Groth16 prover over BN254. Setup → Prove → Verify flow.
+//!
+//! `dev_setup` runs a per-circuit trusted setup in-process. FINE for dev
+//! and tests; NOT OK for production (reveals toxic waste to the process).
+//! Production loads pk/vk from ceremony artifacts or uses a universal-
+//! setup system (Marlin, Plonk via ark-plonk).
+
+use anyhow::Result;
+use ark_bn254::{Bn254, Fr};
+use ark_groth16::{Groth16, PreparedVerifyingKey, Proof, ProvingKey, VerifyingKey};
+use ark_snark::SNARK;
+use ark_std::rand::rngs::OsRng;
+
+use crate::circuit::SumCircuit;
+
+pub struct SetupArtifacts {
+    pub pk: ProvingKey<Bn254>,
+    pub vk: VerifyingKey<Bn254>,
+    pub pvk: PreparedVerifyingKey<Bn254>,
+}
+
+pub fn dev_setup() -> Result<SetupArtifacts> {
+    let mut rng = OsRng;
+    let empty = SumCircuit::<Fr> { a: None, b: None, expected_sum: None };
+    let (pk, vk) = Groth16::<Bn254>::circuit_specific_setup(empty, &mut rng)?;
+    let pvk = Groth16::<Bn254>::process_vk(&vk)?;
+    Ok(SetupArtifacts { pk, vk, pvk })
+}
+
+pub fn prove(pk: &ProvingKey<Bn254>, a: u64, b: u64, expected_sum: u64) -> Result<Proof<Bn254>> {
+    let mut rng = OsRng;
+    let circuit = SumCircuit::<Fr> {
+        a: Some(Fr::from(a)),
+        b: Some(Fr::from(b)),
+        expected_sum: Some(Fr::from(expected_sum)),
+    };
+    Ok(Groth16::<Bn254>::prove(pk, circuit, &mut rng)?)
+}
+
+pub fn verify(
+    pvk: &PreparedVerifyingKey<Bn254>,
+    proof: &Proof<Bn254>,
+    expected_sum: u64,
+) -> Result<bool> {
+    let public_inputs = vec![Fr::from(expected_sum)];
+    Ok(Groth16::<Bn254>::verify_with_processed_vk(pvk, &public_inputs, proof)?)
+}