@caatinga/core 2.2.1 → 2.3.1

package/dist/index.js

@@ -105,7 +105,7 @@ function formatCause(cause) {
 }
 
 // src/version.ts
-var CAATINGA_CORE_VERSION = "2.2.1";
+var CAATINGA_CORE_VERSION = "2.3.1";
 
 // src/config/config.schema.ts
 import { z } from "zod";
@@ -120,6 +120,15 @@ var NetworkConfigSchema = z.object({
   rpcUrl: z.string().url(),
   networkPassphrase: z.string().min(1)
 });
+var ZkCircuitSchema = z.object({
+  path: z.string().min(1),
+  protocol: z.literal("groth16"),
+  curve: z.literal("bls12381"),
+  verifierContract: z.string().optional()
+});
+var ZkConfigSchema = z.object({
+  circuits: z.record(z.string().min(1), ZkCircuitSchema)
+}).optional();
 var CaatingaConfigSchema = z.object({
   project: z.string().min(1),
   defaultNetwork: z.string().min(1).default("testnet"),
@@ -134,7 +143,8 @@ var CaatingaConfigSchema = z.object({
   frontend: z.object({
     framework: z.enum(["vite-react", "next", "astro"]).default("vite-react"),
     bindingsOutput: z.string().min(1)
-  })
+  }).optional(),
+  zk: ZkConfigSchema
 });
 
 // src/config/define-config.ts
@@ -331,6 +341,15 @@ async function listGeneratedEntries(outputDir) {
 }
 async function evaluateBindingFreshness(options) {
   const cwd = options.cwd ?? process.cwd();
+  if (!options.config.frontend) {
+    return {
+      contractName: options.contractName,
+      status: "unknown",
+      outputDir: "",
+      marker: null,
+      reason: "frontend bindings are not configured"
+    };
+  }
   const outputDir = path5.resolve(cwd, options.config.frontend.bindingsOutput, options.contractName);
   const contractArtifact = options.artifacts.networks[options.networkName]?.contracts[options.contractName];
   if (!contractArtifact) {
@@ -577,6 +596,7 @@ async function runCommand(command, args, options = {}) {
     const result = await execa(command, args, {
       cwd: options.cwd,
       env: options.env,
+      input: options.input,
       all: true,
       reject: true
     });
@@ -791,6 +811,19 @@ function resolveContract(config, contractName, cwd = process.cwd()) {
   };
 }
 
+// src/contracts/resolve-default-contract.ts
+function resolveDefaultContractName(config) {
+  const names = Object.keys(config.contracts);
+  if (names.length === 1) {
+    return names[0];
+  }
+  throw new CaatingaError(
+    "Pass a contract name to build.",
+    CaatingaErrorCode.CONTRACT_NOT_FOUND,
+    `Configured contracts: ${names.join(", ")}. Example: caatinga build ${names[0]}`
+  );
+}
+
 // src/contracts/wasm.ts
 import { createHash } from "crypto";
 import { access as access2, readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
@@ -1335,6 +1368,13 @@ async function removeLegacyBindingStub(cwd, bindingsOutput, contractName) {
 }
 async function generateBindings(options) {
   const cwd = options.cwd ?? process.cwd();
+  if (!options.config.frontend) {
+    throw new CaatingaError(
+      "Frontend bindings are not configured.",
+      CaatingaErrorCode.INVALID_CONFIG,
+      "Add a frontend.bindingsOutput entry to caatinga.config.ts before running caatinga generate."
+    );
+  }
   const network = resolveNetwork(options.config, options.networkName);
   const artifacts = await readArtifacts(cwd);
   const contractArtifact = artifacts.networks[network.name]?.contracts[options.contractName];
@@ -1581,15 +1621,18 @@ async function createProjectFromTemplate(options) {
     );
   }
   const manifest = await readTemplateManifest(templateDir);
+  const mergeIntoExisting = Boolean(options.filter);
   await mkdir3(targetDir, { recursive: true });
   await cp(templateDir, targetDir, {
     recursive: true,
-    force: false,
-    errorOnExist: true,
-    filter: (source) => shouldCopyTemplateEntry(templateDir, source)
+    force: mergeIntoExisting,
+    errorOnExist: !mergeIntoExisting,
+    filter: (source) => shouldCopyTemplateEntry(templateDir, source, options.filter)
   });
   await replaceTemplateVariables(targetDir, options.projectName);
-  await ensureArtifacts(targetDir, options.projectName);
+  if (!mergeIntoExisting) {
+    await ensureArtifacts(targetDir, options.projectName);
+  }
   return { targetDir, template: manifest };
 }
 async function ensureArtifacts(targetDir, projectName) {
@@ -1655,11 +1698,15 @@ async function replaceTemplateVariables(dir, projectName) {
     await writeFile3(entryPath, content.replaceAll("__PROJECT_NAME__", projectName), "utf8");
   }));
 }
