import { SettlementSecurity } from "@oobe-protocol-labs/synapse-sap-sdk";

await client.escrowV2.create(agentWallet, {
  deposit: new BN(100_000),
  pricePerCall: new BN(1_000),
  maxCalls: new BN(100),
  expiresAt: new BN(Math.floor(Date.now() / 1000) + 86400),
  securityMode: SettlementSecurity.CoSigned,
});

// Top up escrow
await client.escrowV2.deposit(agentWallet, nonce, new BN(50_000));

// Withdraw unused funds (depositor only)
await client.escrowV2.withdraw(agentWallet, nonce, new BN(30_000));

// Close empty escrow (reclaims rent)
await client.escrowV2.close(agentWallet, nonce);

import { sha256, hashToArray } from "@oobe-protocol-labs/synapse-sap-sdk";

const serviceHash = hashToArray(sha256("service-proof-001"));
await client.escrowV2.settle(depositorWallet, nonce, new BN(5), serviceHash);

// 1. Agent creates pending settlement
await client.escrowV2.createPendingSettlement(
  agentWallet, depositorWallet, nonce,
  settlementIdx, new BN(5), new BN(5000), serviceHash,
);

// 2. Depositor can dispute within the window
await client.escrowV2.fileDispute(agentWallet, nonce, settlementIdx, evidenceHash);

// 3. Arbiter resolves dispute
await client.escrowV2.resolveDispute(
  depositorWallet, agentWallet, nonce, settlementIdx,
  DisputeOutcome.DepositorWins,
);

// 4. Or if no dispute, finalize after window expires
await client.escrowV2.finalizeSettlement(agentWallet, depositorWallet, nonce, settlementIdx);

// 5. Cleanup
await client.escrowV2.closeDispute(pendingSettlementPda);
await client.escrowV2.closePendingSettlement(pendingSettlementPda);

// Migrate an existing V1 escrow to V2 format
await client.escrowV2.migrateFromV1(agentWallet);

const escrow = await client.escrowV2.fetch(agentPda, depositor, nonce);
const escrowOrNull = await client.escrowV2.fetchNullable(escrowPda);
const pending = await client.escrowV2.fetchPendingSettlement(pendingPda);
const dispute = await client.escrowV2.fetchDispute(disputePda);

// estimateCost reads the agent's on-chain pricing tiers and volume curve
// to calculate the total cost for a given number of calls.
// Returns: { totalCost, effectivePricePerCall, hasVolumeCurve, tiers }
const estimate = await client.x402.estimateCost(
  agentWallet,  // PublicKey: the agent you want to pay
  100,          // number of calls you plan to make
);

console.log(estimate.totalCost.toString());           // BN → string
console.log(estimate.effectivePricePerCall.toString()); // weighted average
console.log(estimate.hasVolumeCurve);                 // has tiered pricing?

// preparePayment sends one Solana TX: creates escrow PDA + deposits lamports.
// Returns a PaymentContext with all the derived PDAs needed for headers.
const ctx = await client.x402.preparePayment(agentWallet, {
  pricePerCall: 1_000,           // lamports per call (number, string, or BN)
  maxCalls: 500,                 // max calls allowed (0 = unlimited)
  deposit: 500_000,              // initial deposit in lamports
  expiresAt: 0,                  // Unix timestamp (0 = never expires)
  volumeCurve: [                 // optional: tiered pricing breakpoints
    { afterCalls: 100, pricePerCall: 800 },  // 20% discount after 100 calls
  ],
});

// From a PaymentContext (returned by preparePayment)
const headers = client.x402.buildPaymentHeaders(ctx);
// Returns: { "X-Payment-Protocol", "X-Payment-Escrow", "X-Payment-Depositor", ... }

// From an existing escrow (looks up the PDA on-chain)
const headers = await client.x402.buildPaymentHeadersFromEscrow(agentWallet);

// Agent calls settle() to claim payment for calls served.
// depositorWallet: the client who funded the escrow (identifies which escrow)
// 5: number of calls to settle
// "service-data-v1": service data string (auto-hashed to SHA-256)
const receipt = await client.x402.settle(depositorWallet, 5, "service-data-v1");

