ZK-ProofCommerce for AI Agents

Enable trustless, private, and verifiable transactions between autonomous AI agents with zero-knowledge proofs

Explore Use Cases View Code Examples

Private Payments

Prove payment without revealing amounts

Verifiable Delivery

Validate data quality without exposure

Trustless Agreements

Enforce terms without intermediaries

Enterprise Commerce Use Cases

ZK-Proof of Payment

Prove payment completion without revealing transaction amounts, parties, or sensitive financial data

Key Features

Payment verification

Amount range proofs

Multi-token support

Cross-chain compatibility

"Agent proves $50k payment made without revealing exact amount or recipient identity"

Deliverable Compliance

Verify data quality and compliance requirements without exposing the actual dataset contents

Key Features

Schema validation

Size verification

Content scanning

Quality metrics

"Prove dataset has >100k clean records and no PII without sharing the actual data"

Terms Agreement

Demonstrate commercial agreement compliance using selective disclosure and commitment schemes

Key Features

Sealed auctions

Quote verification

Contract terms

Selective disclosure

"Prove bid meets requirements in sealed auction without revealing bid amount"

Conditional Payments

Enable atomic 'pay-if-prove-X' transactions with programmable conditions and escrow logic

Key Features

Escrow automation

Condition verification

Atomic swaps

Smart contracts

"Payment automatically releases when data quality proof is validated on-chain"

Reputation System

Build verifiable reputation scores while keeping transaction history and volumes private

Key Features

Volume ranges

Success rates

Time active

Anonymous aggregation

"Prove >95% success rate and $1M+ volume without revealing individual transactions"

Regulatory Compliance

Demonstrate regulatory adherence using verifiable credentials and selective disclosure

Key Features

KYC verification

AML compliance

Age proofs

Jurisdiction validation

"Prove accredited investor status and jurisdiction compliance without revealing identity"

Implementation Examples

Sample code showing how to integrate ZK-Commerce into your AI agent workflows

Payment Proof Generation

Generate zero-knowledge proofs for payments while keeping amounts and parties private.

Prove payment completion

Hide transaction amounts

Protect party identities

Enable cross-chain verification

payment-proof.ts

import { ZKCommerce } from '@zk-commerce/sdk';

async function generatePaymentProof() {
  const zkc = new ZKCommerce({
    configPath: './zk-commerce.config.yml'
  });
  
  // Initialize payment prover
  await zkc.payment.setup();
  
  // Generate proof
  const proof = await zkc.payment.prove({
    amount: ethers.utils.parseEther('10'),
    sender: '0x1234...', // Private input
    receiver: '0x5678...', // Private input
    nonce: Date.now()
  });
  
  console.log('Proof generated:', {
    proof: proof.proof.slice(0, 20) + '...',
    publicSignals: proof.publicSignals,
    size: proof.proof.length + ' bytes'
  });
  
  return proof;
}

Data Compliance Verification

Verify data quality and compliance without exposing sensitive dataset contents.

Schema validation

Size and quality checks

PII detection and removal

Statistical analysis

data-compliance.ts

async function verifyDatasetCompliance(datasetPath: string) {
  const zkc = new ZKCommerce();
  
  // Define compliance requirements
  const requirements = {
    minRows: 100_000,
    maxFileSize: 1_000_000_000, // 1GB
    forbiddenPatterns: [
      /\b\d{3}-\d{2}-\d{4}\b/g, // SSN
      /\b\d{16}\b/g              // Credit card
    ],
    schema: {
      type: 'object',
      properties: {
        id: { type: 'string' },
        timestamp: { type: 'number' },
        value: { type: 'number' }
      },
      required: ['id', 'timestamp', 'value']
    }
  };
  
  // Generate compliance proof
  const proof = await zkc.deliverable.prove({
    dataPath: datasetPath,
    requirements,
    options: {
      streaming: true, // For large files
      parallel: true   // Use multiple cores
    }
  });
  
  // Verify proof
  const isValid = await zkc.deliverable.verify(proof);
  
  if (isValid) {
    // Store proof attestation
    const attestation = await zkc.eas.attest({
      schema: 'DELIVERABLE_COMPLIANCE',
      data: proof,
      recipient: '0xBuyerAddress'
    });
    
    console.log('Compliance verified:', attestation.id);
  }
  
  return { proof, isValid };
}

Conditional Payments

Set up atomic "pay-if-prove-X" transactions with programmable conditions.

Automated escrow logic

Condition verification

Atomic execution

Smart contract integration

conditional-payment.ts

async function setupConditionalPayment() {
  const zkc = new ZKCommerce();
  
  // Define payment condition
  const condition = {
    type: 'DELIVERABLE_VALIDATION',
    requirements: {
      minQualityScore: 0.95,
      dataFormat: 'parquet',
      maxDeliveryTime: 3600 // 1 hour
    }
  };
  
  // Lock payment with condition
  const lock = await zkc.swap.lockPayment({
    amount: ethers.utils.parseEther('50'),
    recipient: '0xProviderAddress',
    condition,
    timeout: 86400 // 24 hours
  });
  
  console.log('Payment locked:', lock.id);
  
  // Provider claims with proof
  const claimProof = await zkc.deliverable.prove({
    data: deliverableData,
    requirements: condition.requirements
  });
  
  const claimTx = await zkc.swap.claim({
    lockId: lock.id,
    proof: claimProof
  });
  
  console.log('Payment claimed:', claimTx.hash);
}

Performance Benchmarks

2-5 seconds

Proof Generation

Payment proofs

<50ms

Verification

On-chain verification

10,000+

Throughput

Proofs per day

<$0.10

Cost

Per proof on L2

Ready to Build Trustworthy Commerce?

Join the waitlist to get early access to ZK-Commerce modules and start building verifiable AI agent transactions.

Join the Waitlist

Get early access to Treeship ZK module

Learn about ZK Attestations Developer Documentation