@lemmaoracle/x402 0.1.1 → 0.1.2

package/lib/forge-std/test/fixtures/config.toml

@@ -1,81 +0,0 @@
-# ------------------------------------------------
-#           EXAMPLE DEPLOYMENT CONFIG
-# ------------------------------------------------
-
-# -- MAINNET -------------------------------------
-
-[mainnet]
-endpoint_url = "${MAINNET_RPC}"
-
-[mainnet.bool]
-is_live = true
-bool_array = [true, false]
-
-[mainnet.address]
-weth = "${WETH_MAINNET}"
-deps = [
-    "0x0000000000000000000000000000000000000000",
-    "0x1111111111111111111111111111111111111111",
-]
-
-[mainnet.uint]
-number = 1234
-number_array = [5678, 9999]
-
-[mainnet.int]
-signed_number = -1234
-signed_number_array = [-5678, 9999]
-
-[mainnet.bytes32]
-word = "0x00000000000000000000000000000000000000000000000000000000000004d2" # 1234
-word_array = [
-    "0x000000000000000000000000000000000000000000000000000000000000162e", # 5678
-    "0x000000000000000000000000000000000000000000000000000000000000270f", # 9999
-]
-
-[mainnet.bytes]
-b = "0xabcd"
-b_array = ["0xdead", "0xbeef"]
-
-[mainnet.string]
-str = "foo"
-str_array = ["bar", "baz"]
-
-# -- OPTIMISM ------------------------------------
-
-[optimism]
-endpoint_url = "${OPTIMISM_RPC}"
-
-[optimism.bool]
-is_live = false
-bool_array = [false, true]
-
-[optimism.address]
-weth = "${WETH_OPTIMISM}"
-deps = [
-    "0x2222222222222222222222222222222222222222",
-    "0x3333333333333333333333333333333333333333",
-]
-
-[optimism.uint]
-number = 9999
-number_array = [1234, 5678]
-
-[optimism.int]
-signed_number = 9999
-signed_number_array = [-1234, -5678]
-
-[optimism.bytes32]
-word = "0x000000000000000000000000000000000000000000000000000000000000270f" # 9999
-word_array = [
-    "0x00000000000000000000000000000000000000000000000000000000000004d2", # 1234
-    "0x000000000000000000000000000000000000000000000000000000000000162e", # 5678
-]
-
-[optimism.bytes]
-b = "0xdcba"
-b_array = ["0xc0ffee", "0xbabe"]
-
-[optimism.string]
-str = "alice"
-str_array = ["bob", "charlie"]

package/lib/forge-std/test/fixtures/test.json

@@ -1,8 +0,0 @@
-{
-  "a": 123,
-  "b": "test",
-  "c": {
-    "a": 123,
-    "b": "test"
-  }
-}

package/lib/forge-std/test/fixtures/test.toml

@@ -1,6 +0,0 @@
-a = 123
-b = "test"
-
-[c]
-a = 123
-b = "test"

package/package.json.backup

