1. GET QUOTE       → Find best LP rate for (platform, currency, amount)
2. SIGNAL INTENT   → Lock LP's USDC in escrow
3. SEND FIAT       → Agent sends fiat payment via payment platform API
4. GENERATE PROOF  → Headless Reclaim proof via @reclaimprotocol/attestor-core
5. SUBMIT PROOF    → POST proof to attestation service for EIP-712 signing
6. FULFILL INTENT  → Submit attestation on-chain, receive USDC

npm install @zkp2p/sdk @reclaimprotocol/attestor-core @zkp2p/providers viem

import { OfframpClient } from '@zkp2p/sdk';
import { createClaimOnAttestor } from '@reclaimprotocol/attestor-core';
import { createWalletClient, http } from 'viem';
import { base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

const USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(),
});

const client = new OfframpClient({
  walletClient,
  chainId: 8453,
  runtimeEnv: 'production',
  apiKey: process.env.ZKP2P_API_KEY,
});

const quote = await client.getQuote({
  paymentPlatforms: ['wise'],
  fiatCurrency: 'EUR',
  user: account.address,
  recipient: account.address,
  destinationChainId: 8453,
  destinationToken: USDC,
  amount: '500000000', // 500 USDC (6 decimals)
  isExactFiat: false,
});

// quote.depositId — which LP deposit to use
// quote.conversionRate — rate in 1e18 precision
// quote.fiatAmount — how much fiat to send
// quote.payeeDetails — hashed LP payment recipient

const quotes = await client.getQuote({
  paymentPlatforms: ['venmo', 'wise', 'revolut', 'paypal'],
  fiatCurrency: 'USD',
  user: account.address,
  recipient: account.address,
  destinationChainId: 8453,
  destinationToken: USDC,
  amount: '100000000',
  includeNearbyQuotes: true,
  nearbyQuotesCount: 5,
});

const intentTxHash = await client.signalIntent({
  depositId: quote.depositId,
  amount: quote.amount,
  toAddress: account.address,
  processorName: quote.processorName,
  payeeDetails: quote.payeeDetails,
  fiatCurrencyCode: 'EUR',
  conversionRate: quote.conversionRate,
});
// Parse intentHash from transaction receipt logs

const payeeInfo = await client.resolvePayeeHash(
  quote.depositId,
  quote.paymentMethodHash
);

const fiatAmount = Number(quote.amount) * Number(quote.conversionRate) / 1e18;
// For 500 USDC at 1.02 rate: 500 * 1.02 = €510.00

// Wise has a proper REST API with long-lived personal tokens
const wiseHeaders = { Authorization: `Bearer ${process.env.WISE_API_TOKEN}` };

// 1. Get profile
const profiles = await fetch('https://api.wise.com/v1/profiles', { headers: wiseHeaders });
const profileId = (await profiles.json())[0].id;

// 2. Create quote
const wiseQuote = await fetch('https://api.wise.com/v3/profiles/' + profileId + '/quotes', {
  method: 'POST',
  headers: { ...wiseHeaders, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    sourceCurrency: 'EUR',
    targetCurrency: 'EUR',
    sourceAmount: fiatAmount,
    targetAccount: payeeInfo.accountId,
  }),
});

// 3. Create transfer
const transfer = await fetch('https://api.wise.com/v1/transfers', {
  method: 'POST',
  headers: { ...wiseHeaders, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    targetAccount: payeeInfo.accountId,
    quoteUuid: (await wiseQuote.json()).id,
    customerTransactionId: `zkp2p-${intentHash.slice(0, 8)}`,
  }),
});

// Venmo requires session cookies from browser export
const venmoHeaders = {
  Cookie: process.env.VENMO_COOKIES, // 'api_access_token=...; v_id=...; login=...'
};

const payment = await fetch('https://api.venmo.com/v1/payments', {
  method: 'POST',
  headers: { ...venmoHeaders, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    user_id: payeeInfo.recipientId,
    amount: -fiatAmount, // Negative = outgoing
    note: `ZKP2P-${intentHash.slice(0, 8)}`,
  }),
});

import { createClaimOnAttestor } from '@reclaimprotocol/attestor-core';
import wiseProvider from '@zkp2p/providers/wise/transfer_wise.json' assert { type: 'json' };

// 1. Fetch transaction feed to find the payment
const txResponse = await fetch(wiseProvider.url.replace('{{PROFILE_ID}}', profileId), {
  headers: { Authorization: `Bearer ${process.env.WISE_API_TOKEN}` },
});
const transactions = await txResponse.json();

// 2. Find matching transaction by amount + recipient
const txIndex = transactions.findIndex(
  tx => tx.targetAmount === fiatAmount && tx.targetAccount === payeeInfo.accountId
);

