@usdctofiat/offramp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,674 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Offramp: () => Offramp,
+  OfframpError: () => OfframpError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_viem2 = require("viem");
+var import_sdk4 = require("@zkp2p/sdk");
+
+// src/deposit.ts
+var import_viem = require("viem");
+var import_sdk3 = require("@zkp2p/sdk");
+
+// src/config.ts
+var import_sdk = require("@zkp2p/sdk");
+var BASE_CHAIN_ID = 8453;
+var RUNTIME_ENV = "production";
+var API_BASE_URL = "https://api.zkp2p.xyz";
+var BASE_RPC_URL = "https://mainnet.base.org";
+var contracts = (0, import_sdk.getContracts)(BASE_CHAIN_ID, RUNTIME_ENV);
+var addresses = contracts.addresses;
+var addrs = addresses;
+var USDC_ADDRESS = addrs.token || "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var ESCROW_ADDRESS = addrs.escrowV2 || addrs.escrow || "";
+var GATING_SERVICE_ADDRESS = (0, import_sdk.getGatingServiceAddress)(BASE_CHAIN_ID, RUNTIME_ENV);
+var DELEGATE_RATE_MANAGER_ID = "0x8666d6fb0f6797c56e95339fd7ca82fdd348b9db200e10a4c4aa0a0b879fc41c";
+var RATE_MANAGER_REGISTRY_ADDRESS = "0xeed7db23e724ac4590d6db6f78fda6db203535f3";
+var REFERRER = "galleonlabs";
+var MIN_DEPOSIT_USDC = 10;
+var MIN_ORDER_USDC = 5;
+var INDEXER_MAX_ATTEMPTS = 12;
+var INDEXER_INITIAL_DELAY_MS = 1e3;
+var INDEXER_MAX_DELAY_MS = 1e4;
+var PAYEE_REGISTRATION_TIMEOUT_MS = 8e3;
+
+// src/platforms.ts
+var import_sdk2 = require("@zkp2p/sdk");
+var import_zod = require("zod");
+
+// src/types.ts
+var PLATFORMS = [
+  "venmo",
+  "cashapp",
+  "chime",
+  "revolut",
+  "wise",
+  "mercadopago",
+  "zelle",
+  "paypal",
+  "monzo",
+  "n26"
+];
+
+// src/platforms.ts
+var ZELLE_HASH_LOOKUP_NAMES = ["zelle", "zelle-bofa", "zelle-chase", "zelle-citi"];
+var PAYMENT_CATALOG = (0, import_sdk2.getPaymentMethodsCatalog)(BASE_CHAIN_ID, RUNTIME_ENV);
+var FALLBACK_CURRENCIES = {
+  venmo: ["USD"],
+  cashapp: ["USD"],
+  chime: ["USD"],
+  revolut: ["USD", "EUR", "GBP", "SGD", "NZD", "AUD", "CAD", "HKD", "MXN", "SAR", "AED", "THB", "TRY", "PLN", "CHF", "ZAR", "CZK", "CNY", "DKK", "HUF", "NOK", "RON", "SEK"],
+  wise: ["USD", "CNY", "EUR", "GBP", "AUD", "NZD", "CAD", "AED", "CHF", "ZAR", "SGD", "ILS", "HKD", "JPY", "PLN", "TRY", "IDR", "KES", "MYR", "MXN", "THB", "VND", "UGX", "CZK", "DKK", "HUF", "INR", "NOK", "PHP", "RON", "SEK"],
+  mercadopago: ["ARS"],
+  zelle: ["USD"],
+  paypal: ["USD", "EUR", "GBP", "SGD", "NZD", "AUD", "CAD"],
+  monzo: ["GBP"],
+  n26: ["EUR"]
+};
+function gatherCatalogHashes(platform) {
+  if (platform === "zelle") {
+    return Object.entries(PAYMENT_CATALOG).filter(([key]) => key.startsWith("zelle")).flatMap(([, entry]) => entry.currencies ?? []);
+  }
+  return PAYMENT_CATALOG[platform]?.currencies ?? [];
+}
+function resolveSupportedCurrencies(platform) {
+  const codes = /* @__PURE__ */ new Set();
+  for (const hash of gatherCatalogHashes(platform)) {
+    const info = (0, import_sdk2.getCurrencyInfoFromHash)(hash);
+    if (info?.currencyCode && import_sdk2.currencyInfo[info.currencyCode]) {
+      codes.add(info.currencyCode);
+    }
+  }
+  if (!codes.size) {
+    for (const code of FALLBACK_CURRENCIES[platform] ?? []) codes.add(code);
+  }
+  return Array.from(codes).sort();
+}
+var BLUEPRINT = {
+  venmo: {
+    id: "venmo",
+    name: "Venmo",
+    identifierLabel: "Username",
+    placeholder: "venmo username (no @)",
+    helperText: "Username without @ (publicly discoverable)",
+    validation: import_zod.z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
+    transform: (v) => v.replace(/^@+/, "")
+  },
+  cashapp: {
+    id: "cashapp",
+    name: "Cash App",
+    identifierLabel: "Cashtag",
+    placeholder: "cashtag (no $)",
+    helperText: "Cashtag without $ (publicly discoverable)",
+    validation: import_zod.z.string().min(1).regex(/^[a-zA-Z0-9]+$/),
+    transform: (v) => v.replace(/^\$+/, "")
+  },
+  chime: {
+    id: "chime",
+    name: "Chime",
+    identifierLabel: "ChimeSign",
+    placeholder: "$chimesign",
+    helperText: "ChimeSign with $ (must be discoverable)",
+    validation: import_zod.z.string().min(2).regex(/^\$[a-zA-Z0-9]+$/),
+    transform: (v) => {
+      const t = v.trim().toLowerCase();
+      return t.startsWith("$") ? t : `$${t}`;
+    }
+  },
+  revolut: {
+    id: "revolut",
+    name: "Revolut",
+    identifierLabel: "Revtag",
+    placeholder: "revtag (no @)",
+    helperText: "Revtag without @ (must be public)",
+    validation: import_zod.z.string().min(1).regex(/^[a-zA-Z0-9]+$/),
+    transform: (v) => v.replace(/^@+/, "").trim()
+  },
+  wise: {
+    id: "wise",
+    name: "Wise",
+    identifierLabel: "Wisetag",
+    placeholder: "wisetag (no @)",
+    helperText: "Your Wise @wisetag (no @)",
+    validation: import_zod.z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
+    transform: (v) => v.replace(/^@+/, "").trim()
+  },
+  mercadopago: {
+    id: "mercadopago",
+    name: "Mercado Pago",
+    identifierLabel: "CVU",
+    placeholder: "22-digit CVU",
+    helperText: "CVU must be exactly 22 digits",
+    validation: import_zod.z.string().length(22).regex(/^\d{22}$/)
+  },
+  zelle: {
+    id: "zelle",
+    name: "Zelle",
+    identifierLabel: "Email",
+    placeholder: "email",
+    helperText: "Registered Zelle email",
+    validation: import_zod.z.string().email()
+  },
+  paypal: {
+    id: "paypal",
+    name: "PayPal",
+    identifierLabel: "Email",
+    placeholder: "email",
+    helperText: "Email linked to PayPal account",
+    validation: import_zod.z.string().email()
+  },
+  monzo: {
+    id: "monzo",
+    name: "Monzo",
+    identifierLabel: "Username",
+    placeholder: "monzo.me username",
+    helperText: "Your Monzo.me username",
+    validation: import_zod.z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/)
+  },
+  n26: {
+    id: "n26",
+    name: "N26",
+    identifierLabel: "IBAN",
+    placeholder: "IBAN (e.g. DE89...)",
+    helperText: "Your IBAN (spaces will be removed)",
+    validation: import_zod.z.string().min(15).max(34).regex(/^[A-Z]{2}[0-9]{2}[A-Z0-9]+$/i),
+    transform: (v) => v.replace(/\s/g, "").toUpperCase()
+  }
+};
+var CONFIGS = Object.fromEntries(
+  Object.entries(BLUEPRINT).map(([p, bp]) => {
+    const key = p;
+    return [key, { ...bp, currencies: resolveSupportedCurrencies(key) }];
+  })
+);
+function getPlatformConfig(platform) {
+  return CONFIGS[platform];
+}
+function getPlatforms() {
+  return PLATFORMS.map((id) => {
+    const cfg = CONFIGS[id];
+    return {
+      id,
+      name: cfg.name,
+      currencies: cfg.currencies,
+      identifierLabel: cfg.identifierLabel,
+      identifierPlaceholder: cfg.placeholder,
+      helperText: cfg.helperText
+    };
+  });
+}
+function getCurrencies(platform) {
+  return CONFIGS[platform]?.currencies ?? [];
+}
+function validateIdentifier(platform, value) {
+  const cfg = CONFIGS[platform];
+  if (!cfg) return { valid: false, normalized: value, error: "Unsupported platform" };
+  const transformed = cfg.transform ? cfg.transform(value) : value;
+  const result = cfg.validation.safeParse(transformed);
+  if (!result.success) {
+    return { valid: false, normalized: transformed, error: result.error.issues[0]?.message || "Invalid input" };
+  }
+  return { valid: true, normalized: transformed };
+}
+function isSupportedCurrency(platform, currency) {
+  return CONFIGS[platform]?.currencies.includes(currency) ?? false;
+}
+function normalizePaymentMethodLookupName(platform) {
+  const normalized = platform.trim().toLowerCase();
+  if (!normalized) return null;
+  if (ZELLE_HASH_LOOKUP_NAMES.includes(normalized)) {
+    return normalized;
+  }
+  return PLATFORMS.includes(normalized) ? normalized : null;
+}
+function resolveCanonicalZelleHash() {
+  const direct = PAYMENT_CATALOG.zelle?.paymentMethodHash;
+  if (direct) return direct;
+  const variant = Object.entries(PAYMENT_CATALOG).find(
+    ([name, entry]) => name.startsWith("zelle") && Boolean(entry.paymentMethodHash)
+  );
+  return variant?.[1]?.paymentMethodHash ?? null;
+}
+function getPaymentMethodHash(platform) {
+  const name = normalizePaymentMethodLookupName(platform);
+  if (!name) return null;
+  const catalogEntry = PAYMENT_CATALOG[name];
+  if (catalogEntry?.paymentMethodHash) return catalogEntry.paymentMethodHash;
+  if (name === "zelle" || name.startsWith("zelle-")) return resolveCanonicalZelleHash();
+  const sdkHash = (0, import_sdk2.resolvePaymentMethodHash)(name);
+  return sdkHash ? sdkHash : null;
+}
+function getPaymentMethodHashes(platform) {
+  if (platform !== "zelle") {
+    const hash = getPaymentMethodHash(platform);
+    return hash ? [hash] : [];
+  }
+  const hashes = /* @__PURE__ */ new Set();
+  const generic = (0, import_sdk2.resolvePaymentMethodHash)("zelle");
+  if (generic) hashes.add(generic);
+  const canonical = resolveCanonicalZelleHash();
+  if (canonical) hashes.add(canonical);
+  for (const [name, entry] of Object.entries(PAYMENT_CATALOG)) {
+    if (name.startsWith("zelle") && entry.paymentMethodHash) {
+      hashes.add(entry.paymentMethodHash);
+    }
+  }
+  return Array.from(hashes);
+}
+function buildDepositData(platform, identifier) {
+  switch (platform) {
+    case "venmo":
+      return { venmoUsername: identifier, telegramUsername: "" };
+    case "cashapp":
+      return { cashtag: identifier, telegramUsername: "" };
+    case "chime":
+      return { chimesign: identifier.toLowerCase(), telegramUsername: "" };
+    case "revolut":
+      return { revolutUsername: identifier, telegramUsername: "" };
+    case "wise":
+      return { wisetag: identifier, telegramUsername: "" };
+    case "mercadopago":
+      return { cvu: identifier, telegramUsername: "" };
+    case "zelle":
+      return { zelleEmail: identifier, telegramUsername: "" };
+    case "paypal":
+      return { paypalEmail: identifier, telegramUsername: "" };
+    case "monzo":
+      return { monzoMeUsername: identifier, telegramUsername: "" };
+    case "n26":
+      return { iban: identifier, telegramUsername: "" };
+    default:
+      return { identifier, telegramUsername: "" };
+  }
+}
+
+// src/errors.ts
+var OfframpError = class extends Error {
+  code;
+  step;
+  cause;
+  txHash;
+  depositId;
+  constructor(message, code, step, cause, details) {
+    super(message);
+    this.name = "OfframpError";
+    this.code = code;
+    this.step = step;
+    this.cause = cause;
+    this.txHash = details?.txHash;
+    this.depositId = details?.depositId;
+  }
+};
+function isUserCancellation(error) {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  return msg.includes("user rejected") || msg.includes("user denied") || msg.includes("user cancelled") || msg.includes("rejected the request") || msg.includes("action_rejected");
+}
+
+// src/deposit.ts
+function usdcToUnits(amount) {
+  return (0, import_viem.parseUnits)(amount, 6);
+}
+var DEPOSIT_RECEIVED_ABI = [
+  {
+    type: "event",
+    name: "DepositReceived",
+    inputs: [
+      { indexed: true, name: "depositId", type: "uint256" },
+      { indexed: true, name: "depositor", type: "address" },
+      { indexed: true, name: "token", type: "address" },
+      { indexed: false, name: "amount", type: "uint256" },
+      { indexed: false, name: "intentAmountRange", type: "tuple", components: [
+        { name: "min", type: "uint256" },
+        { name: "max", type: "uint256" }
+      ] },
+      { indexed: false, name: "delegate", type: "address" },
+      { indexed: false, name: "intentGuardian", type: "address" }
+    ]
+  }
+];
+function extractDepositIdFromLogs(logs) {
+  for (const log of logs) {
+    if (!log?.topics?.length || !log.data) continue;
+    try {
+      const decoded = (0, import_viem.decodeEventLog)({
+        abi: DEPOSIT_RECEIVED_ABI,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName !== "DepositReceived") continue;
+      const args = decoded.args;
+      if (typeof args.depositId === "bigint") return args.depositId.toString();
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function registerPayeeDetails(processorName, depositData) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), PAYEE_REGISTRATION_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${API_BASE_URL}/v1/makers/create`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ processorName, depositData }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const txt = await res.text().catch(() => "");
+      throw new Error(`makers/create failed (${res.status}): ${txt || res.statusText}`);
+    }
+    const json = await res.json();
+    if (!json.success || !json.responseObject?.hashedOnchainId) {
+      throw new Error(json.message || "makers/create returned no hashedOnchainId");
+    }
+    return json.responseObject.hashedOnchainId;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function attachOracleConfig(entries, conversionRates) {
+  return entries.map(
+    (group, gi) => group.map((entry, ci) => {
+      const currency = conversionRates[gi]?.[ci]?.currency;
+      if (!currency) return entry;
+      const oracleConfig = (0, import_sdk3.getSpreadOracleConfig)(currency);
+      if (!oracleConfig) return entry;
+      return {
+        ...entry,
+        oracleRateConfig: {
+          adapter: oracleConfig.adapter,
+          adapterConfig: oracleConfig.adapterConfig,
+          spreadBps: 0,
+          maxStaleness: oracleConfig.maxStaleness
+        }
+      };
+    })
+  );
+}
+function createSdkClient(walletClient) {
+  return new import_sdk3.OfframpClient({
+    walletClient,
+    chainId: BASE_CHAIN_ID,
+    runtimeEnv: RUNTIME_ENV,
+    rpcUrl: BASE_RPC_URL,
+    baseApiUrl: API_BASE_URL
+  });
+}
+async function createOfframpDeposit(walletClient, params, onProgress) {
+  const { amount, platform, currency, identifier } = params;
+  const amt = parseFloat(amount);
+  if (!Number.isFinite(amt) || amt < MIN_DEPOSIT_USDC) {
+    throw new OfframpError(`Minimum deposit is ${MIN_DEPOSIT_USDC} USDC`, "VALIDATION");
+  }
+  if (!isSupportedCurrency(platform, currency)) {
+    throw new OfframpError(`${currency} is not supported on ${platform}`, "UNSUPPORTED");
+  }
+  const validation = validateIdentifier(platform, identifier);
+  if (!validation.valid) {
+    throw new OfframpError(validation.error || "Invalid identifier", "VALIDATION");
+  }
+  const normalizedIdentifier = validation.normalized;
+  const methodHash = getPaymentMethodHash(platform);
+  if (!methodHash) {
+    throw new OfframpError(`${platform} is not currently supported`, "UNSUPPORTED");
+  }
+  const amountUnits = usdcToUnits(amount);
+  const minUnits = usdcToUnits(String(MIN_ORDER_USDC));
+  const maxUnits = usdcToUnits(String(Math.min(amt, 2500)));
+  const client = createSdkClient(walletClient);
+  const txOverrides = { referrer: [REFERRER] };
+  onProgress?.({ step: "approving" });
+  try {
+    await client.ensureAllowance({
+      token: USDC_ADDRESS,
+      amount: amountUnits,
+      escrowAddress: ESCROW_ADDRESS,
+      maxApprove: false,
+      txOverrides
+    });
+  } catch (err) {
+    if (isUserCancellation(err)) throw new OfframpError("User cancelled", "USER_CANCELLED", "approving", err);
+    throw new OfframpError("USDC approval failed", "APPROVAL_FAILED", "approving", err);
+  }
+  onProgress?.({ step: "registering" });
+  let hashedOnchainId;
+  try {
+    const canonicalName = platform.startsWith("zelle") ? "zelle" : platform;
+    const depositData = buildDepositData(platform, normalizedIdentifier);
+    hashedOnchainId = await registerPayeeDetails(canonicalName, depositData);
+  } catch (err) {
+    throw new OfframpError("Payee registration failed", "REGISTRATION_FAILED", "registering", err);
+  }
+  onProgress?.({ step: "depositing" });
+  const conversionRates = [
+    [{ currency, conversionRate: "1" }]
+  ];
+  const baseCurrenciesOverride = (0, import_sdk3.mapConversionRatesToOnchainMinRate)(conversionRates, 1);
+  const currenciesOverride = attachOracleConfig(baseCurrenciesOverride, conversionRates);
+  let hash;
+  try {
+    const result = await client.createDeposit({
+      token: USDC_ADDRESS,
+      amount: amountUnits,
+      retainOnEmpty: false,
+      intentAmountRange: { min: minUnits, max: maxUnits },
+      processorNames: [platform],
+      depositData: [buildDepositData(platform, normalizedIdentifier)],
+      conversionRates,
+      paymentMethodsOverride: [methodHash],
+      paymentMethodDataOverride: [{
+        intentGatingService: GATING_SERVICE_ADDRESS,
+        payeeDetails: hashedOnchainId,
+        data: "0x"
+      }],
+      currenciesOverride,
+      escrowAddress: ESCROW_ADDRESS,
+      txOverrides
+    });
+    if (!result?.hash) throw new Error("No transaction hash returned");
+    hash = result.hash;
+  } catch (err) {
+    if (isUserCancellation(err)) throw new OfframpError("User cancelled", "USER_CANCELLED", "depositing", err);
+    throw new OfframpError("Deposit transaction failed", "DEPOSIT_FAILED", "depositing", err);
+  }
+  onProgress?.({ step: "confirming", txHash: hash });
+  let depositId = "";
+  const receiptClient = client;
+  if (typeof receiptClient.waitForTransactionReceipt === "function") {
+    try {
+      const receipt = await receiptClient.waitForTransactionReceipt({ hash, confirmations: 1 });
+      depositId = extractDepositIdFromLogs(receipt.logs) || "";
+    } catch {
+    }
+  }
+  if (!depositId) {
+    const walletAddress = walletClient.account?.address;
+    if (walletAddress) {
+      let delay = INDEXER_INITIAL_DELAY_MS;
+      for (let attempt = 0; attempt < INDEXER_MAX_ATTEMPTS && !depositId; attempt++) {
+        try {
+          const deposits = await client.indexer.getDepositsWithRelations(
+            { depositor: walletAddress },
+            { limit: 25 }
+          );
+          const hit = deposits.find((d) => (d?.txHash || "").toLowerCase() === hash.toLowerCase());
+          if (hit) {
+            depositId = String(hit.depositId);
+            break;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(INDEXER_MAX_DELAY_MS, Math.floor(delay * 1.7));
+      }
+    }
+  }
+  if (!depositId) {
+    throw new OfframpError(
+      "Deposit created on-chain but could not confirm deposit ID. Your funds are safe. Use the transaction hash to locate your deposit.",
+      "CONFIRMATION_FAILED",
+      "confirming",
+      void 0,
+      { txHash: hash }
+    );
+  }
+  onProgress?.({ step: "delegating", txHash: hash, depositId });
+  try {
+    await client.setRateManager({
+      depositId: BigInt(depositId),
+      rateManagerAddress: RATE_MANAGER_REGISTRY_ADDRESS,
+      rateManagerId: DELEGATE_RATE_MANAGER_ID,
+      escrowAddress: ESCROW_ADDRESS,
+      txOverrides
+    });
+  } catch (delegationError) {
+    if (isUserCancellation(delegationError)) {
+      throw new OfframpError("User cancelled delegation", "USER_CANCELLED", "delegating", delegationError, { txHash: hash, depositId });
+    }
+    throw new OfframpError(
+      "Deposit created but delegation failed. Visit usdctofiat.xyz to manage your deposit manually.",
+      "DELEGATION_FAILED",
+      "delegating",
+      delegationError,
+      { txHash: hash, depositId }
+    );
+  }
+  onProgress?.({ step: "done", txHash: hash, depositId });
+  return { depositId, txHash: hash };
+}
+
+// src/client.ts
+function toBigInt(value) {
+  try {
+    return BigInt(value || "0");
+  } catch {
+    return 0n;
+  }
+}
+function toUsdc(value) {
+  return Number((0, import_viem2.formatUnits)(toBigInt(value), 6));
+}
+function resolveStatus(deposit) {
+  if (deposit.status === "CLOSED") return "closed";
+  if (toBigInt(deposit.remainingDeposits) === 0n) return "empty";
+  return "active";
+}
+function resolveMethodNames(hashes) {
+  const names = /* @__PURE__ */ new Set();
+  for (const { paymentMethodHash } of hashes) {
+    const normalized = paymentMethodHash.toLowerCase();
+    for (const platform of ["venmo", "cashapp", "chime", "revolut", "wise", "mercadopago", "zelle", "paypal", "monzo", "n26"]) {
+      const platformHashes = getPaymentMethodHashes(platform);
+      if (platformHashes.some((h) => h.toLowerCase() === normalized)) {
+        names.add(getPlatformConfig(platform).name);
+        break;
+      }
+    }
+  }
+  return Array.from(names);
+}
+var Offramp = class {
+  /**
+   * Create an offramp deposit: approve USDC, register payee, create deposit,
+   * confirm on-chain, and delegate to the vault. All in one call.
+   */
+  async createDeposit(walletClient, params, onProgress) {
+    return createOfframpDeposit(walletClient, params, onProgress);
+  }
+  /**
+   * Fetch deposits for a wallet address. Returns active, empty, and closed deposits
+   * sorted by status (active first) then recency.
+   */
+  async getDeposits(walletAddress) {
+    const client = createSdkClient(
+      // Read-only client -- no wallet needed for indexer queries
+      { account: void 0, chain: void 0, transport: void 0 }
+    );
+    const raw = await client.indexer.getDepositsWithRelations(
+      { depositor: walletAddress },
+      { limit: 100 }
+    );
+    const statusOrder = { active: 0, empty: 1, closed: 2 };
+    return (raw || []).map((d) => {
+      const delegationState = (0, import_sdk4.classifyDelegationState)(
+        d.rateManagerId ?? void 0,
+        d.rateManagerAddress ?? void 0,
+        DELEGATE_RATE_MANAGER_ID,
+        RATE_MANAGER_REGISTRY_ADDRESS
+      );
+      return {
+        depositId: d.depositId,
+        compositeId: d.id,
+        status: resolveStatus(d),
+        remainingUsdc: toUsdc(d.remainingDeposits),
+        outstandingUsdc: toUsdc(d.outstandingIntentAmount),
+        totalTakenUsdc: toUsdc(d.totalAmountTaken),
+        fulfilledIntents: d.fulfilledIntents ?? 0,
+        paymentMethods: resolveMethodNames(d.paymentMethods),
+        currencies: d.currencies.map((c) => c.currencyCode),
+        rateSource: d.currencies[0]?.rateSource || "unknown",
+        delegated: delegationState === "delegated_here",
+        escrowAddress: d.escrowAddress
+      };
+    }).sort((a, b) => {
+      const diff = statusOrder[a.status] - statusOrder[b.status];
+      if (diff !== 0) return diff;
+      return Number(BigInt(b.depositId) - BigInt(a.depositId));
+    });
+  }
+  /**
+   * Withdraw and close a deposit, returning remaining USDC to the wallet.
+   */
+  async withdrawDeposit(walletClient, depositId, escrowAddress) {
+    const client = createSdkClient(walletClient);
+    const result = await client.withdrawDeposit({
+      depositId: BigInt(depositId),
+      escrowAddress: escrowAddress || ESCROW_ADDRESS,
+      txOverrides: { referrer: [REFERRER] }
+    });
+    return typeof result === "string" ? result : result.hash;
+  }
+  /** List available payment platforms and their supported currencies. */
+  getPlatforms() {
+    return getPlatforms();
+  }
+  /** Get supported currencies for a specific platform. */
+  getCurrencies(platform) {
+    return getCurrencies(platform);
+  }
+  /** Validate a payment identifier for a platform without creating a deposit. */
+  validateIdentifier(platform, identifier) {
+    return validateIdentifier(platform, identifier);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Offramp,
+  OfframpError
+});
+//# sourceMappingURL=index.cjs.map