@@ -1,55 +0,0 @@
-{
-  "name": "@lemmaoracle/x402",
-  "version": "0.1.1",
-  "description": "ZK-enabled x402 payment proofs for Lemma's disclosure.condition API",
-  "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "tsc --build",
-    "build:circuit": "bash scripts/build.sh",
-    "dev": "tsc --watch",
-    "type-check": "tsc --noEmit",
-    "test": "vitest run && bash -c 'if [ ! -f \"build/payment_js/payment.wasm\" ]; then echo \"🔧 Circuit not built. Building circuit first...\" && npm run build:circuit; fi && node circuits/payment.test.mjs'",
-    "test:vitest": "vitest run",
-    "test:watch": "vitest",
-    "test:circuit": "node circuits/payment.test.mjs",
-    "test:circuit:comprehensive": "node circuits/payment-comprehensive.test.mjs",
-    "deploy:worker": "wrangler deploy --config wrangler.toml",
-    "deploy": "dotenv -e ../../.env -- forge script ${SCRIPT:-scripts/DeployPaymentVerifier.s.sol} --broadcast",
-    "deploy:monadTestnet": "dotenv -e ../../.env -- forge script ${SCRIPT:-scripts/DeployPaymentVerifier.s.sol} --rpc-url monad_testnet --broadcast --verify",
-    "deploy:baseSepolia": "dotenv -e ../../.env -- forge script ${SCRIPT:-scripts/DeployPaymentVerifier.s.sol} --rpc-url base_sepolia --broadcast --verify",
-    "register": "tsx scripts/register-circuit.ts"
-  },
-  "dependencies": {
-    "@lemmaoracle/sdk": "workspace:*",
-    "@lemmaoracle/spec": "workspace:*",
-    "@x402/core": "^2.9.0",
-    "@x402/evm": "^2.9.0",
-    "@x402/hono": "^2.9.0",
-    "hono": "^4.6.14",
-    "ramda": "^0.30.0",
-    "viem": "^2.21.0"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20241230.0",
-    "@types/ramda": "^0.30.0",
-    "circom2": "^0.2.22",
-    "circomlib": "^2.0.5",
-    "dotenv": "^16.4.7",
-    "dotenv-cli": "^11.0.0",
-    "poseidon-lite": "^0.3.0",
-    "snarkjs": "^0.7.5",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.3",
-    "vitest": "^2.0.0",
-    "wrangler": "^3.101.0"
-  }
-}

package/scripts/DeployPaymentVerifier.s.sol

@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.24;
-
-import {Script, console} from "forge-std/Script.sol";
-import {Groth16Verifier} from "../build/PaymentVerifier.sol";
-
-contract DeployPaymentVerifier is Script {
-  function run() external returns (Groth16Verifier) {
-    uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
-
-    vm.startBroadcast(deployerPrivateKey);
-    Groth16Verifier verifier = new Groth16Verifier();
-    vm.stopBroadcast();
-
-    console.log("Groth16Verifier (PaymentVerifier) deployed at:", address(verifier));
-    return verifier;
-  }
-}

package/scripts/build.sh

@@ -1,61 +0,0 @@
-#!/usr/bin/env bash
-# Build script for x402 payment circuit
-# Compiles circuit → trusted setup → export verifier contract
-set -euo pipefail
-
-CIRCUIT="circuits/payment.circom"
-BUILD_DIR="build"
-PTAU="build/pot14_final.ptau"
-LIBS_DIR="$BUILD_DIR/libs"
-
-mkdir -p "$BUILD_DIR"
-
-# circom2 (WASM) cannot follow symlinks, which breaks with pnpm's symlinked
-# node_modules. Copy circomlib into the build directory as real files.
-rm -rf "$LIBS_DIR"
-mkdir -p "$LIBS_DIR"
-cp -rL node_modules/circomlib "$LIBS_DIR/circomlib"
-
-echo "1/5  Compiling x402 payment circuit..."
-npx circom2 "$CIRCUIT" --r1cs --wasm --sym -o "$BUILD_DIR" -l "$LIBS_DIR"
-
-echo "2/5  Downloading Powers of Tau (Hermez, 14)..."
-if [ ! -f "$PTAU" ]; then
-  curl -L -o "$PTAU" \
-    "https://storage.googleapis.com/zkevm/ptau/powersOfTau28_hez_final_14.ptau"
-fi
-
-echo "3/5  Groth16 setup..."
-npx snarkjs groth16 setup \
-  "$BUILD_DIR/payment.r1cs" \
-  "$PTAU" \
-  "$BUILD_DIR/payment_0000.zkey"
-
-echo "4/5  Contributing to phase 2 (demo only — not secure for production)..."
-echo "demo_entropy_x402_lemma_2026" | npx snarkjs zkey contribute \
-  "$BUILD_DIR/payment_0000.zkey" \
-  "$BUILD_DIR/payment_final.zkey" \
-  --name="Demo contribution x402 payment" -v
-
-echo "5/5  Exporting verification key and Solidity verifier..."
-# Export verification key (for off-chain verification)
-npx snarkjs zkey export verificationkey \
-  "$BUILD_DIR/payment_final.zkey" \
-  "$BUILD_DIR/verification_key.json"
-
-# Export Solidity verifier contract
-npx snarkjs zkey export solidityverifier \
-  "$BUILD_DIR/payment_final.zkey" \
-  "$BUILD_DIR/PaymentVerifier.sol"
-
-echo ""
-echo "✅ Build complete"
-echo "   WASM : $BUILD_DIR/payment_js/payment.wasm"
-echo "   zkey : $BUILD_DIR/payment_final.zkey"
-echo "   Verification key: $BUILD_DIR/verification_key.json"
-echo "   Verifier contract: $BUILD_DIR/PaymentVerifier.sol"
-echo ""
-echo "Next steps:"
-echo "  1. Upload wasm + zkey to IPFS"
-echo "  2. Register with Lemma: circuits.register(client, { circuitId: 'x402-payment-v1', ... })"
-echo ""

