@tangle-network/starter-foundry 0.5.4 → 0.7.0

package/registry/layers/capability/zk-gnark/manifest.json

@@ -0,0 +1,63 @@
+{
+  "id": "zk-gnark",
+  "description": "ConsenSys gnark — Go-native ZK framework. Supports Groth16, Plonk (with/without KZG), and custom constraints. Best fit when the backend is Go (services, indexers, aggregators) and you want circuits + prover in the same binary. Use when prompt names gnark / ConsenSys gnark / wants a Go-based ZK service.",
+  "appliesTo": [
+    "go-api",
+    "go-worker"
+  ],
+  "files": [
+    {
+      "source": "files/circuit.go",
+      "target": "circuit.go"
+    },
+    {
+      "source": "files/prover.go",
+      "target": "prover.go"
+    },
+    {
+      "source": "files/gnark-notes.md",
+      "target": "docs/gnark-notes.md"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {}
+  },
+  "keywords": [
+    "gnark",
+    "consensys gnark",
+    "gnark circuit",
+    "groth16 gnark",
+    "plonk gnark"
+  ],
+  "capabilityRequires": [],
+  "buildHints": {
+    "whenToUse": "Attach on Go backends (go-api, go-worker) that need to generate or verify ZK proofs server-side. Strongest fit for ZK-rollup sequencers, on-chain-proof aggregators, and systems where the prover is infra rather than a user-facing component.",
+    "firstSteps": [
+      "go get github.com/consensys/gnark@v0.13.0 github.com/consensys/gnark-crypto@v0.14.0",
+      "go mod tidy",
+      "Define circuit as a struct implementing frontend.Circuit (Define method)",
+      "Compile + setup: `r1cs, _ := frontend.Compile(...)`, `pk, vk, _ := groth16.Setup(r1cs)`",
+      "Prove: `proof, _ := groth16.Prove(r1cs, pk, witness)`",
+      "Verify: `groth16.Verify(proof, vk, publicWitness)` — returns nil on success"
+    ],
+    "gotchas": [
+      "Witness struct fields match circuit struct fields by NAME, not order. Renaming in one but not the other → silent witness-mismatch.",
+      "`api.AssertIsEqual` is the assertion primitive — not Go's `!=`. Using bare comparisons doesn't constrain.",
+      "Groth16 needs per-circuit trusted setup. For production, load pk/vk from files you generated with a ceremony; only regenerate for dev."
+    ]
+  },
+  "tieredKeywords": {
+    "archetypes": [
+      "gnark",
+      "consensys gnark",
+      "gnark circuit",
+      "groth16 gnark",
+      "plonk gnark",
+      "gnark prover in go",
+      "consensys gnark circuit",
+      "gnark groth16 service",
+      "zk rollup sequencer in go",
+      "go-native zk proof"
+    ]
+  }
+}

package/registry/layers/capability/zk-noir/files/circuits/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "circuit"
+type = "bin"
+authors = [""]
+compiler_version = ">=1.0.0"
+
+[dependencies]

package/registry/layers/capability/zk-noir/files/circuits/main.nr

@@ -0,0 +1,22 @@
+// Noir circuit. Compiles with `nargo compile` into target/circuit.json (ACIR bytecode).
+// Syntax is Rust-flavored but constrained — all values are field elements
+// under the curve's prime (BN254 by default). Loops must have bounded
+// iteration counts known at compile time.
+
+/// Proves that the prover knows two numbers (`a`, `b`) whose sum matches a
+/// publicly-committed expected value. Private inputs are unannotated; public
+/// inputs carry the `pub` marker.
+fn main(a: Field, b: Field, expected_sum: pub Field) {
+    let sum = a + b;
+    assert(sum == expected_sum);
+}
+
+#[test]
+fn test_main_happy_path() {
+    main(3, 4, 7);
+}
+
+#[test(should_fail)]
+fn test_main_wrong_sum_fails() {
+    main(3, 4, 8);
+}

package/registry/layers/capability/zk-noir/files/noir-notes.md

@@ -0,0 +1,72 @@
+# Aztec Noir
+
+Rust-syntax DSL for writing ZK circuits. Compiles to ACIR (the Aztec
+circuit IR); Barretenberg executes ACIR and produces UltraHonk / Groth16 /
+Plonk proofs. Best-of-class developer ergonomics for small-to-medium
+circuits.
+
+## Workspace shape
+
+```
+circuits/
+  Nargo.toml       # package metadata, compiler_version pin
+  src/main.nr      # circuit logic — pub inputs + private inputs
+  target/          # (gitignored) nargo-generated ACIR + proving keys
+src/lib/
+  noir-prover.ts   # TS wrapper: Noir + BarretenbergBackend
+```
+
+## Setup
+
+```bash
+# Install nargo (the Noir compiler + test runner)
+curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
+noirup
+# Compile
+cd circuits && nargo compile
+# Run in-circuit tests (#[test] and #[test(should_fail)] blocks)
+nargo test
+```
+
+The compile step writes `circuits/target/circuit.json`. TypeScript imports
+it as an ACIR JSON artifact and passes to `@noir-lang/noir_js`.
+
+## Key language constraints
+
+- **All values are Field elements** — mod BN254 prime (~2^254). Not ints.
+  Use `as u64` / `as i64` for integer typing sugar, but arithmetic is field.
+- **Loops must have known bounds**: `for i in 0..10 { ... }` — the `..10`
+  must be compile-time constant. For dynamic lengths, pass a max size and
+  loop to it with an active-count guard.
+- **No recursion, no heap**: all memory is stack. Arrays are fixed-size.
+- **`pub` marks public inputs** — private inputs are implicit. Only publics
+  appear in the proof's public-inputs vector.
+
+## Proof backends
+
+| Backend | When to use |
+|---|---|
+| UltraHonk (default) | Fastest modern proving, off-chain verification |
+| Groth16 | On-chain verification with tight proof size (~200 bytes) |
+| Plonk | Universal trusted setup, on-chain via Solidity verifier |
+
+Select via `backend.generateProof(witness, { backend: 'honk' \| 'plonk' \| 'groth16' })`
+(API shape depends on @noir-lang/backend-* version).
+
+## Common patterns
+
+- **Merkle inclusion proofs**: loop `for i in 0..DEPTH` hashing sibling up
+  to root; constrain `root == expected_root`.
+- **Signature verification**: Noir stdlib has `std::ecdsa_secp256k1::verify_signature`.
+- **Poseidon hashing**: `use dep::std::hash::poseidon;`
+- **Anonymous credentials**: prove knowledge of a secret that hashes to a
+  public commitment, without revealing the secret.
+
+## Gotchas
+
+- **Version pinning**: the @noir-lang/noir_js npm version must match the
+  nargo compiler version. Mismatch produces "unknown opcode" at runtime.
+- **WASM first-load**: Barretenberg ships as ~3-5MB WASM. Lazy-load behind
+  a user action; don't block page-mount.
+- **Proof size**: UltraHonk is kilobytes, not the compact hundreds-of-bytes
+  you'd get from Groth16. For on-chain, switch backends.

package/registry/layers/capability/zk-noir/files/prover.ts

@@ -0,0 +1,53 @@
+// Noir prover — Node or browser. Compiles the ACIR circuit (from
+// `nargo compile`) into a witness, then hands it to the Barretenberg
+// backend for proof generation and verification.
+//
+// For browser contexts, the Barretenberg WASM loads lazily — first proof
+// takes ~3-5 seconds for WASM init, subsequent ones are hundreds of ms.
+
+import { Noir } from '@noir-lang/noir_js'
+import { BarretenbergBackend } from '@noir-lang/backend_barretenberg'
+
+// circuit.json is produced by `nargo compile` under circuits/target/.
+// Vite / Next / Webpack all support JSON imports via resolve.json
+// extension handling.
+import circuit from '../../circuits/target/circuit.json' assert { type: 'json' }
+
+export interface ProveResult {
+  proof: Uint8Array
+  publicInputs: string[]
+}
+
+let singletonNoir: Noir | null = null
+let singletonBackend: BarretenbergBackend | null = null
+
+function getNoir(): { noir: Noir; backend: BarretenbergBackend } {
+  if (!singletonNoir || !singletonBackend) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    singletonBackend = new BarretenbergBackend(circuit as any)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    singletonNoir = new Noir(circuit as any, singletonBackend)
+  }
+  return { noir: singletonNoir, backend: singletonBackend }
+}
+
+export async function proveSumCommit(
+  a: string | number,
+  b: string | number,
+  expectedSum: string | number,
+): Promise<ProveResult> {
+  const { noir, backend } = getNoir()
+  await noir.init()
+  const { witness } = await noir.execute({
+    a: String(a),
+    b: String(b),
+    expected_sum: String(expectedSum),
+  })
+  const proof = await backend.generateProof(witness)
+  return { proof: proof.proof, publicInputs: proof.publicInputs }
+}
+
+export async function verifyProof(proof: Uint8Array, publicInputs: string[]): Promise<boolean> {
+  const { backend } = getNoir()
+  return backend.verifyProof({ proof, publicInputs })
+}

