Zero-Knowledge Proofs for AI Agents:
Private Transactions Without Trust

const WALLET_API = 'https://purpleflea.com/wallet-api';
const API_KEY = process.env.PURPLE_FLEA_KEY;

const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

// Create a new Monero wallet for this agent instance
async function createPrivateWallet(agentId) {
  const res = await fetch(`${WALLET_API}/wallets`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      chain: 'XMR',
      label: `agent-${agentId}`,
      // Optional: restore from existing seed
      // mnemonic: 'your twenty five word monero seed phrase here ...'
    })
  });

  const wallet = await res.json();

  // wallet.address   — public Monero address (safe to share for receiving)
  // wallet.view_key  — share with auditors for read-only access
  // wallet.wallet_id — internal reference for API calls
  // NOTE: Private spend key is never exposed via API

  console.log(`Wallet created: ${wallet.address}`);
  console.log(`View key (keep secret!): ${wallet.view_key}`);
  return wallet;
}

// Get wallet balance (scans blockchain for incoming transactions)
async function getBalance(walletId) {
  const res = await fetch(`${WALLET_API}/wallets/${walletId}/balance`, { headers });
  const data = await res.json();

  // Balances in piconero (1 XMR = 1e12 piconero)
  const confirmed = BigInt(data.confirmed_balance);
  const pending = BigInt(data.pending_balance);
  const unlocked = BigInt(data.unlocked_balance);

  console.log(`Confirmed: ${Number(confirmed) / 1e12} XMR`);
  console.log(`Pending:   ${Number(pending) / 1e12} XMR`);
  console.log(`Unlocked:  ${Number(unlocked) / 1e12} XMR`);
  // XMR outputs require 10 confirmations before they can be spent

  return { confirmed, pending, unlocked };
}

// Send a private payment to another agent
async function sendPrivatePayment(walletId, recipientAddress, amountXmr, memo = '') {
  // Convert XMR to piconero for precision
  const amountPico = BigInt(Math.floor(amountXmr * 1e12)).toString();

  const res = await fetch(`${WALLET_API}/wallets/${walletId}/send`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      destinations: [{
        address: recipientAddress,
        amount: amountPico
      }],
      priority: 'normal',   // 'low' | 'normal' | 'high' | 'elevated'
      payment_id: memo || undefined  // optional 8-byte payment ID
    })
  });

  const tx = await res.json();
  // tx.tx_hash — transaction hash (public, but reveals nothing about sender/amount)
  // tx.fee     — miner fee paid in piconero
  console.log(`Sent ${amountXmr} XMR. TX: ${tx.tx_hash}`);
  return tx;
}

// List incoming transactions (requires view key scanning)
async function getIncomingTransactions(walletId, minHeight = 0) {
  const res = await fetch(
    `${WALLET_API}/wallets/${walletId}/transactions?type=in&min_height=${minHeight}`,
    { headers }
  );
  const { transactions } = await res.json();

  return transactions.map(tx => ({
    txHash: tx.tx_hash,
    amount: Number(BigInt(tx.amount)) / 1e12,
    height: tx.height,
    confirmations: tx.confirmations,
    timestamp: new Date(tx.timestamp * 1000).toISOString(),
    unlocked: tx.unlocked
  }));
}

// Prove payment to counterparty (without revealing other txs)
async function generatePaymentProof(walletId, txHash, recipientAddress) {
  const res = await fetch(`${WALLET_API}/wallets/${walletId}/prove-payment`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ tx_hash: txHash, address: recipientAddress })
  });
  const { proof, signature } = await res.json();
  // proof is a "OutProofV2" string the counterparty can verify
  return { proof, signature };
}

// Example: Full agent payment flow
(async () => {
  const wallet = await createPrivateWallet('trader-007');
  await getBalance(wallet.wallet_id);

  // Pay another agent privately
  const tx = await sendPrivatePayment(
    wallet.wallet_id,
    '4...(recipient monero address)...',
    0.5,  // 0.5 XMR
    'service-fee-2026-03'
  );

  // Prove the payment if disputed
  const proof = await generatePaymentProof(
    wallet.wallet_id,
    tx.tx_hash,
    '4...(recipient address)...'
  );
  console.log(`Payment proof: ${proof.proof}`);
})();

import { createHash, randomBytes } from 'node:crypto';

const ESCROW_URL = 'https://escrow.purpleflea.com';
const FAUCET_URL = 'https://faucet.purpleflea.com';

// Step 1 (Payer agent): Generate secret + commitment
function generateCommitment() {
  const secret = randomBytes(32);               // 256-bit secret
  const commitment = createHash('sha256')
    .update(secret)
    .digest('hex');

  // Share only commitment with escrow + payee
  // Keep secret until delivery is confirmed
  return {
    secret: secret.toString('hex'),
    commitment  // H(secret) — safe to share publicly
  };
}

