@usdctofiat/offramp 1.1.3 → 1.3.0

package/dist/{chunk-QELK2M73.js → chunk-JQBKGGI2.js}

@@ -1,14 +1,6 @@
-// src/platforms.ts
-import {
-  currencyInfo,
-  getCurrencyInfoFromHash,
-  getPaymentMethodsCatalog,
-  resolvePaymentMethodHash
-} from "@zkp2p/sdk";
-import { z } from "zod";
-
 // src/config.ts
 import { getContracts, getGatingServiceAddress } from "@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";
@@ -24,6 +16,7 @@ var GATING_SERVICE_ADDRESS = 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;
@@ -33,6 +26,13 @@ var INDEXER_MAX_DELAY_MS = 1e4;
 var PAYEE_REGISTRATION_TIMEOUT_MS = 8e3;
 
 // src/platforms.ts
+import {
+  currencyInfo,
+  getCurrencyInfoFromHash,
+  getPaymentMethodsCatalog,
+  resolvePaymentMethodHash
+} from "@zkp2p/sdk";
+import { z } from "zod";
 var PAYMENT_CATALOG = getPaymentMethodsCatalog(BASE_CHAIN_ID, RUNTIME_ENV);
 var ZELLE_HASH_LOOKUP_NAMES = ["zelle", "zelle-bofa", "zelle-chase", "zelle-citi"];
 var FALLBACK_CURRENCIES = {
@@ -344,7 +344,8 @@ function isUserCancellation(error) {
 }
 
 // src/otc.ts
-import { isAddress, zeroAddress } from "viem";
+import { createPublicClient, http, isAddress, zeroAddress } from "viem";
+import { base } from "viem/chains";
 
 // ../../node_modules/@zkp2p/contracts-v2/abis/base/WhitelistPreIntentHook.json
 var WhitelistPreIntentHook_default = [
@@ -689,20 +690,123 @@ var WhitelistPreIntentHook_default = [
   }
 ];
 
-// src/deposit.ts
-import { createPublicClient, decodeEventLog, formatUnits as formatUnits2, http, parseUnits } from "viem";
-import { base } from "viem/chains";
-import {
-  OfframpClient,
-  getSpreadOracleConfig,
-  mapConversionRatesToOnchainMinRate
-} from "@zkp2p/sdk";
+// src/sdk-client.ts
+import { OfframpClient } from "@zkp2p/sdk";
+function createSdkClient(walletClient) {
+  return new 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";
+async function enableOtc(walletClient, depositId, takerAddress, escrowAddress) {
+  if (!isAddress(takerAddress)) {
+    throw new OfframpError("Invalid taker address", "VALIDATION");
+  }
+  const escrow = escrowAddress || ESCROW_ADDRESS;
+  const taker = takerAddress;
+  const depositIdBig = BigInt(depositId);
+  const client = createSdkClient(walletClient);
+  const txOverrides = { referrer: [REFERRER] };
+  try {
+    const currentHook = await client.getDepositWhitelistHook(depositIdBig, {
+      escrowAddress: escrow
+    });
+    if (currentHook !== zeroAddress) {
+      const isAlready = await readIsWhitelisted(escrow, depositIdBig, taker);
+      if (isAlready) {
+        return {
+          depositId,
+          takerAddress: taker,
+          otcLink: getOtcLink(depositId, escrow)
+        };
+      }
+    }
+    await writeContract(walletClient, "addToWhitelist", [escrow, depositIdBig, [taker]]);
+    if (currentHook === zeroAddress) {
+      await client.setDepositWhitelistHook({
+        depositId: depositIdBig,
+        whitelistHook: WHITELIST_HOOK_ADDRESS,
+        escrowAddress: escrow,
+        txOverrides
+      });
+    }
+    return {
+      depositId,
+      takerAddress: taker,
+      otcLink: getOtcLink(depositId, escrow)
+    };
+  } catch (err) {
+    if (err instanceof OfframpError) throw err;
+    if (isUserCancellation(err)) {
+      throw new OfframpError("User cancelled", "USER_CANCELLED", void 0, err, { depositId });
+    }
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new OfframpError(`Failed to enable OTC: ${detail}`, "DEPOSIT_FAILED", void 0, err, {
+      depositId
+    });
+  }
+}
+async function disableOtc(walletClient, depositId, escrowAddress) {
+  const escrow = escrowAddress || ESCROW_ADDRESS;
+  const client = createSdkClient(walletClient);
+  const txOverrides = { referrer: [REFERRER] };
+  try {
+    await client.setDepositWhitelistHook({
+      depositId: BigInt(depositId),
+      whitelistHook: zeroAddress,
+      escrowAddress: escrow,
+      txOverrides
+    });
+  } catch (err) {
+    if (isUserCancellation(err)) {
+      throw new OfframpError("User cancelled", "USER_CANCELLED", void 0, err, { depositId });
+    }
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new OfframpError(`Failed to disable OTC: ${detail}`, "DEPOSIT_FAILED", void 0, err, {
+      depositId
+    });
+  }
+}
+function getOtcLink(depositId, escrowAddress) {
+  const escrow = escrowAddress || ESCROW_ADDRESS;
+  return `${OTC_BASE_URL}/deposit/${escrow}/${depositId}`;
+}
+async function writeContract(walletClient, functionName, args) {
+  const wc = walletClient;
+  if (typeof wc.writeContract !== "function") {
+    throw new OfframpError("Wallet client does not support writeContract", "VALIDATION");
+  }
+  await wc.writeContract({
+    address: WHITELIST_HOOK_ADDRESS,
+    abi: WhitelistPreIntentHook_default,
+    functionName,
+    args
+  });
+}
+async function readIsWhitelisted(escrow, depositId, taker) {
+  const publicClient = createPublicClient({ chain: base, transport: http(BASE_RPC_URL) });
+  return publicClient.readContract({
+    address: WHITELIST_HOOK_ADDRESS,
+    abi: WhitelistPreIntentHook_default,
+    functionName: "isWhitelisted",
+    args: [escrow, depositId, taker]
+  });
+}
 
 // src/queries.ts
-import { formatUnits } from "viem";
+import { concatHex, createPublicClient as createPublicClient2, encodeFunctionData, formatUnits, http as http2 } from "viem";
+import { base as base2 } from "viem/chains";
 import {
   classifyDelegationState,
   defaultIndexerEndpoint,
+  getAttributionDataSuffix,
   getCurrencyInfoFromHash as getCurrencyInfoFromHash2,
   IndexerClient,
   IndexerDepositService
@@ -779,6 +883,18 @@ function extractTxHash(result) {
     return result.transactionHash;
   throw new Error("Unexpected transaction result format");
 }
+var ESCROW_V2_ABI = [
+  {
+    name: "clearRateManager",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositId", type: "uint256" }],
+    outputs: []
+  }
+];
+function appendReferrerAttribution(calldata) {
+  return concatHex([calldata, getAttributionDataSuffix([REFERRER])]);
+}
 async function deposits(walletAddress) {
   const service = getIndexerService();
   const raw = await service.fetchDepositsWithRelations(
@@ -801,8 +917,167 @@ async function close(walletClient, depositId, escrowAddress) {
   });
   return extractTxHash(result);
 }
+async function delegate(walletClient, depositId, escrowAddress) {
+  const client = createSdkClient(walletClient);
+  const result = await client.setRateManager({
+    depositId: BigInt(depositId),
+    rateManagerAddress: RATE_MANAGER_REGISTRY_ADDRESS,
+    rateManagerId: DELEGATE_RATE_MANAGER_ID,
+    escrowAddress: escrowAddress || ESCROW_ADDRESS,
+    txOverrides: { referrer: [REFERRER] }
+  });
+  return extractTxHash(result);
+}
+async function undelegate(walletClient, depositId, escrowAddress) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("Wallet client has no account. Connect a wallet first.");
+  }
+  const data = appendReferrerAttribution(
+    encodeFunctionData({
+      abi: ESCROW_V2_ABI,
+      functionName: "clearRateManager",
+      args: [BigInt(depositId)]
+    })
+  );
+  const hash = await walletClient.sendTransaction({
+    account,
+    chain: base2,
+    data,
+    to: escrowAddress || ESCROW_ADDRESS
+  });
+  const publicClient = createPublicClient2({
+    chain: base2,
+    transport: http2(BASE_RPC_URL)
+  });
+  try {
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      confirmations: 1,
+      timeout: 12e4,
+      pollingInterval: 4e3
+    });
+    if (receipt.status !== "success") {
+      throw new Error("Undelegation transaction failed");
+    }
+  } catch (err) {
+    const isTimeout = err instanceof Error && err.message.toLowerCase().includes("timed out");
+    if (!isTimeout) {
+      throw err;
+    }
+  }
+  return hash;
+}
+
+// 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 sendTelemetryEvent(name, payload) {
+  emitEvent(name, payload);
+}
+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
+import { createPublicClient as createPublicClient3, decodeEventLog, formatUnits as formatUnits2, http as http3, parseUnits } from "viem";
+import { base as base3 } from "viem/chains";
+import {
+  getSpreadOracleConfig,
+  mapConversionRatesToOnchainMinRate
+} from "@zkp2p/sdk";
 function usdcToUnits(amount) {
   return parseUnits(amount, 6);
 }
