@tangle-network/starter-foundry 0.5.3 → 0.7.0

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)?)
+}

package/registry/families/arkworks-prover/files/validate-arkworks.mjs

@@ -0,0 +1,25 @@
+import fs from "node:fs/promises";
+
+const required = [
+  "Cargo.toml",
+  "src/main.rs",
+  "src/circuit.rs",
+  "src/prover.rs",
+];
+
+for (const path of required) {
+  try {
+    await fs.access(path);
+  } catch {
+    throw new Error(`arkworks-prover scaffold missing required file: ${path}`);
+  }
+}
+
+const cargo = await fs.readFile("Cargo.toml", "utf8");
+for (const dep of ["ark-bn254", "ark-groth16", "ark-r1cs-std", "ark-snark"]) {
+  if (!cargo.includes(dep)) {
+    throw new Error(`Cargo.toml missing ${dep} dep`);
+  }
+}
+
+console.log("arkworks-prover starter ok");

package/registry/families/arkworks-prover/manifest.json

@@ -0,0 +1,84 @@
+{
+  "id": "arkworks-prover",
+  "description": "Arkworks primitive-layer ZK prover — Rust binary crate for hand-rolled R1CS circuits. Pick your curve (BN254 default), pick your proof system (Groth16 default), build constraints by hand. Use when higher-level frameworks (Noir / SP1 / RISC Zero) are too coarse — custom curves, research circuits, novel proof systems.",
+  "tags": [
+    "zk",
+    "rust",
+    "arkworks",
+    "r1cs",
+    "groth16",
+    "primitives",
+    "research"
+  ],
+  "taxonomy": {
+    "language": "rust",
+    "runtime": "native",
+    "surface": "zk-library"
+  },
+  "slots": {},
+  "defaults": {
+    "projectType": "zk-library"
+  },
+  "files": [
+    {
+      "source": "files/Cargo.toml",
+      "target": "Cargo.toml"
+    },
+    {
+      "source": "files/rust-toolchain.toml",
+      "target": "rust-toolchain.toml"
+    },
+    {
+      "source": "files/src/main.rs",
+      "target": "src/main.rs"
+    },
+    {
+      "source": "files/src/circuit.rs",
+      "target": "src/circuit.rs"
+    },
+    {
+      "source": "files/src/prover.rs",
+      "target": "src/prover.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/validate-arkworks.mjs",
+      "target": "validate-arkworks.mjs"
+    }
+  ],
+  "tieredKeywords": {
+    "tier1": [
+      "arkworks",
+      "ark-works",
+      "ark-ff",
+      "ark-bn254",
+      "ark-relations",
+      "ark-groth16"
+    ],
+    "tier2": [
+      "custom r1cs",
+      "hand-rolled r1cs",
+      "arkworks zk primitive",
+      "build a snark circuit from scratch",
+      "custom snark circuit",
+      "research-grade zk proof",
+      "novel proof system",
+      "custom curve proof"
+    ],
+    "archetypes": [
+      "hand-rolled snark circuit",
+      "research zk construction",
+      "novel proof system in rust",
+      "custom curve zk prover"
+    ]
+  },
+  "validationChecks": [
+    { "type": "file-exists", "path": "Cargo.toml" },
+    { "type": "file-exists", "path": "src/main.rs" },
+    { "type": "file-exists", "path": "src/circuit.rs" },
+    { "type": "file-exists", "path": "src/prover.rs" }
+  ]
+}

package/registry/families/astro-static/files/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "astro dev",
+    "start": "astro dev",
+    "build": "astro check && astro build",
+    "preview": "astro preview",
+    "astro": "astro",
+    "validate": "node validate-astro.mjs"
+  },
+  "dependencies": {
+    "astro": "^5.2.0"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.4",
+    "typescript": "^5.7.0"
+  },
+  "overrides": {
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "^6.4.2"
+    }
+  }
+}

package/registry/families/astro-static/files/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"]
+}

package/registry/families/astro-static/files/validate-astro.mjs

@@ -0,0 +1,26 @@
+import fs from "node:fs/promises";
+
+const [pkgSource, configSource, indexSource] = await Promise.all([
+  fs.readFile("package.json", "utf8"),
+  fs.readFile("astro.config.mjs", "utf8"),
+  fs.readFile("src/pages/index.astro", "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?.astro) {
+  throw new Error("package.json missing astro dependency");
+}
+
+if (!configSource.includes("defineConfig")) {
+  throw new Error("astro.config.mjs should call defineConfig()");
+}
+
+if (!indexSource.includes("---")) {
+  throw new Error("src/pages/index.astro missing frontmatter fence (---)");
+}
+
+console.log("astro starter ok");