SDK Reference#

npm install @xenga/client viem
# or
bun add @xenga/client viem

import { escrowFetch } from "@xenga/client";
 
const { response, payment } = await escrowFetch(
  "https://api.xenga.xyz/api/orders/ORDER_ID/pay",
  { method: "POST" },
  { walletClient }
);

{
  response: Response;       // The final HTTP response
  payment?: EscrowPaymentResponse;  // Present if payment was made
}

const { response, payment } = await escrowFetch(url, { method: "POST" }, {
  walletClient,
  onSellerReputation: (rep) => {
    if (rep.score < 50) return false; // abort — throws ReputationAbortError
    return true;
  },
});

import { createEscrowClient } from "@xenga/client";
 
const client = createEscrowClient({
  privateKey: "0xYOUR_PRIVATE_KEY",
  serverUrl: "https://api.xenga.xyz",
  escrowVaultAddress: "0xCONTRACT_ADDRESS",
});

const { order, payment } = await client.payForOrder("order-123");
console.log("Escrow ID:", payment.escrowId);
console.log("TX Hash:", payment.txHash);

const txHash = await client.releaseOnChain(123);

const txHash = await client.disputeOnChain(123);

const txHash = await client.confirmDeliveryOnChain(123);

const txHash = await client.refundOnChain(123);

const order = await client.getOrder("order-123");
console.log(order.status); // "escrowed"

const escrow = await client.getEscrow(123);
console.log(EscrowState[escrow.state]); // "Active"

const rep = await client.getReputation("0x...");
console.log(`Score: ${rep.overall}/100 (${rep.confidence})`);

const stats = await client.getSellerStats();
console.log(`Completed: ${stats.completedCount}/${stats.totalEscrows}`);

const { eth, wei } = await client.getBalance();
console.log(`ETH: ${eth}`);

const { stop } = client.watchEscrow(123, (escrow) => {
  console.log("New state:", EscrowState[escrow.state]);
  if (escrow.state === EscrowState.Completed) stop();
});

import { signEscrowPayment } from "@xenga/client";
 
const payload = await signEscrowPayment(walletClient, paymentRequired);
// payload is ready for the X-PAYMENT header

import { discoverServices, screenSeller, autoPayAndVerify } from "@xenga/client/agent";

const info = await discoverServices("https://api.xenga.xyz");
console.log(info.serviceTypes); // [{ name: "agent-service", releaseWindow: 3600, ... }]

interface DiscoverResult {
  facilitatorUrl: string;
  chain: string;
  chainId: number;
  escrowContract: string;
  serviceTypes: ServiceInfo[];
}
 
interface ServiceInfo {
  name: string;
  releaseWindow: number;
  autoVerify: boolean;
  description: string;
}

const result = await screenSeller("https://api.xenga.xyz", "0x...", 70);
if (!result.acceptable) {
  console.log(`Seller score ${result.score} below minimum 70`);
}

interface ScreenResult {
  address: Address;
  score: number;
  confidence: "low" | "medium" | "high";
  acceptable: boolean;
  reputation: ReputationScore;
}

const result = await autoPayAndVerify(
  "https://api.xenga.xyz/inference",
  { method: "POST", body: JSON.stringify({ prompt: "hello" }) },
  { walletClient, minSellerReputation: 60 }
);
 
console.log(result.data);       // parsed response body
console.log(result.escrowId);   // on-chain escrow ID
console.log(result.txHash);     // settlement transaction hash

interface AutoPayResult {
  response: Response;
  data: unknown;
  escrowId?: number;
  txHash?: string;
}

import { withRetry, isRetryableError } from "@xenga/client";

const result = await withRetry(() => submitTransaction(), { maxRetries: 3 });

import { NetworkError, ReputationAbortError } from "@xenga/client";
 
try {
  await escrowFetch(url, init, options);
} catch (err) {
  if (err instanceof ReputationAbortError) {
    console.log(`Aborted: seller score ${err.score} too low`);
  }
}

interface EscrowPaymentRequired {
  scheme: "escrow";
  network: string;
  escrowContract: Address;
  asset: Address;
  amount: string;           // stringified bigint (USDC smallest unit)
  orderId: Hash;
  sellerAddress: Address;
  releaseWindow: number;
  serviceType: string;
  facilitatorFee?: string;  // informational
  feeBps?: number;          // basis points (100 = 1%)
  flatFee?: string;         // informational
}

interface EscrowPaymentResponse {
  success: boolean;
  txHash: Hash;
  escrowId: number;
}

interface OnChainEscrow {
  orderId: Hash;
  buyer: Address;
  seller: Address;
  amount: bigint;
  serviceType: string;
  state: EscrowState;
  createdAt: bigint;
  releaseWindow: bigint;
  deliveryConfirmedAt: bigint;
  disputeWindow: bigint;
  facilitatorFee: bigint;
  contentHash: Hash;       // keccak256 of order terms/metadata; bytes32(0) if none provided
}

enum EscrowState {
  None = 0,
  Active = 1,
  DeliveryConfirmed = 2,
  Completed = 3,
  AutoReleased = 4,
  Disputed = 5,
  Resolved = 6,
  Refunded = 7,
}

interface ReputationScore {
  address: Address;
  overall: number;        // 0-100
  confidence: "low" | "medium" | "high";
  seller?: SellerReputation;
  buyer?: BuyerReputation;
  updatedAt: number;
}

interface Stats {
  totalEscrows: bigint;
  totalAmount: bigint;
  completedCount: bigint;
  completedAmount: bigint;
  disputedCount: bigint;
  disputedAmount: bigint;
  resolvedCount: bigint;
  refundedCount: bigint;
  refundedAmount: bigint;
}