// 3. Build claim request (same structure the PeerAuth extension uses)
const claimRequest = {
  name: 'http',
  context: {
    contextAddress: '0x0',
    contextMessage: intentHash, // Links proof to the on-chain intent
  },
  params: {
    url: wiseProvider.url.replace('{{PROFILE_ID}}', profileId),
    method: wiseProvider.method,
    body: wiseProvider.body || '',
    headers: {},
    paramValues: { PROFILE_ID: profileId },
    responseMatches: wiseProvider.responseMatches.map(m => ({
      ...m,
      value: m.value.replace(/\{\{INDEX\}\}/g, String(txIndex)),
    })),
    responseRedactions: wiseProvider.responseRedactions.map(r => ({
      jsonPath: r.jsonPath?.replace(/\{\{INDEX\}\}/g, String(txIndex)),
      xPath: r.xPath?.replace(/\{\{INDEX\}\}/g, String(txIndex)),
    })),
    ...(wiseProvider.additionalClientOptions && {
      additionalClientOptions: wiseProvider.additionalClientOptions,
    }),
  },
  secretParams: {
    headers: { Authorization: `Bearer ${process.env.WISE_API_TOKEN}` },
  },
  ownerPrivateKey: process.env.PRIVATE_KEY,
  client: {
    url: 'wss://attestation-service.zkp2p.xyz/ws', // provisional — confirm with ZKP2P team
  },
};

// 4. Generate proof (runs headlessly in Node.js)
const proof = await createClaimOnAttestor(claimRequest);

if (proof.error) {
  throw new Error(`Proof generation failed: ${proof.error}`);
}
// proof = { claim, signatures }

import venmoProvider from '@zkp2p/providers/venmo/transfer_venmo.json' assert { type: 'json' };

// Venmo uses cookies instead of bearer tokens
const claimRequest = {
  name: 'http',
  context: {
    contextAddress: '0x0',
    contextMessage: intentHash,
  },
  params: {
    url: venmoProvider.url.replace('{{SENDER_ID}}', senderId),
    method: 'GET',
    body: '',
    headers: {},
    paramValues: { SENDER_ID: senderId },
    responseMatches: venmoProvider.responseMatches.map(m => ({
      ...m,
      value: m.value.replace(/\{\{INDEX\}\}/g, String(txIndex)),
    })),
    responseRedactions: venmoProvider.responseRedactions.map(r => ({
      jsonPath: r.jsonPath?.replace(/\{\{INDEX\}\}/g, String(txIndex)),
    })),
    additionalClientOptions: venmoProvider.additionalClientOptions,
  },
  secretParams: {
    cookieStr: process.env.VENMO_COOKIES,
  },
  ownerPrivateKey: process.env.PRIVATE_KEY,
  client: {
    url: 'wss://attestation-service.zkp2p.xyz/ws', // provisional — confirm with ZKP2P team
  },
};

const proof = await createClaimOnAttestor(claimRequest);

// First proof: transfer list
const proof1 = await createClaimOnAttestor(mainClaimRequest);

// Second proof: delivery detail (from provider.additionalProofs[0])
const additionalProvider = wiseProvider.additionalProofs[0];
const proof2 = await createClaimOnAttestor({
  ...mainClaimRequest,
  params: {
    ...mainClaimRequest.params,
    url: additionalProvider.url.replace('{{TRANSFER_ID}}', transferId),
    responseMatches: additionalProvider.responseMatches,
    responseRedactions: additionalProvider.responseRedactions,
  },
});

// Both proofs are submitted together
const combinedProof = { proofs: [proof1, proof2] };

const attestationUrl = 'https://attestation-service.zkp2p.xyz';

const response = await fetch(
  `${attestationUrl}/verify/wise/transfer_wise`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      proofType: 'reclaim',
      proof: JSON.stringify(proof),
      chainId: 8453,
      verifyingContract: '0x16b3e4a3CA36D3A4bCA281767f15C7ADeF4ab163',
      intent: {
        intentHash,
        amount: String(quote.amount),
        timestampMs: String(Date.now()),
        paymentMethod: quote.paymentMethodHash,
        fiatCurrency: quote.fiatCurrencyHash,
        conversionRate: String(quote.conversionRate),
        payeeDetails: quote.payeeDetails,
        timestampBufferMs: '300000',
      },
    }),
  }
);

const attestation = await response.json();
// attestation = { intentHash, releaseAmount, dataHash, signatures, data, metadata }

const fulfillTxHash = await client.fulfillIntent({
  intentHash,
  proof: proof, // The Reclaim { claim, signatures } object
});

// USDC is now in the agent's wallet

// Human: "Here's my Wise API token: sk_live_..."
// Agent stores token → finds LP → sends fiat → generates proof → fulfills intent
// No further human interaction needed.

// Human exports cookies from browser (every few days when they expire)
// Agent: uses cookies → finds LP → sends fiat → generates proof → fulfills intent

// Agent: "Send $102 to @lp-venmo-username with note ZKP2P-ABC"
// Human: sends payment via Venmo app
// Human: provides fresh session cookies
// Agent: fetches transaction feed → generates proof → fulfills intent

import { Peerlytics } from '@peerlytics/sdk';

const peerlytics = new Peerlytics({ apiKey: process.env.PEERLYTICS_API_KEY });
const history = await peerlytics.getTakerHistory(account.address);

// history.stats.lockScore -> numeric trust score
// history.stats.tier -> 'PEASANT' | 'PEER' | 'PLUS' | 'PRO' | 'PLATINUM' | 'PEER_PRESIDENT'
// history.stats.tierProgress -> { currentTier, nextTier, progress, volumeNeeded }
// history.intents -> { total, fulfilled, pruned, successRate, volumeUsd }