package/registry/layers/capability/zk-noir/manifest.json

@@ -0,0 +1,72 @@
+{
+  "id": "zk-noir",
+  "description": "Aztec Noir \u2014 high-level DSL for writing ZK circuits (Rust-like syntax, compiles to ACIR for Barretenberg backend). Supports UltraHonk (fast, modern), Groth16 (compact, on-chain), Plonk. Best DX of the Rust-family ZK frameworks for small-to-medium circuits. Use when prompt names Noir / Aztec / nargo / Barretenberg, or when you want high-level-DSL productivity over raw primitives.",
+  "appliesTo": [
+    "react-vite-ts",
+    "nextjs-ts",
+    "fullstack-ts",
+    "remix-ts"
+  ],
+  "files": [
+    {
+      "source": "files/circuits/main.nr",
+      "target": "circuits/src/main.nr"
+    },
+    {
+      "source": "files/circuits/Nargo.toml",
+      "target": "circuits/Nargo.toml"
+    },
+    {
+      "source": "files/prover.ts",
+      "target": "src/lib/noir-prover.ts"
+    },
+    {
+      "source": "files/noir-notes.md",
+      "target": "docs/noir-notes.md"
+    }
+  ],
+  "packageDeps": {
+    "dependencies": {
+      "@noir-lang/noir_js": "^1.0.0",
+      "@noir-lang/backend_barretenberg": "^1.0.0"
+    }
+  },
+  "keywords": [
+    "noir",
+    "aztec noir",
+    "barretenberg",
+    "nargo",
+    "ultrahonk",
+    "honk prover"
+  ],
+  "capabilityRequires": [],
+  "buildHints": {
+    "whenToUse": "Attach for products with small-to-medium ZK circuits where the DSL's ergonomics beat writing raw R1CS. Excellent for verifier-side browser/Node proving \u2014 bundle stays manageable because Barretenberg wasm is <5MB. For huge circuits where performance dominates, reach for SP1/RISC Zero instead.",
+    "firstSteps": [
+      "Install nargo: `curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash && noirup`",
+      "In circuits/: `nargo check` validates, `nargo compile` produces target/circuit.json (ACIR)",
+      "JS side: `import { Noir } from '@noir-lang/noir_js'; const noir = new Noir(circuit); await noir.execute(inputs)`",
+      "Proving: `import { BarretenbergBackend } from '@noir-lang/backend_barretenberg'`; `backend.generateProof()`"
+    ],
+    "gotchas": [
+      "Noir version pinning matters \u2014 the @noir-lang/noir_js version must match the nargo compiler you compiled with. Mismatches produce cryptic 'unknown opcode' errors.",
+      "Browser Barretenberg ships as WASM \u2014 first-load cost is ~3-5MB. Lazy-load behind a user-triggered action, not on page-mount.",
+      "Field arithmetic is mod BN254; large u64/u128 values need to stay under ~2^254."
+    ]
+  },
+  "tieredKeywords": {
+    "archetypes": [
+      "noir",
+      "aztec noir",
+      "barretenberg",
+      "nargo",
+      "ultrahonk",
+      "honk prover",
+      "aztec noir circuit",
+      "build a noir program",
+      "noir zk app",
+      "nargo new",
+      "ultrahonk verifier"
+    ]
+  }
+}