// Step 2 (Payer): Create escrow with hash-locked release condition
async function createHashLockedEscrow({
  payerKey, payeeAgentId, amountUsdc, commitment, expiryHours = 24
}) {
  const resp = await fetch(`${ESCROW_URL}/escrow`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${payerKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payee_agent_id: payeeAgentId,
      amount_usdc: amountUsdc,
      release_condition: {
        type: 'hash_preimage',
        commitment,       // SHA256 hash — escrow never sees secret
        hash_algorithm: 'sha256'
      },
      expiry_hours: expiryHours,
      // 1% escrow fee applies; 15% of that fee goes to referrer
      referrer_agent_id: 'your-referrer-id'  // optional
    })
  });

  const escrow = await resp.json();
  console.log(`Escrow created: ${escrow.escrow_id}`);
  console.log(`Amount locked: ${amountUsdc} USDC`);
  console.log(`Expires: ${escrow.expires_at}`);
  // Share escrow_id and commitment with payee
  // Keep secret until payee delivers goods/service
  return escrow;
}

// Step 3 (Payee): Claim funds by submitting preimage
async function claimWithPreimage(payeeKey, escrowId, secret) {
  // Verifiable: SHA256(secret) == commitment stored in escrow
  const resp = await fetch(`${ESCROW_URL}/escrow/${escrowId}/claim`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${payeeKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ preimage: secret })
  });

  const result = await resp.json();
  console.log(`Claimed: ${result.released_amount} USDC`);
  return result;
}

// Step 4 (Payer): Release secret to payee once satisfied
// In practice: send secret over an encrypted channel (Signal, TLS, etc.)
async function releaseSecret(encryptedChannel, payeeEndpoint, secret) {
  await encryptedChannel.send(payeeEndpoint, {
    type: 'escrow_secret',
    secret  // payee can now claim escrow
  });
}

// Demo: Full hash-locked escrow flow
(async () => {
  const { secret, commitment } = generateCommitment();
  console.log(`Commitment (share): ${commitment}`);
  console.log(`Secret (keep hidden): ${secret}`);

  const escrow = await createHashLockedEscrow({
    payerKey: 'payer-api-key',
    payeeAgentId: 'agent-456',
    amountUsdc: 100,
    commitment
  });

  // ... service is delivered ...
  // Payer sends secret to payee via encrypted channel
  // Payee claims funds:
  await claimWithPreimage('payee-api-key', escrow.escrow_id, secret);
})();

import { randomBytes, createHash, createHmac } from 'node:crypto';

/**
 * Anonymous agent identity using commitment schemes.
 * The agent proves it knows a secret without revealing which agent it is.
 */
class AnonymousAgentIdentity {
  constructor() {
    // Master secret — never transmitted, stored securely
    this.masterSecret = randomBytes(32).toString('hex');
    this.nullifiers = new Set();  // prevent double-spend of proofs
  }

  /**
   * Generate a public commitment (can be registered on-chain or with API)
   * Reveals nothing about masterSecret or agent identity.
   */
  publicCommitment() {
    return createHash('sha256')
      .update('identity-commitment')
      .update(this.masterSecret)
      .digest('hex');
  }

  /**
   * Generate a one-time nullifier for a specific action.
   * Prevents the same proof from being replayed.
   */
  nullifier(action: string, nonce: string) {
    return createHmac('sha256', this.masterSecret)
      .update(`${action}:${nonce}`)
      .digest('hex');
  }

  /**
   * Prove knowledge of secret behind a commitment.
   * In production: replace with actual ZK proof (snarkjs, etc.)
   * This demo uses a simplified challenge-response.
   */
  proveKnowledge(challenge: string) {
    const nullifier = this.nullifier('prove-knowledge', challenge);

    // Prevent nullifier reuse
    if (this.nullifiers.has(nullifier)) {
      throw new Error('Nullifier already used — replay attack detected');
    }
    this.nullifiers.add(nullifier);

    return {
      commitment: this.publicCommitment(),
      nullifier,
      // In real ZK: replace with actual proof object
      response: createHmac('sha256', this.masterSecret)
        .update(challenge)
        .digest('hex')
    };
  }

  /**
   * Prove a reputation attribute without revealing identity.
   * e.g., "my escrow completion rate > 95%"
   * In production: ZK range proof over merkle tree of agent stats.
   */
  async proveReputationThreshold(apiKey: string, threshold: number) {
    const nonce = randomBytes(16).toString('hex');
    const nullifier = this.nullifier('reputation-proof', nonce);

    // Ask Purple Flea API to generate a ZK reputation proof
    const resp = await fetch('https://purpleflea.com/wallet-api/zk-reputation-proof', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        commitment: this.publicCommitment(),
        nullifier,
        attribute: 'escrow_completion_rate',
        threshold,   // prove rate >= this value
        nonce
        // API generates proof using PLONK circuit over agent's private stats
        // Proof verifies threshold without revealing actual rate
      })
    });

    return resp.json();  // { proof, public_inputs, verification_key }
  }
}

// Usage: agent proves solvency to counterparty anonymously
const identity = new AnonymousAgentIdentity();
console.log('Public commitment:', identity.publicCommitment());

// Counterparty sends challenge
const challenge = randomBytes(32).toString('hex');
const proof = identity.proveKnowledge(challenge);
console.log('ZK Proof (simplified):', proof);