// settleBatch combines multiple settlements in one TX. Max 10 entries.
const batch = await client.x402.settleBatch(depositorWallet, [
  { calls: 3, serviceData: "batch-1" },  // settle 3 calls
  { calls: 7, serviceData: "batch-2" },  // settle 7 calls
]);

const balance = await client.x402.getBalance(agentWallet);

// Add more funds to an existing escrow (in lamports).
await client.x402.addFunds(agentWallet, 50_000);

// Withdraw funds from an escrow you own (must be the depositor).
await client.x402.withdrawFunds(agentWallet, 25_000);

// Close the escrow PDA. Balance must be 0. Reclaims ~0.004 SOL rent.
await client.x402.closeEscrow(agentWallet);

// Check if an escrow exists for this agent (returns boolean).
const exists = await client.x402.hasEscrow(agentWallet);

// Fetch the raw escrow account data (or null if not found).
const escrow = await client.x402.fetchEscrow(agentWallet);

// Verify a settlement TX by parsing its events.
const events = await client.x402.verifySettlement(txSignature);

import { BN } from "@coral-xyz/anchor";

// Low-level: all values must be BN. No automatic type conversion.
// Use the X402Registry (client.x402) for automatic conversions.
await client.escrow.create(agentWallet, {
  pricePerCall: new BN(1_000_000),     // 1,000,000 lamports per call
  maxCalls: new BN(100),               // max 100 calls (BN(0) = unlimited)
  initialDeposit: new BN(100_000_000), // deposit 0.1 SOL
  expiresAt: null,                     // null = never expires
  volumeCurve: null,                   // null = flat pricing
  tokenMint: null,                     // null = native SOL
  tokenDecimals: null,                 // null = defaults to 9 (SOL)
});

await client.escrow.deposit(agentWallet, new BN(50_000_000));

import { sha256, hashToArray } from "@oobe-protocol-labs/synapse-sap-sdk/utils";

// Low-level settle: requires BN for calls and pre-hashed service data.
const serviceHash = hashToArray(sha256("service-record-001")); // number[32]
await client.escrow.settle(
  depositorWallet,  // PublicKey: the client's wallet
  new BN(5),        // number of calls to settle
  serviceHash,      // 32-byte SHA-256 hash
);

// Low-level batch settle: each entry must use BN and pre-hashed service data.
// Max 10 entries per batch (LIMITS.MAX_BATCH_SETTLEMENTS).
await client.escrow.settleBatch(depositorWallet, [
  { callsToSettle: new BN(3), serviceHash: hashToArray(sha256("batch-1")) },
  { callsToSettle: new BN(7), serviceHash: hashToArray(sha256("batch-2")) },
]);

// Withdraw partial funds (must be the depositor).
await client.escrow.withdraw(agentWallet, new BN(25_000_000));

// Close escrow PDA. Balance must be 0. Reclaims rent to payer.
await client.escrow.close(agentWallet);

// Initialize stake (minimum 0.1 SOL)
await client.staking.initStake(agentWallet, new BN(1_000_000_000));

// Add more stake
await client.staking.deposit(agentWallet, new BN(500_000_000));

// Request unstake (starts 7-day cooldown)
await client.staking.requestUnstake(agentWallet, new BN(500_000_000));

// Complete unstake after cooldown expires
await client.staking.completeUnstake(agentWallet);

const stake = await client.staking.fetch(agentPda);
const stakeOrNull = await client.staking.fetchNullable(agentPda);
const stakeByPda = await client.staking.fetchByPda(stakePda);

import { BillingInterval } from "@oobe-protocol-labs/synapse-sap-sdk";

// Create a subscription
await client.subscription.create(agentWallet, {
  subId: 1,
  amount: new BN(100_000),
  interval: BillingInterval.Monthly,
});

// Fund subscription
await client.subscription.fund(agentWallet, 1, new BN(100_000));

// Cancel subscription (stops future billing)
await client.subscription.cancel(agentWallet, 1);

// Close subscription PDA (reclaim rent)
await client.subscription.close(agentWallet, 1);

const sub = await client.subscription.fetch(agentPda, subscriber, subId);
const subOrNull = await client.subscription.fetchNullable(subscriptionPda);