@@ -897,15 +1172,6 @@ function extractTxHash2(result) {
     return result.transactionHash;
   throw new Error("Unexpected transaction result format");
 }
-function createSdkClient(walletClient) {
-  return new 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();
@@ -914,6 +1180,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;
@@ -925,369 +1192,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 = createPublicClient3({ chain: base3, transport: http3(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(formatUnits2(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 = createPublicClient({ chain: base, transport: 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(formatUnits2(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 = 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 = 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",
-        "delegating",
-        delegationError,
-        { txHash: hash, depositId }
+        "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 }
       );
     }
-    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 });
+    emitProgress({ step: "delegating", txHash: hash, depositId });
     try {
-      const otcResult = await enableOtc(walletClient, depositId, params.otcTaker);
-      otcLink = otcResult.otcLink;
-    } catch (otcError) {
-      if (isUserCancellation(otcError)) {
+      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 OTC restriction",
+          "User cancelled delegation",
           "USER_CANCELLED",
-          "restricting",
-          otcError,
-          {
-            txHash: hash,
-            depositId
-          }
+          "delegating",
+          delegationError,
+          { txHash: hash, depositId }
         );
       }
       throw new OfframpError(
-        "Deposit created and delegated but OTC restriction failed. Use enableOtc() to retry.",
-        "DEPOSIT_FAILED",
-        "restricting",
-        otcError,
+        "Deposit created but delegation failed. Call offramp() again to resume delegation.",
+        "DELEGATION_FAILED",
+        "delegating",
+        delegationError,
         { txHash: hash, depositId }
       );
     }
+    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(
+          "Deposit created and delegated but OTC restriction failed. Use enableOtc() to retry.",
+          "DEPOSIT_FAILED",
+          "restricting",
+          otcError,
+          { 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;
   }
-  onProgress?.({ step: "done", txHash: hash, depositId });
-  return { depositId, txHash: hash, resumed: false, otcLink };
 }
 
-// src/otc.ts
-var WHITELIST_HOOK_ADDRESS = "0xda023Ea0d789A41BcF5866F7B6BBd2CaDF9b79B8";
-var OTC_BASE_URL = "https://usdctofiat.xyz";
-async function enableOtc(walletClient, depositId, takerAddress, escrowAddress) {
-  if (!isAddress(takerAddress)) {
-    throw new OfframpError("Invalid taker address", "VALIDATION");
+// src/currencies.ts
+import { currencyInfo as currencyInfo2 } from "@zkp2p/sdk";
+function buildCurrencies() {
+  const entries = {};
+  for (const [code, info] of Object.entries(
+    currencyInfo2
+  )) {
+    entries[code] = {
+      code: info.currencyCode ?? code,
+      name: info.currencyName ?? code,
+      symbol: info.currencySymbol ?? code,
+      countryCode: info.countryCode ?? ""
+    };
   }
-  const escrow = escrowAddress || ESCROW_ADDRESS;
-  const taker = takerAddress;
-  const depositIdBig = BigInt(depositId);
-  const client = createSdkClient(walletClient);
-  const txOverrides = { referrer: [REFERRER] };
+  return entries;
+}
+var CURRENCIES = buildCurrencies();
+
+// 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 currentHook = await client.getDepositWhitelistHook(depositIdBig, {
-      escrowAddress: escrow
-    });
-    if (currentHook !== zeroAddress) {
-      const isAlready = await readIsWhitelisted(
-        walletClient,
-        escrow,
-        depositIdBig,
-        taker
-      );
-      if (isAlready) {
-        return {
-          depositId,
-          takerAddress: taker,
-          otcLink: getOtcLink(depositId, escrow)
-        };
-      }
+    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;
     }
-    await writeContract(walletClient, "addToWhitelist", [escrow, depositIdBig, [taker]]);
-    if (currentHook === zeroAddress) {
-      await client.setDepositWhitelistHook({
-        depositId: depositIdBig,
-        whitelistHook: WHITELIST_HOOK_ADDRESS,
-        escrowAddress: escrow,
-        txOverrides
-      });
+    const result = parsed.result;
+    if (!result?.depositId || !result.txHash) {
+      sessionStorage.removeItem(storageKey);
+      return null;
     }
-    return {
-      depositId,
-      takerAddress: taker,
-      otcLink: getOtcLink(depositId, escrow)
-    };
-  } catch (err) {
-    if (err instanceof OfframpError) throw err;
-    if (isUserCancellation(err)) {
-      throw new OfframpError("User cancelled", "USER_CANCELLED", void 0, err, { depositId });
-    }
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new OfframpError(`Failed to enable OTC: ${detail}`, "DEPOSIT_FAILED", void 0, err, {
-      depositId
-    });
+    return result;
+  } catch {
+    return null;
   }
 }
-async function disableOtc(walletClient, depositId, escrowAddress) {
-  const escrow = escrowAddress || ESCROW_ADDRESS;
-  const client = createSdkClient(walletClient);
-  const txOverrides = { referrer: [REFERRER] };
+function writeIdempotencyResult(storageKey, result) {
+  if (typeof sessionStorage === "undefined") return;
   try {
-    await client.setDepositWhitelistHook({
-      depositId: BigInt(depositId),
-      whitelistHook: zeroAddress,
-      escrowAddress: escrow,
-      txOverrides
-    });
-  } catch (err) {
-    if (isUserCancellation(err)) {
-      throw new OfframpError("User cancelled", "USER_CANCELLED", void 0, err, { depositId });
-    }
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new OfframpError(`Failed to disable OTC: ${detail}`, "DEPOSIT_FAILED", void 0, err, {
-      depositId
-    });
+    const record = {
+      result,
+      expiresAt: Date.now() + IDEMPOTENCY_TTL_MS
+    };
+    sessionStorage.setItem(storageKey, JSON.stringify(record));
+  } catch {
   }
 }
-function getOtcLink(depositId, escrowAddress) {
-  const escrow = escrowAddress || ESCROW_ADDRESS;
-  return `${OTC_BASE_URL}/deposit/${escrow}/${depositId}`;
+function createPerFlowTelemetry(base4, integratorId, referralId) {
+  return createTelemetryContext({
+    sdkVersion: base4.sdkVersion,
+    telemetry: base4.enabled,
+    integratorId: sanitizeAttributionId(integratorId) ?? base4.integratorId,
+    referralId: sanitizeAttributionId(referralId) ?? base4.referralId
+  });
 }
-async function writeContract(walletClient, functionName, args) {
-  const wc = walletClient;
-  if (typeof wc.writeContract !== "function") {
-    throw new OfframpError("Wallet client does not support writeContract", "VALIDATION");
+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);
   }
-  await wc.writeContract({
-    address: WHITELIST_HOOK_ADDRESS,
-    abi: WhitelistPreIntentHook_default,
-    functionName,
-    args
-  });
+  return grouped;
 }
-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")
-  });
-  return publicClient.readContract({
-    address: WHITELIST_HOOK_ADDRESS,
-    abi: WhitelistPreIntentHook_default,
-    functionName: "isWhitelisted",
-    args: [escrow, depositId, taker]
-  });
+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(
+        `${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();
+  }
+};
+function createOfframp(options) {
+  return new Offramp(options);
 }
 
 export {
+  ESCROW_ADDRESS,
   PLATFORMS,
   OfframpError,
   enableOtc,
@@ -1295,6 +1686,15 @@ export {
   getOtcLink,
   deposits,
   close,
-  offramp
+  delegate,
+  undelegate,
+  sanitizeAttributionId,
+  emitEvent,
+  sendTelemetryEvent,
+  createTelemetryContext,
+  offramp,
+  CURRENCIES,
+  Offramp,
+  createOfframp
 };
-//# sourceMappingURL=chunk-QELK2M73.js.map
+//# sourceMappingURL=chunk-JQBKGGI2.js.map