@usdctofiat/offramp 1.1.3 → 1.3.0

package/dist/react.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/react.ts
@@ -37,13 +27,9 @@ module.exports = __toCommonJS(react_exports);
 // src/hooks/useOfframp.ts
 var import_react = require("react");
 
-// src/deposit.ts
-var import_viem3 = require("viem");
-var import_chains = require("viem/chains");
-var import_sdk4 = require("@zkp2p/sdk");
-
 // src/config.ts
 var import_sdk = require("@zkp2p/sdk");
+var SDK_VERSION = "1.2.0";
 var BASE_CHAIN_ID = 8453;
 var RUNTIME_ENV = "production";
 var API_BASE_URL = "https://api.zkp2p.xyz";
@@ -59,6 +45,7 @@ var GATING_SERVICE_ADDRESS = (0, import_sdk.getGatingServiceAddress)(
 );
 var DELEGATE_RATE_MANAGER_ID = "0x8666d6fb0f6797c56e95339fd7ca82fdd348b9db200e10a4c4aa0a0b879fc41c";
 var RATE_MANAGER_REGISTRY_ADDRESS = "0xeed7db23e724ac4590d6db6f78fda6db203535f3";
+var DELEGATE_MANAGER_FEE_BPS = 10;
 var REFERRER = "galleonlabs";
 var MIN_DEPOSIT_USDC = 1;
 var MIN_ORDER_USDC = 1;
@@ -67,10 +54,33 @@ var INDEXER_INITIAL_DELAY_MS = 1e3;
 var INDEXER_MAX_DELAY_MS = 1e4;
 var PAYEE_REGISTRATION_TIMEOUT_MS = 8e3;
 
-// src/platforms.ts
+// src/currencies.ts
 var import_sdk2 = require("@zkp2p/sdk");
+function buildCurrencies() {
+  const entries = {};
+  for (const [code, info] of Object.entries(
+    import_sdk2.currencyInfo
+  )) {
+    entries[code] = {
+      code: info.currencyCode ?? code,
+      name: info.currencyName ?? code,
+      symbol: info.currencySymbol ?? code,
+      countryCode: info.countryCode ?? ""
+    };
+  }
+  return entries;
+}
+var CURRENCIES = buildCurrencies();
+
+// src/deposit.ts
+var import_viem3 = require("viem");
+var import_chains3 = require("viem/chains");
+var import_sdk6 = require("@zkp2p/sdk");
+
+// src/platforms.ts
+var import_sdk3 = require("@zkp2p/sdk");
 var import_zod = require("zod");
-var PAYMENT_CATALOG = (0, import_sdk2.getPaymentMethodsCatalog)(BASE_CHAIN_ID, RUNTIME_ENV);
+var PAYMENT_CATALOG = (0, import_sdk3.getPaymentMethodsCatalog)(BASE_CHAIN_ID, RUNTIME_ENV);
 var ZELLE_HASH_LOOKUP_NAMES = ["zelle", "zelle-bofa", "zelle-chase", "zelle-citi"];
 var FALLBACK_CURRENCIES = {
   venmo: ["USD"],
@@ -149,8 +159,8 @@ function gatherCatalogHashes(platform) {
 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]) {
+    const info = (0, import_sdk3.getCurrencyInfoFromHash)(hash);
+    if (info?.currencyCode && import_sdk3.currencyInfo[info.currencyCode]) {
       codes.add(info.currencyCode);
     }
   }
@@ -310,7 +320,7 @@ function getPaymentMethodHash(platform) {
   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);