package/scripts/deploy.sh

@@ -1,65 +0,0 @@
-#!/bin/bash
-# Deploy PaymentVerifier contract to Monad Testnet
-
-set -e
-
-echo "🚀 Deploying PaymentVerifier to Monad Testnet..."
-
-# Load environment variables
-if [ -f .env ]; then
-  export $(cat .env | grep -v '^#' | xargs)
-fi
-
-# Check required environment variables
-if [ -z "$PRIVATE_KEY" ]; then
-  echo "❌ PRIVATE_KEY is not set"
-  exit 1
-fi
-
-if [ -z "$RPC_URL" ]; then
-  RPC_URL="https://testnet-rpc.monad.xyz"
-  echo "⚠️  RPC_URL not set, using default: $RPC_URL"
-fi
-
-# Check if contract exists
-if [ ! -f "build/PaymentVerifier.sol" ]; then
-  echo "❌ PaymentVerifier.sol not found. Run build.sh first."
-  exit 1
-fi
-
-# Deploy contract
-echo "📄 Deploying PaymentVerifier..."
-DEPLOY_OUTPUT=$(forge create \
-  --rpc-url "$RPC_URL" \
-  --private-key "$PRIVATE_KEY" \
-  --legacy \
-  "build/PaymentVerifier.sol:PaymentVerifier")
-
-echo "$DEPLOY_OUTPUT"
-
-# Extract contract address
-CONTRACT_ADDRESS=$(echo "$DEPLOY_OUTPUT" | grep -o "Deployed to: 0x[0-9a-fA-F]\{40\}" | cut -d' ' -f3)
-
-if [ -n "$CONTRACT_ADDRESS" ]; then
-  echo "✅ Contract deployed successfully!"
-  echo "📝 Contract address: $CONTRACT_ADDRESS"
-  
-  # Save to environment file
-  echo "VERIFIER_CONTRACT=$CONTRACT_ADDRESS" > .verifier.env
-  echo "✅ Saved to .verifier.env"
-  
-  # Verify on Etherscan if API key is available
-  if [ -n "$ETHERSCAN_API_KEY" ]; then
-    echo "🔍 Verifying on Etherscan..."
-    forge verify-contract \
-      --chain-id 10143 \
-      --etherscan-api-key "$ETHERSCAN_API_KEY" \
-      --compiler-version v0.8.28+commit.5fe4bb1d \
-      --num-of-optimizations 200 \
-      "$CONTRACT_ADDRESS" \
-      "build/PaymentVerifier.sol:PaymentVerifier" || echo "⚠️ Verification failed or skipped"
-  fi
-else
-  echo "❌ Failed to extract contract address"
-  exit 1
-fi