-function shouldCopyTemplateEntry(templateDir, source) {
+function shouldCopyTemplateEntry(templateDir, source, userFilter) {
   const relativePath = path10.relative(templateDir, source);
   if (!relativePath || relativePath === ".") {
     return true;
   }
+  const normalizedPath = relativePath.split(path10.sep).join("/");
+  if (userFilter && !userFilter(normalizedPath)) {
+    return false;
+  }
   return !relativePath.split(path10.sep).some((segment) => TEMPLATE_COPY_EXCLUDED_DIRS.has(segment));
 }
 function isTextTemplateFile(filePath) {
@@ -1675,6 +1722,118 @@ function isTextTemplateFile(filePath) {
   ].includes(path10.extname(filePath));
 }
 
+// src/scaffold/create-zk-project.ts
+import { cp as cp2, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync } from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+var moduleDir = typeof __dirname === "string" ? __dirname : path11.dirname(fileURLToPath(import.meta.url));
+function scaffoldRoot() {
+  const candidates = [
+    path11.resolve(moduleDir, "../../scaffolds"),
+    path11.resolve(moduleDir, "../scaffolds")
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  return found ?? candidates[0];
+}
+function configSource(projectName) {
+  return `import { defineConfig } from "@caatinga/core";
+
+export default defineConfig({
+  project: "${projectName}",
+  defaultNetwork: "testnet",
+  contracts: {
+    verifier: {
+      path: "./contracts/verifier",
+      wasm: "./contracts/verifier/target/wasm32v1-none/release/verifier.wasm"
+    }
+  },
+  networks: {
+    testnet: {
+      rpcUrl: "https://soroban-testnet.stellar.org",
+      networkPassphrase: "Test SDF Network ; September 2015"
+    }
+  },
+  zk: {
+    circuits: {
+      main: {
+        path: "./circuits",
+        protocol: "groth16",
+        curve: "bls12381",
+        verifierContract: "verifier"
+      }
+    }
+  }
+});
+`;
+}
+function packageJsonSource(projectName) {
+  return `${JSON.stringify({
+    name: projectName,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      "zk:build": "caatinga zk build main",
+      "zk:prove": "caatinga zk prove main",
+      build: "caatinga build verifier",
+      deploy: "caatinga deploy verifier"
+    },
+    devDependencies: {
+      "@caatinga/cli": `^${CAATINGA_CORE_VERSION}`,
+      "@caatinga/core": `^${CAATINGA_CORE_VERSION}`
+    }
+  }, null, 2)}
+`;
+}
+function readmeSource(projectName) {
+  return `# ${projectName}
+
+Minimal Caatinga ZK project.
+
+## Workflow
+
+\`\`\`bash
+npm install
+npx caatinga zk build main
+npx caatinga build verifier
+npx caatinga deploy verifier --network testnet
+npx caatinga zk prove main
+\`\`\`
+
+Replace \`circuits/main.circom\` with your circuit. Keep the entry point named \`main\`.
+`;
+}
+async function createZkProject(options) {
+  const targetDir = path11.resolve(options.targetDir);
+  const force = options.force ?? false;
+  const projectFiles = options.projectFiles ?? true;
+  await mkdir4(targetDir, { recursive: true });
+  if (projectFiles) {
+    await Promise.all([
+      writeFile4(path11.join(targetDir, "caatinga.config.ts"), configSource(options.projectName), { encoding: "utf8", flag: force ? "w" : "wx" }),
+      writeFile4(path11.join(targetDir, "package.json"), packageJsonSource(options.projectName), { encoding: "utf8", flag: force ? "w" : "wx" }),
+      writeFile4(path11.join(targetDir, ".gitignore"), "node_modules\n.artifacts\ntarget\n", { encoding: "utf8", flag: force ? "w" : "wx" }),
+      writeFile4(path11.join(targetDir, "README.md"), readmeSource(options.projectName), { encoding: "utf8", flag: force ? "w" : "wx" })
+    ]);
+  }
+  await mkdir4(path11.join(targetDir, "contracts"), { recursive: true });
+  await cp2(path11.join(scaffoldRoot(), "zk-circuit-stub"), path11.join(targetDir, "circuits"), {
+    recursive: true,
+    force,
+    errorOnExist: !force
+  });
+  await cp2(path11.join(scaffoldRoot(), "zk-verifier"), path11.join(targetDir, "contracts", "verifier"), {
+    recursive: true,
+    force,
+    errorOnExist: !force
+  });
+  if (projectFiles) {
+    await writeArtifacts(createInitialArtifacts(options.projectName, { networks: ["testnet"] }), targetDir);
+  }
+  return { targetDir };
+}
+
 // src/ci/is-transient-testnet-smoke-failure.ts
 var NO_RETRY_CAATINGA_SUBSTRINGS = [
   "CAATINGA_UNSUPPORTED_CLI_VERSION",
@@ -1714,6 +1873,7 @@ export {
   collectProjectStatus,
   createInitialArtifacts,
   createProjectFromTemplate,
+  createZkProject,
   defineConfig,
   deployContract,
   deployContractGraph,
@@ -1732,6 +1892,7 @@ export {
   readArtifacts,
   readBindingMarker,
   resolveContract,
+  resolveDefaultContractName,
   resolveDeployArgs,
   resolveDeployOrder,
   resolveNetwork,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caatinga/core",
-  "version": "2.2.1",
+  "version": "2.3.1",
   "description": "Core config, artifacts, command orchestration, and error primitives for Caatinga/Soroban toolkit",
   "keywords": [
     "stellar",
@@ -45,6 +45,7 @@
   },
   "files": [
     "dist",
+    "scaffolds",
     "README.md",
     "LICENSE"
   ],

package/scaffolds/zk-circuit-stub/input.json

@@ -0,0 +1,3 @@
+{
+  "a": "1"
+}

package/scaffolds/zk-circuit-stub/main.circom

@@ -0,0 +1,9 @@
+pragma circom 2.1.6;
+
+template Main() {
+    signal input a;
+    signal output b;
+    b <== a;
+}
+
+component main = Main();