Connect Your Agent

const KURIER_BASE = "https://api-testnet.kurier.xyz/api/v1";
const API_KEY = process.env.KURIER_API_KEY;

const res = await fetch(`${KURIER_BASE}/submit-proof/${API_KEY}`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    proofType: "groth16",
    proofOptions: {
      library: "snarkjs",
      curve: "bn128",
    },
    proofData: {
      proof: proof,
      publicSignals: publicSignals,
      vk: vkHash,  // registered VK hash
    },
    vkRegistered: true,
    chainId: 84532,  // routes to Base Sepolia
  }),
});

const { jobId } = await res.json();

async function waitForAggregation(jobId) {
  while (true) {
    const res = await fetch(
      `${KURIER_BASE}/job-status/${API_KEY}/${jobId}`
    );
    const job = await res.json();

    if (job.status === "Aggregated") {
      // aggregationDetails contains:
      //   leaf, merkleProof, leafIndex,
      //   numberOfLeaves, root, receipt,
      //   receiptBlockHash
      return job;
    }
    if (job.status === "Error") {
      throw new Error(job.error);
    }

    await new Promise((r) => setTimeout(r, 5000));
  }
}

const result = await waitForAggregation(jobId);
const agg = result.aggregationDetails;

import { createPublicClient, http } from "viem";
import { baseSepolia } from "viem/chains";

const ZKVERIFY_ATTESTATION = "0x0807C544D38aE7729f8798388d89Be6502A1e8A8";

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(process.env.BASE_SEPOLIA_RPC_URL),
});

const abi = [{
  name: "verifyProofAggregation",
  type: "function",
  stateMutability: "view",
  inputs: [
    { name: "domainId", type: "uint256" },
    { name: "attestationId", type: "uint256" },
    { name: "leaf", type: "bytes32" },
    { name: "merklePath", type: "bytes32[]" },
    { name: "leafCount", type: "uint256" },
    { name: "index", type: "uint256" },
  ],
  outputs: [{ type: "bool" }],
}];

// Poll until relayed (up to 5 minutes)
for (let i = 0; i < 60; i++) {
  try {
    const ok = await client.readContract({
      address: ZKVERIFY_ATTESTATION,
      abi,
      functionName: "verifyProofAggregation",
      args: [
        result.domainId,
        result.attestationId,
        agg.leaf,
        agg.merkleProof,
        agg.numberOfLeaves,
        agg.leafIndex,
      ],
    });
    if (ok) break;
  } catch (e) {}
  await new Promise((r) => setTimeout(r, 5000));
}

import { createWalletClient } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const GATEWAY = "0xbbdcb0C9C3B9ce60555fdF50cFB99802E7c33920";

const gatewayAbi = [{
  name: "recordValidation",
  type: "function",
  stateMutability: "payable",
  inputs: [{
    name: "p",
    type: "tuple",
    components: [
      { name: "agentId", type: "uint256" },
      { name: "proofType", type: "string" },
      { name: "zkVerifyTxHash", type: "bytes32" },
      { name: "zkVerifyBlockHash", type: "bytes32" },
      { name: "domainId", type: "uint256" },
      { name: "attestationId", type: "uint256" },
      { name: "leaf", type: "bytes32" },
      { name: "merklePath", type: "bytes32[]" },
      { name: "leafCount", type: "uint256" },
      { name: "index", type: "uint256" },
      { name: "pubsBytes", type: "bytes" },
      { name: "vkHash", type: "bytes32" },
      { name: "versionHash", type: "bytes32" },
    ],
  }],
  outputs: [{ name: "validationId", type: "uint256" }],
}, {
  name: "protocolFee",
  type: "function",
  stateMutability: "view",
  inputs: [],
  outputs: [{ type: "uint256" }],
}];

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const walletClient = createWalletClient({
  account,
  chain: baseSepolia,
  transport: http(process.env.BASE_SEPOLIA_RPC_URL),
});

// Read current fee — V2 requires msg.value == protocolFee exactly (no overpayment)
const fee = await client.readContract({
  address: GATEWAY,
  abi: gatewayAbi,
  functionName: "protocolFee",
});

// Record validation
const txHash = await walletClient.writeContract({
  address: GATEWAY,
  abi: gatewayAbi,
  functionName: "recordValidation",
  args: [{
    agentId: YOUR_AGENT_ID,
    proofType: "pulse-sla",                  // proofType you onboarded under
    zkVerifyTxHash: agg.receipt,             // zkVerify extrinsic hash from Kurier
    zkVerifyBlockHash: agg.receiptBlockHash, // zkVerify block hash from Kurier
    domainId: result.domainId,
    attestationId: result.attestationId,
    leaf: agg.leaf,
    merklePath: agg.merkleProof,
    leafCount: agg.numberOfLeaves,
    index: agg.leafIndex,
    pubsBytes: PUBS_BYTES,                   // proof-system-specific encoding of public signals
    vkHash: VK_HASH,                         // your circuit's registered VK hash
    versionHash: VERSION_HASH,               // zkVerify proof-system version hash
  }],
  value: fee,                                // exact-fee — overpayment now reverts
});

console.log("Validation recorded:", txHash);

Need help with the integration? Check the full documentation.