package/scripts/fix-verifier.mjs

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-/**
- * Fix G2 point encoding bug in snarkjs-generated verifier contracts
- * 
- * This script swaps the coordinate order in G2 points to match EIP-197 compatibility.
- * Required for snarkjs-generated verifiers to work with Ethereum.
- */
-
-import fs from 'fs';
-import path from 'path';
-
-const VERIFIER_PATH = path.join(process.cwd(), 'build', 'PaymentVerifier.sol');
-
-function fixG2Encoding(content) {
-  // Pattern to match G2 points in the verifier
-  // Looking for lines like: vk.gamma[0] = Pairing.G2Point([...], [...]);
-  const g2PointPattern = /(vk\.(gamma|gamma_2|gamma_abc\[0\]) = Pairing\.G2Point\()\[(0x[0-9a-fA-F, ]+)\],\s*\[(0x[0-9a-fA-F, ]+)\]\);/g;
-  
-  let fixedContent = content;
-  let replacements = 0;
-  
-  // Find and fix all G2 points
-  fixedContent = fixedContent.replace(g2PointPattern, (match, prefix, pointType, xCoord, yCoord) => {
-    replacements++;
-    console.log(`🔧 Fixing ${pointType} G2 point (swap coordinates)`);
-    // Swap the coordinates
-    return `${prefix}[${yCoord}], [${xCoord}]);`;
-  });
-  
-  if (replacements > 0) {
-    console.log(`✅ Fixed ${replacements} G2 point(s)`);
-  } else {
-    console.log('⚠️  No G2 points found to fix');
-  }
-  
-  return fixedContent;
-}
-
-function main() {
-  console.log(`🔍 Checking verifier: ${VERIFIER_PATH}`);
-  
-  if (!fs.existsSync(VERIFIER_PATH)) {
-    console.error(`❌ Verifier file not found: ${VERIFIER_PATH}`);
-    console.error('   Run build.sh first to generate the verifier.');
-    process.exit(1);
-  }
-  
-  // Read the verifier contract
-  const content = fs.readFileSync(VERIFIER_PATH, 'utf8');
-  
-  // Fix G2 encoding
-  const fixedContent = fixG2Encoding(content);
-  
-  // Write back if changes were made
-  if (content !== fixedContent) {
-    fs.writeFileSync(VERIFIER_PATH, fixedContent, 'utf8');
-    console.log('✅ Verifier contract fixed and saved.');
-  } else {
-    console.log('✅ No changes needed.');
-  }
-}
-
-// Run the script
-main();

package/scripts/register-circuit.ts