package/registry/layers/database/convex/manifest.json

@@ -3,21 +3,24 @@
   "slot": "database",
   "description": "Database profile for Convex-backed starters.",
   "appliesTo": [
+    "agent-service-py",
+    "agent-service-rust",
+    "agent-service-ts",
+    "agent-swarm-ts",
     "api-service",
-    "python-api",
-    "rust-service",
+    "bun-http",
     "cloudflare-worker-ts",
+    "deno-edge",
+    "dspy-pipeline-py",
+    "evm-infra-ts",
     "fullstack-ts",
     "go-api",
     "mcp-server-ts",
-    "dspy-pipeline-py",
-    "agent-service-ts",
-    "agent-service-py",
-    "agent-service-rust",
+    "python-api",
+    "python-worker",
+    "rust-service",
     "x402-service",
-    "zk-prover-service",
-    "evm-infra-ts",
-    "python-worker"
+    "zk-prover-service"
   ],
   "defaults": {
     "databaseProvider": "convex"

package/registry/layers/database/mongodb/manifest.json

@@ -3,21 +3,24 @@
   "slot": "database",
   "description": "Database profile for MongoDB-backed starters.",
   "appliesTo": [
+    "agent-service-py",
+    "agent-service-rust",
+    "agent-service-ts",
+    "agent-swarm-ts",
     "api-service",
-    "python-api",
-    "rust-service",
+    "bun-http",
     "cloudflare-worker-ts",
+    "deno-edge",
+    "dspy-pipeline-py",
+    "evm-infra-ts",
     "fullstack-ts",
     "go-api",
     "mcp-server-ts",
-    "dspy-pipeline-py",
-    "agent-service-ts",
-    "agent-service-py",
-    "agent-service-rust",
+    "python-api",
+    "python-worker",
+    "rust-service",
     "x402-service",
-    "zk-prover-service",
-    "evm-infra-ts",
-    "python-worker"
+    "zk-prover-service"
   ],
   "defaults": {
     "databaseProvider": "mongodb"

package/registry/layers/database/postgres/manifest.json

@@ -3,21 +3,30 @@
   "slot": "database",
   "description": "Database profile for PostgreSQL-backed starters.",
   "appliesTo": [
+    "agent-service-py",
+    "agent-service-rust",
+    "agent-service-ts",
+    "agent-swarm-ts",
     "api-service",
-    "python-api",
-    "rust-service",
+    "bun-http",
     "cloudflare-worker-ts",
+    "crm-backend",
+    "deno-edge",
+    "dspy-pipeline-py",
+    "ecommerce-headless",
+    "evm-infra-ts",
+    "fintech-ledger-backend",
     "fullstack-ts",
     "go-api",
+    "healthcare-hipaa-backend",
+    "k12-edtech",
+    "legal-case-mgmt",
     "mcp-server-ts",
-    "dspy-pipeline-py",
-    "agent-service-ts",
-    "agent-service-py",
-    "agent-service-rust",
+    "python-api",
+    "python-worker",
+    "rust-service",
     "x402-service",
-    "zk-prover-service",
-    "evm-infra-ts",
-    "python-worker"
+    "zk-prover-service"
   ],
   "defaults": {
     "databaseProvider": "postgres"

package/registry/layers/database/sqlite/manifest.json

@@ -3,21 +3,30 @@
   "slot": "database",
   "description": "Database profile for SQLite-backed starters.",
   "appliesTo": [
+    "agent-service-py",
+    "agent-service-rust",
+    "agent-service-ts",
+    "agent-swarm-ts",
     "api-service",
-    "python-api",
-    "rust-service",
+    "bun-http",
     "cloudflare-worker-ts",
+    "crm-backend",
+    "deno-edge",
+    "dspy-pipeline-py",
+    "ecommerce-headless",
+    "evm-infra-ts",
+    "fintech-ledger-backend",
     "fullstack-ts",
     "go-api",
+    "healthcare-hipaa-backend",
+    "k12-edtech",
+    "legal-case-mgmt",
     "mcp-server-ts",
-    "dspy-pipeline-py",
-    "agent-service-ts",
-    "agent-service-py",
-    "agent-service-rust",
+    "python-api",
+    "python-worker",
+    "rust-service",
     "x402-service",
-    "zk-prover-service",
-    "evm-infra-ts",
-    "python-worker"
+    "zk-prover-service"
   ],
   "defaults": {
     "databaseProvider": "sqlite"

package/registry/layers/framework/agent-swarm-ts/files/researcher.ts

@@ -0,0 +1,30 @@
+// Researcher agent — given a task, produces bullet-point notes. Swap the
+// tool surface (web search, vector store lookup, SQL query) for your domain.
+
+import { ChatOpenAI } from '@langchain/openai'
+import type { SwarmStateType } from '../state'
+
+const model = new ChatOpenAI({
+  model: process.env['LLM_MODEL'] ?? 'anthropic/claude-haiku-4-5',
+  configuration: {
+    baseURL: process.env['OPENAI_BASE_URL'] ?? 'https://router.tangle.tools',
+    apiKey: process.env['OPENAI_API_KEY'],
+  },
+})
+
+const SYSTEM = `You are the Researcher. Given a task, produce compact bullet-point notes covering:
+- Key facts
+- Relevant entities
+- Open questions
+Keep it under 200 words. You hand off to a Writer agent who'll turn your notes into prose.`
+
+export async function runResearcher(state: SwarmStateType): Promise<Partial<SwarmStateType>> {
+  const result = await model.invoke([
+    { role: 'system', content: SYSTEM },
+    { role: 'user', content: state.task },
+  ])
+  return {
+    notes: String(result.content),
+    messages: [{ role: 'assistant', content: String(result.content), agent: 'researcher' }],
+  }
+}

package/registry/layers/framework/agent-swarm-ts/files/server.ts

@@ -0,0 +1,35 @@
+// Minimal HTTP server that drives the swarm. POST /run with {task} to execute.
+
+import { createServer } from 'node:http'
+import { buildSwarm } from './supervisor'
+
+const swarm = buildSwarm()
+const port = Number(process.env['PORT'] ?? '{{port}}')
+
+const server = createServer(async (req, res) => {
+  if (req.method === 'GET' && req.url === '/health') {
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({ status: 'ok', service: '{{serviceName}}', orchestrator: 'langgraph' }))
+    return
+  }
+  if (req.method === 'POST' && req.url === '/run') {
+    const chunks: Buffer[] = []
+    for await (const chunk of req) chunks.push(chunk as Buffer)
+    const payload = JSON.parse(Buffer.concat(chunks).toString('utf8')) as { task?: string }
+    if (!payload.task) {
+      res.writeHead(400, { 'content-type': 'application/json' })
+      res.end(JSON.stringify({ error: 'task is required' }))
+      return
+    }
+    const final = await swarm.invoke({ task: payload.task, nextAgent: 'researcher' })
+    res.writeHead(200, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({ draft: final.draft, notes: final.notes, messages: final.messages }))
+    return
+  }
+  res.writeHead(404, { 'content-type': 'text/plain' })
+  res.end('not found')
+})
+
+server.listen(port, () => {
+  console.log(`{{serviceName}} listening on http://localhost:${port}`)
+})

package/registry/layers/framework/agent-swarm-ts/files/state.ts

@@ -0,0 +1,33 @@
+import { Annotation } from '@langchain/langgraph'
+
+// Shared state graph for the swarm. Each agent reads the messages history,
+// contributes its output, and optionally sets `nextAgent` to hand off.
+// Keep this interface small — too much shared state = tight coupling.
+
+export const SwarmState = Annotation.Root({
+  messages: Annotation<Array<{ role: 'user' | 'assistant' | 'system'; content: string; agent?: string }>>({
+    reducer: (prev, next) => [...prev, ...next],
+    default: () => [],
+  }),
+  task: Annotation<string>({
+    reducer: (_prev, next) => next,
+    default: () => '',
+  }),
+  /** Research notes collected by the researcher for the writer to consume. */
+  notes: Annotation<string>({
+    reducer: (prev, next) => (next ? `${prev}\n${next}` : prev),
+    default: () => '',
+  }),
+  /** Final output produced by the writer. */
+  draft: Annotation<string>({
+    reducer: (_prev, next) => next,
+    default: () => '',
+  }),
+  /** Supervisor-set routing — which agent runs next. 'END' terminates the graph. */
+  nextAgent: Annotation<'researcher' | 'writer' | 'END'>({
+    reducer: (_prev, next) => next,
+    default: () => 'researcher',
+  }),
+})
+
+export type SwarmStateType = typeof SwarmState.State

package/registry/layers/framework/agent-swarm-ts/files/supervisor.ts

@@ -0,0 +1,31 @@
+// Supervisor agent — decides which specialist runs next based on the state
+// graph's current fields. Swap the decision logic for an LLM call if you
+// want model-driven routing; this rule-based version is fast + deterministic
+// and gives you a working baseline.
+
+import { END, START, StateGraph } from '@langchain/langgraph'
+import { SwarmState, type SwarmStateType } from './state'
+import { runResearcher } from './agents/researcher'
+import { runWriter } from './agents/writer'
+
+function supervise(state: SwarmStateType): Partial<SwarmStateType> {
+  if (!state.notes) return { nextAgent: 'researcher' }
+  if (!state.draft) return { nextAgent: 'writer' }
+  return { nextAgent: 'END' }
+}
+
+export function buildSwarm() {
+  const graph = new StateGraph(SwarmState)
+    .addNode('supervisor', async (s) => supervise(s))
+    .addNode('researcher', async (s) => runResearcher(s))
+    .addNode('writer', async (s) => runWriter(s))
+    .addEdge(START, 'supervisor')
+    .addConditionalEdges('supervisor', (s) => s.nextAgent, {
+      researcher: 'researcher',
+      writer: 'writer',
+      END,
+    })
+    .addEdge('researcher', 'supervisor')
+    .addEdge('writer', 'supervisor')
+  return graph.compile()
+}

package/registry/layers/framework/agent-swarm-ts/files/writer.ts

@@ -0,0 +1,27 @@
+// Writer agent — takes the researcher's notes and writes the final output.
+
+import { ChatOpenAI } from '@langchain/openai'
+import type { SwarmStateType } from '../state'
+
+const model = new ChatOpenAI({
+  model: process.env['LLM_MODEL'] ?? 'anthropic/claude-haiku-4-5',
+  configuration: {
+    baseURL: process.env['OPENAI_BASE_URL'] ?? 'https://router.tangle.tools',
+    apiKey: process.env['OPENAI_API_KEY'],
+  },
+})
+
+const SYSTEM = `You are the Writer. Turn the Researcher's notes into clear, concise prose.
+Style: direct, specific, no filler. One paragraph unless the task asks for longer.
+Output just the prose, no preamble.`
+
+export async function runWriter(state: SwarmStateType): Promise<Partial<SwarmStateType>> {
+  const result = await model.invoke([
+    { role: 'system', content: SYSTEM },
+    { role: 'user', content: `Task: ${state.task}\n\nResearcher's notes:\n${state.notes}` },
+  ])
+  return {
+    draft: String(result.content),
+    messages: [{ role: 'assistant', content: String(result.content), agent: 'writer' }],
+  }
+}

package/registry/layers/framework/agent-swarm-ts/manifest.json

@@ -0,0 +1,27 @@
+{
+  "id": "agent-swarm-ts",
+  "description": "LangGraph-based supervisor/worker multi-agent scaffold. Ships a researcher + writer pair plus a supervisor that routes between them via a shared state graph.",
+  "appliesTo": ["agent-swarm-ts"],
+  "files": [
+    {
+      "source": "files/server.ts",
+      "target": "src/server.ts"
+    },
+    {
+      "source": "files/state.ts",
+      "target": "src/state.ts"
+    },
+    {
+      "source": "files/supervisor.ts",
+      "target": "src/supervisor.ts"
+    },
+    {
+      "source": "files/researcher.ts",
+      "target": "src/agents/researcher.ts"
+    },
+    {
+      "source": "files/writer.ts",
+      "target": "src/agents/writer.ts"
+    }
+  ]
+}