@usdctofiat/offramp 1.1.4 → 2.0.0

package/dist/index.cjs

@@ -22,15 +22,32 @@ var index_exports = {};
 __export(index_exports, {
   CURRENCIES: () => CURRENCIES,
   ESCROW_ADDRESS: () => ESCROW_ADDRESS,
+  MakersCreateError: () => MakersCreateError,
+  OFFRAMP_ERROR_CODES: () => OFFRAMP_ERROR_CODES,
+  Offramp: () => Offramp,
   OfframpError: () => OfframpError,
+  PEER_EXTENSION_CHROME_URL: () => import_sdk7.PEER_EXTENSION_CHROME_URL,
   PLATFORMS: () => PLATFORMS,
   close: () => close,
+  createOfframp: () => createOfframp,
+  createPeerExtensionSdk: () => import_sdk7.createPeerExtensionSdk,
+  createTelemetryContext: () => createTelemetryContext,
   delegate: () => delegate,
   deposits: () => deposits,
   disableOtc: () => disableOtc,
+  emitEvent: () => emitEvent,
   enableOtc: () => enableOtc,
   getOtcLink: () => getOtcLink,
+  getPeerExtensionRegistrationInfo: () => getPeerExtensionRegistrationInfo,
+  getPeerExtensionState: () => import_sdk7.getPeerExtensionState,
+  isPeerExtensionAvailable: () => import_sdk7.isPeerExtensionAvailable,
+  isPeerExtensionRegistrationError: () => isPeerExtensionRegistrationError,
+  normalizePaypalMeUsername: () => normalizePaypalMeUsername,
   offramp: () => offramp,
+  openPeerExtensionInstallPage: () => import_sdk7.openPeerExtensionInstallPage,
+  peerExtensionSdk: () => import_sdk7.peerExtensionSdk,
+  sanitizeAttributionId: () => sanitizeAttributionId,
+  sendTelemetryEvent: () => sendTelemetryEvent,
   undelegate: () => undelegate
 });
 module.exports = __toCommonJS(index_exports);
@@ -42,6 +59,7 @@ var import_sdk5 = 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";
@@ -57,6 +75,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;
@@ -157,6 +176,17 @@ function resolveSupportedCurrencies(platform) {
   }
   return Array.from(codes).sort();
 }