@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-/**
- * Register x402 payment circuit with Lemma
- *
- * This script:
- * 1. Uploads payment circuit WASM and zkey to Pinata
- * 2. Registers the circuit with Lemma SDK using the deployed verifier contract
- */
-
-import { create, circuits } from "@lemmaoracle/sdk";
-import type { LemmaClient, CircuitMeta } from "@lemmaoracle/spec";
-import dotenv from "dotenv";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = path.resolve(__dirname, "../../..");
-
-// Load environment variables
-dotenv.config({ path: path.join(PROJECT_ROOT, ".env") });
-
-const LEMMA_API_KEY = process.env.LEMMA_API_KEY;
-const PINATA_API_KEY = process.env.PINATA_API_KEY;
-const PINATA_SECRET_API_KEY = process.env.PINATA_SECRET_API_KEY;
-
-// Verifier contract address from deployment (Monad Testnet)
-const VERIFIER_ADDRESS = "0x851b33e46fc1ded8f752d1f2f26a9c58afde8815";
-const CHAIN_ID = 10143; // Monad Testnet
-
-/* ------------------------------------------------------------------ */
-/*  Pinata Upload Functions                                           */
-/* ------------------------------------------------------------------ */
-
-type PinataUploadResponse = Readonly<{
-  readonly IpfsHash: string;
-  readonly PinSize: number;
-  readonly Timestamp: string;
-  readonly isDuplicate?: boolean;
-}>;
-
-const uploadToPinata = (filePath: string, fileName: string): Promise<PinataUploadResponse> => {
-  const formData = new FormData();
-  const file = fs.readFileSync(filePath);
-  const blob = new Blob([file]);
-  formData.append("file", blob, fileName);
-
-  const metadata = JSON.stringify({
-    name: fileName,
-    keyvalues: {
-      project: "lemma-x402",
-      circuit: "payment",
-      timestamp: Date.now().toString(),
-    },
-  });
-  formData.append("pinataMetadata", metadata);
-
-  const options = JSON.stringify({ cidVersion: 0 });
-  formData.append("pinataOptions", options);
-
-  return fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
-    method: "POST",
-    headers: {
-      pinata_api_key: PINATA_API_KEY!,
-      pinata_secret_api_key: PINATA_SECRET_API_KEY!,
-    },
-    body: formData,
-  })
-    .then((res: Response) =>
-      res.ok ? res.json() : Promise.reject(new Error(`Pinata upload failed: ${res.status}`)),
-    )
-    .then((data: unknown) => data as PinataUploadResponse);
-};
-
-const uploadFileToPinata = (filePath: string, fileName: string): Promise<string> => {
-  if (!PINATA_API_KEY || !PINATA_SECRET_API_KEY) {
-    return Promise.reject(
-      new Error("PINATA_API_KEY and PINATA_SECRET_API_KEY environment variables are required"),
-    );
-  }
-  return uploadToPinata(filePath, fileName)
-    .then((response) => `ipfs://${response.IpfsHash}`)
-    .catch((error) => Promise.reject(new Error(`Failed to upload ${fileName}: ${error.message}`)));
-};
-
-/* ------------------------------------------------------------------ */
-/*  File Validation Functions                                         */
-/* ------------------------------------------------------------------ */
-
-const validateEnvironment = (): Promise<void> => {
-  if (!LEMMA_API_KEY || !PINATA_API_KEY || !PINATA_SECRET_API_KEY) {
-    return Promise.reject(
-      new Error(
-        "Missing required environment variables: LEMMA_API_KEY, PINATA_API_KEY, PINATA_SECRET_API_KEY",
-      ),
-    );
-  }
-  return Promise.resolve();
-};
-
-const checkFileExists = (filePath: string): Promise<void> => {
-  if (fs.existsSync(filePath)) {
-    return Promise.resolve();
-  }
-  return Promise.reject(new Error(`File not found: ${filePath}`));
-};
-
-/* ------------------------------------------------------------------ */
-/*  Circuit Registration                                              */
-/* ------------------------------------------------------------------ */
-
-const createLemmaClient = (): LemmaClient =>
-  create({
-    apiBase: "https://workers.lemma.workers.dev",
-    apiKey: LEMMA_API_KEY!,
-  });
-
-const registerCircuit = (client: LemmaClient, circuitMeta: CircuitMeta): Promise<CircuitMeta> =>
-  circuits.register(client, circuitMeta);
-
-const buildCircuitMeta = (wasmIpfsUrl: string, zkeyIpfsUrl: string): CircuitMeta => ({
-  circuitId: "x402-payment-v1",
-  schema: "passthrough-v1",
-  description: "x402 payment circuit for Monad Testnet",
-  inputs: ["amount", "recipient", "nonce"],
-  verifiers: [
-    {
-      type: "onchain",
-      address: VERIFIER_ADDRESS,
-      chainId: CHAIN_ID,
-      alg: "groth16-bn254-snarkjs",
-    },
-  ],
-  artifact: {
-    location: {
-      type: "ipfs",
-      wasm: wasmIpfsUrl,
-      zkey: zkeyIpfsUrl,
-    },
-  },
-  metadata: {
-    network: "monad-testnet",
-    chainId: CHAIN_ID,
-    version: "1.0",
-    deploymentTx: "0x365504aa2131a5e3f046dbbd3f929ebae17d3f78a21cea9d52742252bd9b33c2",
-    deploymentBlock: 0x17cf6e9,
-    circuitType: "payment",
-  },
-});
-
-/* ------------------------------------------------------------------ */
-/*  Main Execution Pipeline                                           */
-/* ------------------------------------------------------------------ */
-
-const main = async (): Promise<void> => {
-  try {
-    console.log("🚀 Starting x402 payment circuit registration...");
-    await validateEnvironment();
-
-    const wasmPath = path.join(PROJECT_ROOT, "packages/x402/build/payment_js/payment.wasm");
-    const zkeyPath = path.join(PROJECT_ROOT, "packages/x402/build/payment_final.zkey");
-
-    console.log("1. Checking artifact files...");
-    await Promise.all([checkFileExists(wasmPath), checkFileExists(zkeyPath)]);
-
-    console.log("2. Uploading artifacts to Pinata...");
-    const [wasmIpfsUrl, zkeyIpfsUrl] = await Promise.all([
-      uploadFileToPinata(wasmPath, "payment.wasm"),
-      uploadFileToPinata(zkeyPath, "payment_final.zkey"),
-    ]);
-
-    console.log("3. Registering circuit with Lemma...");
-    const client = createLemmaClient();
-    const circuitMeta = buildCircuitMeta(wasmIpfsUrl, zkeyIpfsUrl);
-    const registeredCircuit = await registerCircuit(client, circuitMeta);
-
-    console.log("\n✅ Circuit registered successfully!");
-    console.log(`📝 Circuit ID: ${registeredCircuit.circuitId}`);
-    console.log(`🔗 Schema: ${registeredCircuit.schema}`);
-    console.log(`🏢 Verifier: ${VERIFIER_ADDRESS} (Chain: ${CHAIN_ID})`);
-    console.log(`📦 WASM IPFS: ${wasmIpfsUrl}`);
-    console.log(`📦 zKey IPFS: ${zkeyIpfsUrl}`);
-    console.log("\n🎉 x402 payment circuit is now ready for use!");
-  } catch (error: unknown) {
-    console.error("\n❌ Error:", error instanceof Error ? error.message : String(error));
-
-    // Check if circuit already exists
-    if (
-      error instanceof Error &&
-      (error.message.includes("already exists") || error.message.includes("409"))
-    ) {
-      console.log("\nℹ️  Circuit may already be registered. Checking...");
-      try {
-        const client = createLemmaClient();
-        const existingCircuit = await circuits.getById(client, "x402-payment-v1");
-        console.log("   ✅ Circuit already exists:", existingCircuit.circuitId);
-        console.log("   🔗 Existing verifier:", existingCircuit.verifiers?.[0]?.address);
-        console.log("   📦 Existing WASM IPFS:", existingCircuit.artifact?.location.wasm);
-      } catch (checkError) {
-        console.error(
-          "   ❌ Circuit check failed:",
-          checkError instanceof Error ? checkError.message : String(checkError),
-        );
-        process.exit(1);
-      }
-    } else {
-      process.exit(1);
-    }
-  }
-};
-
-// Execute main function
-main();