+  const sdkHash = (0, import_sdk3.resolvePaymentMethodHash)(name);
   return sdkHash ? sdkHash : null;
 }
 function getPaymentMethodHashes(platform) {
@@ -319,7 +329,7 @@ function getPaymentMethodHashes(platform) {
     return hash ? [hash] : [];
   }
   const hashes = /* @__PURE__ */ new Set();
-  const generic = (0, import_sdk2.resolvePaymentMethodHash)("zelle");
+  const generic = (0, import_sdk3.resolvePaymentMethodHash)("zelle");
   if (generic) hashes.add(generic);
   const canonical = resolveCanonicalZelleHash();
   if (canonical) hashes.add(canonical);
@@ -382,6 +392,7 @@ function isUserCancellation(error) {
 
 // src/otc.ts
 var import_viem = require("viem");
+var import_chains = require("viem/chains");
 
 // ../../node_modules/@zkp2p/contracts-v2/abis/base/WhitelistPreIntentHook.json
 var WhitelistPreIntentHook_default = [
@@ -726,6 +737,18 @@ var WhitelistPreIntentHook_default = [
   }
 ];
 
+// src/sdk-client.ts
+var import_sdk4 = require("@zkp2p/sdk");
+function createSdkClient(walletClient) {
+  return new import_sdk4.OfframpClient({
+    walletClient,
+    chainId: BASE_CHAIN_ID,
+    runtimeEnv: RUNTIME_ENV,
+    rpcUrl: BASE_RPC_URL,
+    baseApiUrl: API_BASE_URL
+  });
+}
+
 // src/otc.ts
 var WHITELIST_HOOK_ADDRESS = "0xda023Ea0d789A41BcF5866F7B6BBd2CaDF9b79B8";
 var OTC_BASE_URL = "https://usdctofiat.xyz";
@@ -743,12 +766,7 @@ async function enableOtc(walletClient, depositId, takerAddress, escrowAddress) {
       escrowAddress: escrow
     });
     if (currentHook !== import_viem.zeroAddress) {
-      const isAlready = await readIsWhitelisted(
-        walletClient,
-        escrow,
-        depositIdBig,
-        taker
-      );
+      const isAlready = await readIsWhitelisted(escrow, depositIdBig, taker);
       if (isAlready) {
         return {
           depositId,
@@ -798,13 +816,8 @@ async function writeContract(walletClient, functionName, args) {
     args
   });
 }
-async function readIsWhitelisted(walletClient, escrow, depositId, taker) {
-  const { createPublicClient: createPublicClient2, http: http2 } = await import("viem");
-  const { base: base2 } = await import("viem/chains");
-  const publicClient = createPublicClient2({
-    chain: base2,
-    transport: http2("https://mainnet.base.org")
-  });
+async function readIsWhitelisted(escrow, depositId, taker) {
+  const publicClient = (0, import_viem.createPublicClient)({ chain: import_chains.base, transport: (0, import_viem.http)(BASE_RPC_URL) });
   return publicClient.readContract({
     address: WHITELIST_HOOK_ADDRESS,
     abi: WhitelistPreIntentHook_default,
@@ -815,13 +828,14 @@ async function readIsWhitelisted(walletClient, escrow, depositId, taker) {
 
 // src/queries.ts
 var import_viem2 = require("viem");
-var import_sdk3 = require("@zkp2p/sdk");
+var import_chains2 = require("viem/chains");
+var import_sdk5 = require("@zkp2p/sdk");
 var indexerService = null;
 function getIndexerService() {
   if (!indexerService) {
-    const endpoint = (0, import_sdk3.defaultIndexerEndpoint)("PRODUCTION");
-    const client = new import_sdk3.IndexerClient(endpoint);
-    indexerService = new import_sdk3.IndexerDepositService(client);
+    const endpoint = (0, import_sdk5.defaultIndexerEndpoint)("PRODUCTION");
+    const client = new import_sdk5.IndexerClient(endpoint);
+    indexerService = new import_sdk5.IndexerDepositService(client);
   }
   return indexerService;
 }
@@ -855,7 +869,7 @@ function resolveMethodNames(hashes) {
   return Array.from(names);
 }
 function mapDeposit(d) {
-  const delegationState = (0, import_sdk3.classifyDelegationState)(
+  const delegationState = (0, import_sdk5.classifyDelegationState)(
     d.rateManagerId ?? void 0,
     d.rateManagerAddress ?? void 0,
     DELEGATE_RATE_MANAGER_ID,
@@ -872,7 +886,7 @@ function mapDeposit(d) {
     fulfilledIntents: d.fulfilledIntents ?? 0,
     paymentMethods: resolveMethodNames(d.paymentMethods),
     currencies: d.currencies.map((c) => {
-      const info = (0, import_sdk3.getCurrencyInfoFromHash)(c.currencyCode);
+      const info = (0, import_sdk5.getCurrencyInfoFromHash)(c.currencyCode);
       return info?.currencyCode ?? c.currencyCode;
     }),
     rateSource: d.currencies[0]?.rateSource || "unknown",
@@ -911,6 +925,105 @@ async function close(walletClient, depositId, escrowAddress) {
   return extractTxHash(result);
 }
 
+// src/telemetry.ts
+var SDK_EVENTS_ENDPOINT = "https://usdctofiat.xyz/api/sdk-events";
+var MAX_BATCH_SIZE = 50;
+var FLUSH_DELAY_MS = 180;
+var TELEMETRY_TIMEOUT_MS = 2e3;
+var queuedEvents = [];
+var flushTimer = null;
+var flushInFlight = false;
+function sanitizeAttributionId(raw) {
+  if (typeof raw !== "string") return void 0;
+  const stripped = raw.trim().replace(/[^a-zA-Z0-9_-]/g, "");
+  if (!stripped) return void 0;
+  if (stripped.length > 64) return void 0;
+  return stripped;
+}
+function scheduleFlush() {
+  if (flushTimer != null) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    void flushQueue();
+  }, FLUSH_DELAY_MS);
+}
+async function postBatch(batch) {
+  if (!batch.length) return;
+  const body = JSON.stringify(batch);
+  try {
+    if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+      const blob = new Blob([body], { type: "application/json" });
+      const accepted = navigator.sendBeacon(SDK_EVENTS_ENDPOINT, blob);
+      if (accepted) return;
+    }
+  } catch {
+  }
+  try {
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timeout = controller ? setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS) : null;
+    await fetch(SDK_EVENTS_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      keepalive: true,
+      signal: controller?.signal
+    }).catch(() => {
+    });
+    if (timeout) clearTimeout(timeout);
+  } catch {
+  }
+}
+async function flushQueue() {
+  if (flushInFlight) return;
+  if (!queuedEvents.length) return;
+  flushInFlight = true;
+  try {
+    while (queuedEvents.length > 0) {
+      const batch = queuedEvents.slice(0, MAX_BATCH_SIZE);
+      queuedEvents = queuedEvents.slice(batch.length);
+      await postBatch(batch);
+    }
+  } finally {
+    flushInFlight = false;
+  }
+}
+function emitEvent(name, payload) {
+  try {
+    queuedEvents.push({
+      name,
+      payload,
+      ts: Date.now()
+    });
+    if (queuedEvents.length >= MAX_BATCH_SIZE) {
+      void flushQueue();
+      return;
+    }
+    scheduleFlush();
+  } catch {
+  }
+}
+function createTelemetryContext(options) {
+  const integratorId = sanitizeAttributionId(options.integratorId);
+  const referralId = sanitizeAttributionId(options.referralId);
+  const enabled = options.telemetry !== false;
+  const sdkVersion = options.sdkVersion;
+  return {
+    enabled,
+    sdkVersion,
+    integratorId,
+    referralId,
+    emit(name, payload = {}) {
+      if (!enabled) return;
+      emitEvent(name, {
+        sdkVersion,
+        integratorId,
+        referralId,
+        ...payload
+      });
+    }
+  };
+}
+
 // src/deposit.ts
 function usdcToUnits(amount) {
   return (0, import_viem3.parseUnits)(amount, 6);
@@ -984,7 +1097,7 @@ function attachOracleConfig(entries, conversionRates) {
     (group, gi) => group.map((entry, ci) => {
       const currency = conversionRates[gi]?.[ci]?.currency;
       if (!currency) return entry;
-      const oracleConfig = (0, import_sdk4.getSpreadOracleConfig)(currency);
+      const oracleConfig = (0, import_sdk6.getSpreadOracleConfig)(currency);
       if (!oracleConfig) return entry;
       return {
         ...entry,
@@ -1006,15 +1119,6 @@ function extractTxHash2(result) {
     return result.transactionHash;
   throw new Error("Unexpected transaction result format");
 }
-function createSdkClient(walletClient) {
-  return new import_sdk4.OfframpClient({
-    walletClient,
-    chainId: BASE_CHAIN_ID,
-    runtimeEnv: RUNTIME_ENV,
-    rpcUrl: BASE_RPC_URL,
-    baseApiUrl: API_BASE_URL
-  });
-}
 async function findUndelegatedDeposit(walletAddress) {
   try {
     const service = getIndexerService();
@@ -1023,6 +1127,7 @@ async function findUndelegatedDeposit(walletAddress) {
       { limit: 50 }
     );
     const escrowLower = ESCROW_ADDRESS.toLowerCase();
+    const delegateIdLower = DELEGATE_RATE_MANAGER_ID.toLowerCase();
     const undelegated = (raw || []).filter((d) => {
       if (d.status === "CLOSED") return false;
       if (d.escrowAddress.toLowerCase() !== escrowLower) return false;
@@ -1034,273 +1139,493 @@ async function findUndelegatedDeposit(walletAddress) {
         }
       })();
       if (remaining === 0n) return false;
-      return d.rateManagerId !== DELEGATE_RATE_MANAGER_ID;
+      return (d.rateManagerId ?? "").toLowerCase() !== delegateIdLower;
+    });
+    undelegated.sort((a, b) => {
+      const left = BigInt(a.depositId);
+      const right = BigInt(b.depositId);
+      if (left === right) return 0;
+      return left > right ? -1 : 1;
     });
-    undelegated.sort((a, b) => Number(BigInt(b.depositId) - BigInt(a.depositId)));
     return undelegated[0] ?? null;
   } catch {
     return null;
   }
 }
-async function offramp(walletClient, params, onProgress) {
+async function offramp(walletClient, params, onProgress, telemetryContext) {
   const { amount, platform, currency, identifier } = params;
   const platformId = platform.id;
   const currencyCode = currency.code;
-  if (!walletClient.account?.address) {
-    throw new OfframpError("Wallet client has no account. Connect a wallet first.", "VALIDATION");
-  }
-  const walletAddress = walletClient.account.address;
-  const amt = parseFloat(amount);
-  if (!Number.isFinite(amt) || amt < MIN_DEPOSIT_USDC) {
-    throw new OfframpError(`Minimum deposit is ${MIN_DEPOSIT_USDC} USDC`, "VALIDATION");
-  }
-  if (!platform.currencies.includes(currencyCode)) {
-    throw new OfframpError(`${currencyCode} is not supported on ${platform.name}`, "UNSUPPORTED");
-  }
-  const validation = platform.validate(identifier);
-  if (!validation.valid) {
-    throw new OfframpError(validation.error || "Invalid identifier", "VALIDATION");
-  }
-  const normalizedIdentifier = validation.normalized;
-  const methodHash = getPaymentMethodHash(platformId);
-  if (!methodHash) {
-    throw new OfframpError(`${platform.name} is not currently supported`, "UNSUPPORTED");
-  }
-  const existing = await findUndelegatedDeposit(walletAddress);
-  if (existing) {
-    onProgress?.({ step: "resuming", depositId: existing.depositId });
-    const client2 = createSdkClient(walletClient);
-    const txOverrides2 = { referrer: [REFERRER] };
+  const telemetry = telemetryContext ?? createTelemetryContext({
+    sdkVersion: SDK_VERSION,
+    telemetry: true,
+    integratorId: params.integratorId,
+    referralId: params.referralId
+  });
+  const flowStartMs = Date.now();
+  const emitProgress = (progress) => {
+    onProgress?.(progress);
+    telemetry.emit("sdk.createDeposit.progress", {
+      step: progress.step,
+      txHash: progress.txHash
+    });
+  };
+  try {
+    if (!walletClient.account?.address) {
+      throw new OfframpError("Wallet client has no account. Connect a wallet first.", "VALIDATION");
+    }
+    const walletAddress = walletClient.account.address.toLowerCase();
+    telemetry.emit("sdk.createDeposit.start", {
+      platform: platformId,
+      currency: currencyCode,
+      amount,
+      wallet: walletAddress
+    });
+    const amt = parseFloat(amount);
+    if (!Number.isFinite(amt) || amt < MIN_DEPOSIT_USDC) {
+      throw new OfframpError(`Minimum deposit is ${MIN_DEPOSIT_USDC} USDC`, "VALIDATION");
+    }
+    if (!platform.currencies.includes(currencyCode)) {
+      throw new OfframpError(`${currencyCode} is not supported on ${platform.name}`, "UNSUPPORTED");
+    }
+    const validation = platform.validate(identifier);
+    if (!validation.valid) {
+      throw new OfframpError(validation.error || "Invalid identifier", "VALIDATION");
+    }
+    const normalizedIdentifier = validation.normalized;
+    const methodHash = getPaymentMethodHash(platformId);
+    if (!methodHash) {
+      throw new OfframpError(`${platform.name} is not currently supported`, "UNSUPPORTED");
+    }
+    const existing = await findUndelegatedDeposit(walletAddress);
+    if (existing) {
+      emitProgress({ step: "resuming", depositId: existing.depositId });
+      const client2 = createSdkClient(walletClient);
+      const txOverrides2 = { referrer: [REFERRER] };
+      try {
+        const result2 = await client2.setRateManager({
+          depositId: BigInt(existing.depositId),
+          rateManagerAddress: RATE_MANAGER_REGISTRY_ADDRESS,
+          rateManagerId: DELEGATE_RATE_MANAGER_ID,
+          escrowAddress: existing.escrowAddress,
+          txOverrides: txOverrides2
+        });
+        const txHash = extractTxHash2(result2);
+        emitProgress({ step: "done", txHash, depositId: existing.depositId });
+        const resumedResult = { depositId: existing.depositId, txHash, resumed: true };
+        telemetry.emit("sdk.createDeposit.success", {
+          depositId: resumedResult.depositId,
+          txHash: resumedResult.txHash,
+          wallet: walletAddress,
+          resumed: true,
+          wallDurationMs: Date.now() - flowStartMs
+        });
+        return resumedResult;
+      } catch (err) {
+        if (isUserCancellation(err))
+          throw new OfframpError("User cancelled", "USER_CANCELLED", "resuming", err);
+        throw new OfframpError(
+          "Found undelegated deposit but delegation failed. Try again.",
+          "DELEGATION_FAILED",
+          "resuming",
+          err,
+          { depositId: existing.depositId, txHash: existing.txHash }
+        );
+      }
+    }
+    const truncatedAmount = amt.toFixed(6).replace(/\.?0+$/, "");
+    const amountUnits = usdcToUnits(truncatedAmount);
+    const minUnits = usdcToUnits(String(MIN_ORDER_USDC));
+    const maxUnits = usdcToUnits(String(Math.min(amt, 2500)));
     try {
-      const result = await client2.setRateManager({
-        depositId: BigInt(existing.depositId),
-        rateManagerAddress: RATE_MANAGER_REGISTRY_ADDRESS,
-        rateManagerId: DELEGATE_RATE_MANAGER_ID,
-        escrowAddress: existing.escrowAddress,
-        txOverrides: txOverrides2
+      const publicClient = (0, import_viem3.createPublicClient)({ chain: import_chains3.base, transport: (0, import_viem3.http)(BASE_RPC_URL) });
+      const balance = await publicClient.readContract({
+        address: USDC_ADDRESS,
+        abi: [
+          {
+            name: "balanceOf",
+            type: "function",
+            stateMutability: "view",
+            inputs: [{ name: "account", type: "address" }],
+            outputs: [{ name: "", type: "uint256" }]
+          }
+        ],
+        functionName: "balanceOf",
+        args: [walletAddress]
+      });
+      if (balance < amountUnits) {
+        const available = Number((0, import_viem3.formatUnits)(balance, 6));
+        throw new OfframpError(
+          `Insufficient USDC balance. Have ${available.toFixed(2)}, need ${truncatedAmount}.`,
+          "VALIDATION"
+        );
+      }
+    } catch (err) {
+      if (err instanceof OfframpError) throw err;
+    }
+    const client = createSdkClient(walletClient);
+    const txOverrides = { referrer: [REFERRER] };
+    emitProgress({ step: "approving" });
+    try {
+      await client.ensureAllowance({
+        token: USDC_ADDRESS,
+        amount: amountUnits,
+        escrowAddress: ESCROW_ADDRESS,
+        maxApprove: false,
+        txOverrides
       });
-      const txHash = extractTxHash2(result);
-      onProgress?.({ step: "done", txHash, depositId: existing.depositId });
-      return { depositId: existing.depositId, txHash, resumed: true };
     } catch (err) {
       if (isUserCancellation(err))
-        throw new OfframpError("User cancelled", "USER_CANCELLED", "resuming", err);
+        throw new OfframpError("User cancelled", "USER_CANCELLED", "approving", err);
+      const detail = err instanceof Error ? err.message : String(err);
       throw new OfframpError(
-        "Found undelegated deposit but delegation failed. Try again.",
-        "DELEGATION_FAILED",
-        "resuming",
-        err,
-        { depositId: existing.depositId, txHash: existing.txHash }
+        `USDC approval failed: ${detail}`,
+        "APPROVAL_FAILED",
+        "approving",
+        err
       );
     }
-  }
-  const truncatedAmount = amt.toFixed(6).replace(/\.?0+$/, "");
-  const amountUnits = usdcToUnits(truncatedAmount);
-  const minUnits = usdcToUnits(String(MIN_ORDER_USDC));
-  const maxUnits = usdcToUnits(String(Math.min(amt, 2500)));
-  try {
-    const publicClient = (0, import_viem3.createPublicClient)({ chain: import_chains.base, transport: (0, import_viem3.http)(BASE_RPC_URL) });
-    const balance = await publicClient.readContract({
-      address: USDC_ADDRESS,
-      abi: [
-        {
-          name: "balanceOf",
-          type: "function",
-          stateMutability: "view",
-          inputs: [{ name: "account", type: "address" }],
-          outputs: [{ name: "", type: "uint256" }]
-        }
-      ],
-      functionName: "balanceOf",
-      args: [walletAddress]
-    });
-    if (balance < amountUnits) {
-      const available = Number((0, import_viem3.formatUnits)(balance, 6));
+    emitProgress({ step: "registering" });
+    let hashedOnchainId;
+    try {
+      const canonicalName = platformId.startsWith("zelle") ? "zelle" : platformId;
+      const depositData = buildDepositData(platformId, normalizedIdentifier);
+      hashedOnchainId = await registerPayeeDetails(canonicalName, depositData);
+    } catch (err) {
       throw new OfframpError(
-        `Insufficient USDC balance. Have ${available.toFixed(2)}, need ${truncatedAmount}.`,
-        "VALIDATION"
+        "Payee registration failed",
+        "REGISTRATION_FAILED",
+        "registering",
+        err
       );
     }
-  } catch (err) {
-    if (err instanceof OfframpError) throw err;
-  }
-  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);
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new OfframpError(`USDC approval failed: ${detail}`, "APPROVAL_FAILED", "approving", err);
-  }
-  onProgress?.({ step: "registering" });
-  let hashedOnchainId;
-  try {
-    const canonicalName = platformId.startsWith("zelle") ? "zelle" : platformId;
-    const depositData = buildDepositData(platformId, normalizedIdentifier);
-    hashedOnchainId = await registerPayeeDetails(canonicalName, depositData);
-  } catch (err) {
-    throw new OfframpError("Payee registration failed", "REGISTRATION_FAILED", "registering", err);
-  }
-  onProgress?.({ step: "depositing" });
-  const conversionRates = [
-    [{ currency: currencyCode, conversionRate: "1" }]
-  ];
-  const baseCurrenciesOverride = (0, import_sdk4.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: [platformId],
-      conversionRates,
-      payeeDetailsHashes: [hashedOnchainId],
-      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);
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new OfframpError(
-      `Deposit transaction failed: ${detail}`,
-      "DEPOSIT_FAILED",
-      "depositing",
-      err
-    );
-  }
-  onProgress?.({ step: "confirming", txHash: hash });
-  let depositId = "";
-  const receiptClient = client;
-  if (typeof receiptClient.waitForTransactionReceipt === "function") {
+    emitProgress({ step: "depositing" });
+    const conversionRates = [
+      [{ currency: currencyCode, conversionRate: "1" }]
+    ];
+    const baseCurrenciesOverride = (0, import_sdk6.mapConversionRatesToOnchainMinRate)(conversionRates, 1);
+    const currenciesOverride = attachOracleConfig(baseCurrenciesOverride, conversionRates);
+    let hash;
     try {
-      const receipt = await receiptClient.waitForTransactionReceipt({ hash, confirmations: 1 });
-      depositId = extractDepositIdFromLogs(receipt.logs) || "";
-    } catch {
+      const result2 = await client.createDeposit({
+        token: USDC_ADDRESS,
+        amount: amountUnits,
+        retainOnEmpty: false,
+        intentAmountRange: { min: minUnits, max: maxUnits },
+        processorNames: [platformId],
+        conversionRates,
+        payeeDetailsHashes: [hashedOnchainId],
+        paymentMethodsOverride: [methodHash],
+        paymentMethodDataOverride: [
+          {
+            intentGatingService: GATING_SERVICE_ADDRESS,
+            payeeDetails: hashedOnchainId,
+            data: "0x"
+          }
+        ],
+        currenciesOverride,
+        escrowAddress: ESCROW_ADDRESS,
+        txOverrides
+      });
+      if (!result2?.hash) throw new Error("No transaction hash returned");
+      hash = result2.hash;
+    } catch (err) {
+      if (isUserCancellation(err))
+        throw new OfframpError("User cancelled", "USER_CANCELLED", "depositing", err);
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new OfframpError(
+        `Deposit transaction failed: ${detail}`,
+        "DEPOSIT_FAILED",
+        "depositing",
+        err
+      );
     }
-  }
-  if (!depositId) {
-    let delay = INDEXER_INITIAL_DELAY_MS;
-    for (let attempt = 0; attempt < INDEXER_MAX_ATTEMPTS && !depositId; attempt++) {
+    emitProgress({ step: "confirming", txHash: hash });
+    let depositId = "";
+    const receiptClient = client;
+    if (typeof receiptClient.waitForTransactionReceipt === "function") {
       try {
-        const deps = await client.indexer.getDepositsWithRelations(
-          { depositor: walletAddress },
-          { limit: 25 }
-        );
-        const hit = deps.find((d) => (d?.txHash || "").toLowerCase() === hash.toLowerCase());
-        if (hit) {
-          depositId = String(hit.depositId);
-          break;
-        }
+        const receipt = await receiptClient.waitForTransactionReceipt({ hash, confirmations: 1 });
+        depositId = extractDepositIdFromLogs(receipt.logs) || "";
       } 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. Call offramp() again to resume delegation.",
-      "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)) {
+    if (!depositId) {
+      let delay = INDEXER_INITIAL_DELAY_MS;
+      for (let attempt = 0; attempt < INDEXER_MAX_ATTEMPTS && !depositId; attempt++) {
+        try {
+          const deps = await client.indexer.getDepositsWithRelations(
+            { depositor: walletAddress },
+            { limit: 25 }
+          );
+          const hit = deps.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(
-        "User cancelled delegation",
-        "USER_CANCELLED",
+        "Deposit created on-chain but could not confirm deposit ID. Your funds are safe. Call offramp() again to resume delegation.",
+        "CONFIRMATION_FAILED",
+        "confirming",
+        void 0,
+        { txHash: hash }
+      );
+    }
+    emitProgress({ 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. Call offramp() again to resume delegation.",
+        "DELEGATION_FAILED",
         "delegating",
         delegationError,
         { txHash: hash, depositId }
       );
     }
-    throw new OfframpError(
-      "Deposit created but delegation failed. Call offramp() again to resume delegation.",
-      "DELEGATION_FAILED",
-      "delegating",
-      delegationError,
-      { txHash: hash, depositId }
-    );
-  }
-  let otcLink;
-  if (params.otcTaker) {
-    onProgress?.({ step: "restricting", txHash: hash, depositId });
-    try {
-      const otcResult = await enableOtc(walletClient, depositId, params.otcTaker);
-      otcLink = otcResult.otcLink;
-    } catch (otcError) {
-      if (isUserCancellation(otcError)) {
+    let otcLink;
+    if (params.otcTaker) {
+      emitProgress({ step: "restricting", txHash: hash, depositId });
+      try {
+        const otcResult = await enableOtc(walletClient, depositId, params.otcTaker);
+        otcLink = otcResult.otcLink;
+      } catch (otcError) {
+        if (isUserCancellation(otcError)) {
+          throw new OfframpError(
+            "User cancelled OTC restriction",
+            "USER_CANCELLED",
+            "restricting",
+            otcError,
+            {
+              txHash: hash,
+              depositId
+            }
+          );
+        }
         throw new OfframpError(
-          "User cancelled OTC restriction",
-          "USER_CANCELLED",
+          "Deposit created and delegated but OTC restriction failed. Use enableOtc() to retry.",
+          "DEPOSIT_FAILED",
           "restricting",
           otcError,
-          {
-            txHash: hash,
-            depositId
-          }
+          { txHash: hash, depositId }
         );
       }
+    }
+    emitProgress({ step: "done", txHash: hash, depositId });
+    const result = { depositId, txHash: hash, resumed: false, otcLink };
+    telemetry.emit("sdk.createDeposit.success", {
+      depositId: result.depositId,
+      txHash: result.txHash,
+      wallet: walletAddress,
+      resumed: false,
+      wallDurationMs: Date.now() - flowStartMs
+    });
+    return result;
+  } catch (error) {
+    const known = error instanceof OfframpError ? error : null;
+    telemetry.emit("sdk.createDeposit.error", {
+      code: known?.code ?? "DEPOSIT_FAILED",
+      step: known?.step ?? "unknown"
+    });
+    throw error;
+  }
+}
+
+// src/offramp.ts
+var IDEMPOTENCY_TTL_MS = 10 * 60 * 1e3;
+var IDEMPOTENCY_STORAGE_PREFIX = "offramp:idempotency:";
+function getWalletAddress(walletClient) {
+  const address = walletClient.account?.address;
+  if (!address) {
+    throw new OfframpError("Wallet client has no account. Connect a wallet first.", "VALIDATION");
+  }
+  return address.toLowerCase();
+}
+function getIdempotencyStorageKey(walletAddress, idempotencyKey) {
+  return `${IDEMPOTENCY_STORAGE_PREFIX}${walletAddress}:${idempotencyKey}`;
+}
+function readIdempotencyResult(storageKey) {
+  if (typeof sessionStorage === "undefined") return null;
+  try {
+    const raw = sessionStorage.getItem(storageKey);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    const expiresAt = typeof parsed.expiresAt === "number" && Number.isFinite(parsed.expiresAt) ? parsed.expiresAt : 0;
+    if (expiresAt <= Date.now()) {
+      sessionStorage.removeItem(storageKey);
+      return null;
+    }
+    const result = parsed.result;
+    if (!result?.depositId || !result.txHash) {
+      sessionStorage.removeItem(storageKey);
+      return null;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function writeIdempotencyResult(storageKey, result) {
+  if (typeof sessionStorage === "undefined") return;
+  try {
+    const record = {
+      result,
+      expiresAt: Date.now() + IDEMPOTENCY_TTL_MS
+    };
+    sessionStorage.setItem(storageKey, JSON.stringify(record));
+  } catch {
+  }
+}
+function createPerFlowTelemetry(base4, integratorId, referralId) {
+  return createTelemetryContext({
+    sdkVersion: base4.sdkVersion,
+    telemetry: base4.enabled,
+    integratorId: sanitizeAttributionId(integratorId) ?? base4.integratorId,
+    referralId: sanitizeAttributionId(referralId) ?? base4.referralId
+  });
+}
+function normalizeCurrencyEntry(code) {
+  const fromCatalog = CURRENCIES[code];
+  if (fromCatalog) return fromCatalog;
+  return {
+    code,
+    name: code,
+    symbol: code,
+    countryCode: ""
+  };
+}
+function buildCurrencyGroups() {
+  const grouped = {};
+  for (const platform of Object.values(PLATFORMS)) {
+    grouped[platform.id] = platform.currencies.map(normalizeCurrencyEntry);
+  }
+  return grouped;
+}
+var Offramp = class {
+  walletClient;
+  telemetry;
+  constructor(options) {
+    this.walletClient = options.walletClient;
+    this.telemetry = createTelemetryContext({
+      sdkVersion: SDK_VERSION,
+      telemetry: options.telemetry,
+      integratorId: options.integratorId,
+      referralId: options.referralId
+    });
+    this.telemetry.emit("sdk.init", {
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown"
+    });
+  }
+  async createDeposit(params, onProgress) {
+    const flowTelemetry = createPerFlowTelemetry(
+      this.telemetry,
+      params.integratorId,
+      params.referralId
+    );
+    const sanitizedParams = {
+      ...params,
+      integratorId: flowTelemetry.integratorId,
+      referralId: flowTelemetry.referralId
+    };
+    const sanitizedKey = sanitizeAttributionId(params.idempotencyKey);
+    const walletAddress = sanitizedKey ? getWalletAddress(this.walletClient) : null;
+    const storageKey = walletAddress && sanitizedKey ? getIdempotencyStorageKey(walletAddress, sanitizedKey) : null;
+    if (storageKey) {
+      const existing = readIdempotencyResult(storageKey);
+      if (existing) return existing;
+    }
+    const result = await offramp(
+      this.walletClient,
+      sanitizedParams,
+      onProgress,
+      flowTelemetry
+    );
+    if (storageKey) {
+      writeIdempotencyResult(storageKey, result);
+    }
+    return result;
+  }
+  getQuote(input) {
+    const amountUsdc = Number(input.amount);
+    if (!Number.isFinite(amountUsdc) || amountUsdc <= 0) {
+      throw new OfframpError("Amount must be a positive number", "VALIDATION");
+    }
+    if (!input.platform.currencies.includes(input.currency.code)) {
       throw new OfframpError(
-        "Deposit created and delegated but OTC restriction failed. Use enableOtc() to retry.",
-        "DEPOSIT_FAILED",
-        "restricting",
-        otcError,
-        { txHash: hash, depositId }
+        `${input.currency.code} is not supported on ${input.platform.name}`,
+        "UNSUPPORTED"
       );
     }
+    const vaultSpreadBps = 0;
+    const spreadFactor = Math.max(0, 1 - vaultSpreadBps / 1e4);
+    const expectedFiat = amountUsdc * spreadFactor;
+    const effectiveRate = amountUsdc === 0 ? 0 : expectedFiat / amountUsdc;
+    return {
+      amountUsdc,
+      expectedFiat,
+      effectiveRate,
+      vaultSpreadBps
+    };
+  }
+  getVaultStatus() {
+    return {
+      rateManagerId: DELEGATE_RATE_MANAGER_ID,
+      rateManagerAddress: RATE_MANAGER_REGISTRY_ADDRESS,
+      feeRateBps: DELEGATE_MANAGER_FEE_BPS,
+      escrow: ESCROW_ADDRESS,
+      isActive: true
+    };
+  }
+  listCurrencies() {
+    return buildCurrencyGroups();
   }
-  onProgress?.({ step: "done", txHash: hash, depositId });
-  return { depositId, txHash: hash, resumed: false, otcLink };
+};
+function createOfframp(options) {
+  return new Offramp(options);
 }
 
 // src/hooks/useOfframp.ts
-function useOfframp() {
+function mapStepToState(step) {
+  if (step === "resuming" || step === "restricting") return "delegating";
+  if (step === "done") return "done";
+  return step;
+}
+function useOfframp(defaultOptions = {}) {
+  const [state, setState] = (0, import_react.useState)("idle");
   const [step, setStep] = (0, import_react.useState)(null);
   const [txHash, setTxHash] = (0, import_react.useState)(null);
   const [depositId, setDepositId] = (0, import_react.useState)(null);
-  const [error, setError] = (0, import_react.useState)(null);
+  const [lastError, setLastError] = (0, import_react.useState)(null);
   const [isLoading, setIsLoading] = (0, import_react.useState)(false);
   const lockRef = (0, import_react.useRef)(false);
   const reset = (0, import_react.useCallback)(() => {
+    setState("idle");
     setStep(null);
     setTxHash(null);
     setDepositId(null);
-    setError(null);
+    setLastError(null);
     setIsLoading(false);
     lockRef.current = false;
   }, []);
@@ -1309,16 +1634,25 @@ function useOfframp() {
       if (lockRef.current) throw new OfframpError("Deposit already in progress", "VALIDATION");
       lockRef.current = true;
       setIsLoading(true);
-      setError(null);
+      setState("idle");
+      setLastError(null);
       setStep(null);
       setTxHash(null);
       setDepositId(null);
       try {
-        const result = await offramp(walletClient, params, (progress) => {
+        const sdk = createOfframp({
+          walletClient,
+          integratorId: params.integratorId ?? defaultOptions.integratorId,
+          referralId: params.referralId ?? defaultOptions.referralId,
+          telemetry: defaultOptions.telemetry
+        });
+        const result = await sdk.createDeposit(params, (progress) => {
           setStep(progress.step);
+          setState(mapStepToState(progress.step));
           if (progress.txHash) setTxHash(progress.txHash);
           if (progress.depositId) setDepositId(progress.depositId);
         });
+        setState("done");
         setDepositId(result.depositId);
         setTxHash(result.txHash);
         return result;
@@ -1327,20 +1661,23 @@ function useOfframp() {
           err instanceof Error ? err.message : "Offramp failed",
           "DEPOSIT_FAILED"
         );
-        setError(offrampError);
-        throw err;
+        setLastError(offrampError);
+        setState("error");
+        throw offrampError;
       } finally {
         setIsLoading(false);
         lockRef.current = false;
       }
     },
-    []
+    [defaultOptions.integratorId, defaultOptions.referralId, defaultOptions.telemetry]
   );
   return {
+    state,
     step,
     txHash,
     depositId,
-    error,
+    lastError,
+    error: lastError,
     isLoading,
     offramp: offramp2,
     deposits,