+function normalizePaypalMeUsername(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  const withoutProtocol = trimmed.replace(/^https?:\/\//i, "").replace(/^www\./i, "");
+  if (/^paypal\.me(?:[?#].*)?$/i.test(withoutProtocol)) return "";
+  const withoutDomain = withoutProtocol.replace(/^paypal\.me\//i, "");
+  const [pathWithoutQuery] = withoutDomain.split(/[?#]/, 1);
+  const sanitizedPath = pathWithoutQuery.replace(/^\/+/, "");
+  const [username] = sanitizedPath.split("/", 1);
+  return username.replace(/^@+/, "").trim().toLowerCase();
+}
 var BLUEPRINTS = {
   venmo: {
     id: "venmo",
@@ -204,7 +234,13 @@ var BLUEPRINTS = {
     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()
+    transform: (v) => v.replace(/^@+/, "").trim(),
+    extensionRegistration: {
+      providerId: "wise",
+      requiredPrompt: "This Wisetag is not registered yet. Verify it in the Peer extension, then refresh and retry with the same Wisetag.",
+      ctaLabel: "Install Peer Extension",
+      minExtensionVersion: "0.4.12"
+    }
   },
   mercadopago: {
     id: "mercadopago",
@@ -225,10 +261,18 @@ var BLUEPRINTS = {
   paypal: {
     id: "paypal",
     name: "PayPal",
-    identifierLabel: "Email",
-    placeholder: "email",
-    helperText: "Email linked to PayPal account",
-    validation: import_zod.z.string().email()
+    identifierLabel: "PayPal.me Username",
+    placeholder: "paypal.me/your-username",
+    helperText: "Your PayPal.me username, not your email",
+    validation: import_zod.z.string().min(1, "PayPal.me username is required").regex(/^[a-z0-9._-]+$/i, "Use your PayPal.me username (letters, numbers, . _ -)"),
+    transform: normalizePaypalMeUsername,
+    extensionRegistration: {
+      providerId: "paypal",
+      requiredPrompt: "This PayPal username is not registered yet. Verify it in the Peer extension, then refresh and retry with the same PayPal username.",
+      ctaLabel: "Install Peer Extension",
+      ctaSubtext: "PayPal Business accounts are not supported at this time.",
+      minExtensionVersion: "0.4.14"
+    }
   },
   monzo: {
     id: "monzo",
@@ -259,6 +303,7 @@ function buildPlatformEntry(bp) {
       placeholder: bp.placeholder,
       help: bp.helperText
     },
+    ...bp.extensionRegistration ? { extensionRegistration: bp.extensionRegistration } : {},
     validate(input) {
       const transformed = bp.transform ? bp.transform(input) : input;
       const result = bp.validation.safeParse(transformed);
@@ -285,6 +330,9 @@ var PLATFORMS = {
   MONZO: buildPlatformEntry(BLUEPRINTS.monzo),
   N26: buildPlatformEntry(BLUEPRINTS.n26)
 };
+function getPlatformById(id) {
+  return Object.values(PLATFORMS).find((p) => p.id === id) ?? null;
+}
 function normalizePaymentMethodLookupName(platform) {
   const normalized = platform.trim().toLowerCase();
   if (!normalized) return null;
@@ -328,34 +376,37 @@ function getPaymentMethodHashes(platform) {
   }
   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: "" };
-  }
+function buildDepositData(platform, identifier, telegramUsername = "") {
+  const offchainId = platform === "chime" ? identifier.toLowerCase() : identifier;
+  return telegramUsername ? { offchainId, telegramUsername } : { offchainId };
+}
+function getPeerExtensionRegistrationInfo(platform) {
+  const entry = getPlatformById(platform);
+  return entry?.extensionRegistration ?? null;
+}
+var EXTENSION_REGISTRATION_ERROR_PATTERNS = ["creating the maker", "create the maker"];
+function isPeerExtensionRegistrationError(platform, message, statusCode) {
+  const info = getPeerExtensionRegistrationInfo(platform);
+  if (!info) return false;
+  const normalized = (message ?? "").trim();
+  if (normalized === info.requiredPrompt) return true;
+  if (statusCode === 400) return true;
+  if (!normalized) return false;
+  const lower = normalized.toLowerCase();
+  return EXTENSION_REGISTRATION_ERROR_PATTERNS.some((p) => lower.includes(p));
 }
 
 // src/errors.ts
+var MakersCreateError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "MakersCreateError";
+    this.status = status;
+    this.body = body;
+  }
+};
 var OfframpError = class extends Error {
   code;
   step;
@@ -997,6 +1048,108 @@ async function undelegate(walletClient, depositId, escrowAddress) {
   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
 function usdcToUnits(amount) {
   return (0, import_viem3.parseUnits)(amount, 6);
@@ -1042,23 +1195,39 @@ function extractDepositIdFromLogs(logs) {
   }
   return null;
 }
-async function registerPayeeDetails(processorName, depositData) {
+async function registerPayeeDetails(processorName, payload) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), PAYEE_REGISTRATION_TIMEOUT_MS);
   try {
-    const res = await fetch(`${API_BASE_URL}/v1/makers/create`, {
+    const res = await fetch(`${API_BASE_URL}/v2/makers/create`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ processorName, depositData }),
+      body: JSON.stringify({ processorName, ...payload }),
       signal: controller.signal
     });
     if (!res.ok) {
       const txt = await res.text().catch(() => "");
-      throw new Error(`makers/create failed (${res.status}): ${txt || res.statusText}`);
+      let detail = txt || res.statusText;
+      try {
+        const parsed = JSON.parse(txt);
+        if (typeof parsed.message === "string" && parsed.message.trim()) {
+          detail = parsed.message;
+        }
+      } catch {
+      }
+      throw new MakersCreateError(
+        `makers/create failed (${res.status}): ${detail}`,
+        res.status,
+        txt
+      );
     }
     const json = await res.json();
     if (!json.success || !json.responseObject?.hashedOnchainId) {
-      throw new Error(json.message || "makers/create returned no hashedOnchainId");
+      throw new MakersCreateError(
+        json.message || "makers/create returned no hashedOnchainId",
+        json.statusCode ?? null,
+        ""
+      );
     }
     return json.responseObject.hashedOnchainId;
   } finally {
@@ -1114,256 +1283,326 @@ async function findUndelegatedDeposit(walletAddress) {
       if (remaining === 0n) return false;
       return (d.rateManagerId ?? "").toLowerCase() !== delegateIdLower;
     });
-    undelegated.sort((a, b) => Number(BigInt(b.depositId) - BigInt(a.depositId)));
+    undelegated.sort((a, b) => {
+      const left = BigInt(a.depositId);
+      const right = BigInt(b.depositId);
+      if (left === right) return 0;
+      return left > right ? -1 : 1;
+    });
     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_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));
+    emitProgress({ step: "registering" });
+    let hashedOnchainId;
+    const canonicalName = platformId.startsWith("zelle") ? "zelle" : platformId;
+    try {
+      const payeePayload = buildDepositData(canonicalName, normalizedIdentifier);
+      hashedOnchainId = await registerPayeeDetails(canonicalName, payeePayload);
+    } catch (err) {
+      const status = err instanceof MakersCreateError ? err.status : null;
+      const message = err instanceof Error ? err.message : String(err);
+      if (isPeerExtensionRegistrationError(canonicalName, message, status)) {
+        throw new OfframpError(
+          `${platform.name} maker is not yet registered in the Peer extension. Verify this handle in the extension, then retry.`,
+          "EXTENSION_REGISTRATION_REQUIRED",
+          "registering",
+          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_sdk5.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_sdk5.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/currencies.ts
@@ -1383,19 +1622,213 @@ function buildCurrencies() {
   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 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(
+        `${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);
+}
+
+// src/types.ts
+var OFFRAMP_ERROR_CODES = {
+  VALIDATION: "VALIDATION",
+  APPROVAL_FAILED: "APPROVAL_FAILED",
+  REGISTRATION_FAILED: "REGISTRATION_FAILED",
+  /**
+   * Curator rejected the maker because the user has not registered this
+   * handle in the Peer extension yet. Thrown from `offramp()` for PayPal
+   * and Wise when `/v2/makers/create` returns 400 or a "creating the maker"
+   * message. Recover by prompting the user through the Peer extension via
+   * `usePeerExtensionRegistration(platform)` (React) or `peerExtensionSdk`
+   * directly, then call `offramp()` again.
+   */
+  EXTENSION_REGISTRATION_REQUIRED: "EXTENSION_REGISTRATION_REQUIRED",
+  DEPOSIT_FAILED: "DEPOSIT_FAILED",
+  CONFIRMATION_FAILED: "CONFIRMATION_FAILED",
+  DELEGATION_FAILED: "DELEGATION_FAILED",
+  USER_CANCELLED: "USER_CANCELLED",
+  UNSUPPORTED: "UNSUPPORTED"
+};
+
+// src/extension.ts
+var import_sdk7 = require("@zkp2p/sdk");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CURRENCIES,
   ESCROW_ADDRESS,
+  MakersCreateError,
+  OFFRAMP_ERROR_CODES,
+  Offramp,
   OfframpError,
+  PEER_EXTENSION_CHROME_URL,
   PLATFORMS,
   close,
+  createOfframp,
+  createPeerExtensionSdk,
+  createTelemetryContext,
   delegate,
   deposits,
   disableOtc,
+  emitEvent,
   enableOtc,
   getOtcLink,
+  getPeerExtensionRegistrationInfo,
+  getPeerExtensionState,
+  isPeerExtensionAvailable,
+  isPeerExtensionRegistrationError,
+  normalizePaypalMeUsername,
   offramp,
+  openPeerExtensionInstallPage,
+  peerExtensionSdk,
+  sanitizeAttributionId,
+  sendTelemetryEvent,
   undelegate
 });
 //# sourceMappingURL=index.cjs.map