package/scripts/test-with-circuit.mjs

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-/**
- * Combined test script that runs both TypeScript tests and circuit tests
- * Usage: node scripts/test-with-circuit.mjs
- */
-
-import { spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT_DIR = resolve(__dirname, '..');
-
-// Check if build files exist
-function checkBuildFiles() {
-  const requiredFiles = [
-    'build/payment_js/payment.wasm',
-    'build/payment_final.zkey',
-    'build/verification_key.json'
-  ];
-  
-  const missingFiles = requiredFiles.filter(file => !existsSync(resolve(ROOT_DIR, file)));
-  return missingFiles;
-}
-
-// Helper function to run commands
-function runCommand(command, args = [], cwd = ROOT_DIR) {
-  return new Promise((resolve, reject) => {
-    console.log(`\n>>> Running: ${command} ${args.join(' ')}`);
-    
-    const child = spawn(command, args, {
-      cwd,
-      stdio: 'inherit',
-      shell: true
-    });
-    
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Command failed with exit code ${code}`));
-      }
-    });
-    
-    child.on('error', (error) => {
-      reject(error);
-    });
-  });
-}
-
-async function main() {
-  console.log('=== Running X402 Package Tests ===\n');
-  
-  try {
-    // 1. Run TypeScript tests (direct vitest execution)
-    console.log('1. Running TypeScript tests with Vitest...');
-    await runCommand('npx', ['vitest', 'run']);
-    
-    // 2. Check circuit build files
-    console.log('\n2. Checking circuit build files...');
-    const missingFiles = checkBuildFiles();
-    
-    if (missingFiles.length > 0) {
-      console.log('⚠️  Circuit build files missing. Building circuit...');
-      await runCommand('npm', ['run', 'build:circuit']);
-    } else {
-      console.log('✅ Circuit build files are present.');
-    }
-    
-    // 3. Run circuit tests
-    console.log('\n3. Running circuit tests...');
-    await runCommand('node', ['circuits/payment.test.mjs']);
-    
-    console.log('\n✅ All tests passed!');
-    process.exit(0);
-    
-  } catch (error) {
-    console.error('\n❌ Test failed:', error.message);
-    process.exit(1);
-  }
-}
-
-// Execute main function
-main().catch(error => {
-  console.error('Unhandled error:', error);
-  process.exit(1);
-});