@lemmaoracle/x402 0.1.1

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

@@ -0,0 +1,81 @@
+# ------------------------------------------------
+#           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

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

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

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

package/package.json

@@ -0,0 +1,55 @@
+{
+  "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": "^0.0.17",
+    "@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/package.json.backup

@@ -0,0 +1,55 @@
+{
+  "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

@@ -0,0 +1,18 @@
+// 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

@@ -0,0 +1,61 @@
+#!/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

@@ -0,0 +1,65 @@
+#!/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

@@ -0,0 +1,64 @@
+#!/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

@@ -0,0 +1,213 @@
+#!/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();