@rhinestone/deposit-modal 0.13.0 → 0.14.1

package/dist/{chunk-XYJFEN5D.mjs → chunk-R5UQ3TN4.mjs}

@@ -1,7 +1,7 @@
 import {
   CdnIcon,
   ChevronRightIcon
-} from "./chunk-EOMT5LKX.mjs";
+} from "./chunk-UX35GYLM.mjs";
 
 // src/components/ui/ListRow.tsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";

package/dist/{chunk-EOMT5LKX.mjs → chunk-UX35GYLM.mjs}

@@ -1,6 +1,7 @@
 import {
+  MODAL_VERSION,
   serviceHeaders
-} from "./chunk-FZ5FZFIG.mjs";
+} from "./chunk-LMG46EP2.mjs";
 import {
   CHAIN_DISPLAY_ORDER,
   HYPERCORE_CHAIN_ID,
@@ -83,7 +84,7 @@ function Modal({
     (event) => {
       if (event.key === "Escape") {
         event.preventDefault();
-        onClose();
+        onClose("escape");
         return;
       }
       if (event.key === "Tab" && contentRef.current) {
@@ -109,7 +110,7 @@ function Modal({
   const handleOverlayClick = useCallback(
     (event) => {
       if (closeOnOverlayClick && event.target === overlayRef.current) {
-        onClose();
+        onClose("overlay");
       }
     },
     [closeOnOverlayClick, onClose]
@@ -2875,6 +2876,554 @@ function formatReceiveEstimate(params) {
   return sameSymbol ? `${formatted} ${params.targetSymbol}` : `~${formatted} ${params.targetSymbol}`;
 }
 
+// src/core/analytics.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback2,
+  useContext as useContext3,
+  useEffect as useEffect4,
+  useMemo as useMemo3,
+  useRef as useRef3
+} from "react";
+
+// src/core/analytics-ingest.ts
+var DEFAULT_ANALYTICS_INGEST_URL = "https://v1.orchestrator.rhinestone.dev/deposit-processor/analytics/events";
+var MAX_BATCH = 20;
+var MAX_QUEUE = 200;
+var FLUSH_DELAY_MS = 5e3;
+var MAX_BODY_BYTES = 48 * 1024;
+var TOKEN_REFRESH_MARGIN_MS = 6e4;
+var TOKEN_TIMEOUT_MS = 3e3;
+var CLOSE_MINT_WAIT_MS = 1500;
+var MAX_ATTEMPTS = 3;
+var MAX_BACKOFF_MS = 3e4;
+var IDLE = 0;
+var CLOSING = 1;
+var DISMISSAL = 2;
+var ENVELOPE_FIELDS = /* @__PURE__ */ new Set([
+  "type",
+  "timestamp",
+  "session_id",
+  "modal",
+  "widget_version",
+  "session_properties",
+  "funding_method"
+]);
+function createIngestTransport(options) {
+  const {
+    ingestUrl,
+    backendUrl,
+    proxyOrigin,
+    sessionId,
+    modal,
+    widgetVersion,
+    sessionProperties,
+    onFailure
+  } = options;
+  const fetchImpl = options.fetchImpl ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  const now = options.now ?? (() => Date.now());
+  const createEventId = options.createEventId ?? randomUuid;
+  const mintUrl = `${backendUrl.replace(/\/$/, "")}/analytics/ingest-token`;
+  const queue = [];
+  let sequence = 0;
+  let dropped = 0;
+  let token = null;
+  let mintUnavailable = false;
+  let mintFailures = 0;
+  let mintBackoffUntil = 0;
+  let timer = null;
+  let sending = false;
+  let disposed = false;
+  let pendingRun = false;
+  let urgency = IDLE;
+  let minting = null;
+  let mintAbort = null;
+  const sleepers = /* @__PURE__ */ new Set();
+  function report(reason, status) {
+    try {
+      onFailure({ reason, status, droppedEvents: dropped });
+    } catch {
+    }
+  }
+  function drop(batch, reason, status) {
+    dropped += batch.length;
+    report(reason, status);
+  }
+  function toWireEvent(event) {
+    const payload = {};
+    for (const [key, value] of Object.entries(event)) {
+      if (!ENVELOPE_FIELDS.has(key)) payload[key] = value;
+    }
+    const wire = {
+      event_id: createEventId(),
+      session_id: sessionId,
+      sequence: sequence++,
+      type: String(event.type),
+      timestamp: String(event.timestamp),
+      widget_version: widgetVersion,
+      proxy_origin: proxyOrigin,
+      modal,
+      session_properties: sessionProperties,
+      payload
+    };
+    if (modal === "deposit") wire.funding_method = event.funding_method ?? null;
+    return wire;
+  }
+  function takeBatch() {
+    const batch = queue.slice(0, MAX_BATCH);
+    while (batch.length > 1 && bodyOf(batch).length > MAX_BODY_BYTES) {
+      batch.pop();
+    }
+    queue.splice(0, batch.length);
+    return batch;
+  }
+  function bodyOf(batch) {
+    return JSON.stringify({ events: batch });
+  }
+  function backoff(attempt) {
+    return Math.min(1e3 * 2 ** (attempt - 1), MAX_BACKOFF_MS);
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(finish, ms);
+      function finish() {
+        clearTimeout(timeout);
+        sleepers.delete(finish);
+        resolve();
+      }
+      sleepers.add(finish);
+    });
+  }
+  function interruptForUnload() {
+    for (const wake of [...sleepers]) wake();
+    mintAbort?.abort();
+  }
+  function retryDelay(response, attempt) {
+    const seconds = Number(response.headers?.get?.("Retry-After"));
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(seconds * 1e3, MAX_BACKOFF_MS);
+    }
+    return backoff(attempt);
+  }
+  async function mintToken() {
+    if (mintUnavailable || !fetchImpl) return;
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    mintAbort = controller;
+    const timeout = controller ? setTimeout(() => controller.abort(), TOKEN_TIMEOUT_MS) : null;
+    let response;
+    try {
+      response = await fetchImpl(mintUrl, {
+        method: "POST",
+        headers: serviceHeaders(),
+        signal: controller?.signal
+      });
+    } catch {
+      if (urgency !== DISMISSAL) {
+        mintFailures += 1;
+        mintBackoffUntil = now() + backoff(mintFailures);
+      }
+      return;
+    } finally {
+      if (timeout !== null) clearTimeout(timeout);
+      mintAbort = null;
+    }
+    if (response.status === 404 || response.status === 401 || response.status === 403) {
+      mintUnavailable = true;
+      report("token_unavailable", response.status);
+      return;
+    }
+    if (!response.ok) {
+      mintFailures += 1;
+      mintBackoffUntil = now() + backoff(mintFailures);
+      return;
+    }
+    try {
+      const data = await response.json();
+      const value = typeof data.token === "string" ? data.token : "";
+      const expiresAt = Date.parse(String(data.expiresAt));
+      if (!value || Number.isNaN(expiresAt)) throw new Error("malformed");
+      token = { value, expiresAt };
+      mintFailures = 0;
+      mintBackoffUntil = 0;
+    } catch {
+      mintUnavailable = true;
+      report("token_unavailable", response.status);
+    }
+  }
+  function startMint() {
+    if (!minting) {
+      minting = mintToken().finally(() => {
+        minting = null;
+      });
+    }
+    return minting;
+  }
+  async function ensureToken(maxWaitMs) {
+    if (mintUnavailable) return;
+    if (token && token.expiresAt - now() > TOKEN_REFRESH_MARGIN_MS) return;
+    if (now() < mintBackoffUntil) return;
+    const pending = startMint();
+    await (maxWaitMs === void 0 ? pending : Promise.race([pending, sleep(maxWaitMs)]));
+  }
+  async function deliver(batch) {
+    if (!fetchImpl) return drop(batch, "unsupported");
+    let attempt = 0;
+    let refreshed = false;
+    let unattributed = false;
+    for (; ; ) {
+      const terminal = urgency === DISMISSAL;
+      attempt += 1;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (token && !unattributed) headers.Authorization = `Bearer ${token.value}`;
+      let response;
+      try {
+        response = await fetchImpl(ingestUrl, {
+          method: "POST",
+          headers,
+          body: bodyOf(batch),
+          keepalive: true
+        });
+      } catch {
+        if (terminal || attempt >= MAX_ATTEMPTS) {
+          return drop(batch, "network");
+        }
+        await sleep(backoff(attempt));
+        continue;
+      }
+      if (response.ok) return;
+      const status = response.status;
+      if (status === 401) {
+        token = null;
+        if (!refreshed && !terminal) {
+          refreshed = true;
+          await startMint();
+          if (token) continue;
+        }
+        if (!unattributed) {
+          unattributed = true;
+          continue;
+        }
+        return drop(batch, "unauthorized", status);
+      }
+      if (status === 409) return drop(batch, "conflict", status);
+      if (status === 429 || status >= 500) {
+        if (terminal || attempt >= MAX_ATTEMPTS) {
+          return drop(batch, status === 429 ? "throttled" : "unavailable", status);
+        }
+        await sleep(retryDelay(response, attempt));
+        continue;
+      }
+      return drop(batch, "rejected", status);
+    }
+  }
+  function escalate(level) {
+    if (level <= urgency) return;
+    urgency = level;
+    if (level === DISMISSAL) interruptForUnload();
+  }
+  function onDismissal(event) {
+    if (event.type === "pagehide" || document.visibilityState === "hidden") {
+      escalate(DISMISSAL);
+    }
+  }
+  function dismissalGuard(attach) {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const bind = attach ? "addEventListener" : "removeEventListener";
+    window[bind]("pagehide", onDismissal);
+    document[bind]("visibilitychange", onDismissal);
+  }
+  async function run(level) {
+    escalate(level);
+    if (sending) {
+      pendingRun = true;
+      return;
+    }
+    sending = true;
+    try {
+      while (queue.length > 0) {
+        const batch = takeBatch();
+        if (urgency !== DISMISSAL) {
+          await ensureToken(urgency === CLOSING ? CLOSE_MINT_WAIT_MS : void 0);
+        }
+        await deliver(batch);
+      }
+    } finally {
+      sending = false;
+    }
+    if (pendingRun) {
+      pendingRun = false;
+      await run(urgency);
+      return;
+    }
+    if (!disposed) urgency = IDLE;
+    else dismissalGuard(false);
+  }
+  function clearFlushTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function scheduleFlush() {
+    if (timer !== null || disposed) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void run(IDLE);
+    }, FLUSH_DELAY_MS);
+  }
+  return {
+    enqueue(event) {
+      if (disposed) return;
+      queue.push(toWireEvent(event));
+      if (sequence === 1) void ensureToken();
+      if (queue.length > MAX_QUEUE) {
+        dropped += queue.length - MAX_QUEUE;
+        queue.splice(0, queue.length - MAX_QUEUE);
+      }
+      if (queue.length >= MAX_BATCH) {
+        clearFlushTimer();
+        void run(IDLE);
+      } else {
+        scheduleFlush();
+      }
+    },
+    flush(flushOptions) {
+      const dismissal = flushOptions?.terminal ?? false;
+      if (disposed && !dismissal) return;
+      clearFlushTimer();
+      void run(dismissal ? DISMISSAL : IDLE);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      clearFlushTimer();
+      dismissalGuard(true);
+      void run(CLOSING);
+    }
+  };
+}
+function randomUuid() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  globalThis.crypto?.getRandomValues?.(bytes);
+  if (!bytes.some(Boolean)) {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+function resolveProxyOrigin(backendUrl) {
+  if (!backendUrl.trim()) return null;
+  try {
+    const { origin } = new URL(backendUrl, globalThis.location?.href);
+    return origin.startsWith("http") ? origin : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/analytics.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+var AnalyticsContext = createContext3(null);
+var noopDepositEmitter = () => {
+};
+var noopWithdrawEmitter = () => {
+};
+var noopClaimEmitter = () => {
+};
+function cloneAndFreeze(value) {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map(cloneAndFreeze));
+  }
+  if (value && typeof value === "object") {
+    const clone = Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, cloneAndFreeze(child)])
+    );
+    return Object.freeze(clone);
+  }
+  return value;
+}
+function AnalyticsSession(props) {
+  const sessionIdRef = useRef3(void 0);
+  if (sessionIdRef.current === void 0) {
+    sessionIdRef.current = (props.createSessionId ?? randomUuid)();
+  }
+  const sessionPropertiesRef = useRef3(void 0);
+  if (sessionPropertiesRef.current === void 0) {
+    sessionPropertiesRef.current = cloneAndFreeze(props.sessionProperties);
+  }
+  const onEventRef = useRef3(props.onEvent);
+  onEventRef.current = props.onEvent;
+  const nowRef = useRef3(props.now ?? (() => /* @__PURE__ */ new Date()));
+  nowRef.current = props.now ?? (() => /* @__PURE__ */ new Date());
+  const modal = props.modal;
+  const reportedFailuresRef = useRef3(/* @__PURE__ */ new Set());
+  const emitFailure = useCallback2(
+    ({ reason, status, droppedEvents }) => {
+      if (reportedFailuresRef.current.has(reason)) return;
+      reportedFailuresRef.current.add(reason);
+      const event = {
+        type: "analytics_ingest_failure",
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        reason,
+        ...status === void 0 ? {} : { status },
+        dropped_events: droppedEvents
+      };
+      onEventRef.current?.(event);
+    },
+    [modal]
+  );
+  function createIngest() {
+    if (props.enableIngest === false) {
+      return { transport: null, initialFailure: null };
+    }
+    const proxyOrigin = resolveProxyOrigin(props.backendUrl ?? "");
+    if (!proxyOrigin || typeof globalThis.fetch !== "function") {
+      return {
+        transport: null,
+        initialFailure: { reason: "unsupported", droppedEvents: 0 }
+      };
+    }
+    return {
+      transport: createIngestTransport({
+        ingestUrl: props.ingestUrl ?? DEFAULT_ANALYTICS_INGEST_URL,
+        backendUrl: props.backendUrl,
+        proxyOrigin,
+        sessionId: sessionIdRef.current,
+        modal,
+        widgetVersion: MODAL_VERSION,
+        sessionProperties: sessionPropertiesRef.current,
+        onFailure: (failure) => emitFailure(failure),
+        fetchImpl: props.fetchImpl,
+        createEventId: props.createEventId
+      }),
+      initialFailure: null
+    };
+  }
+  const ingestRef = useRef3(void 0);
+  if (ingestRef.current === void 0) {
+    ingestRef.current = createIngest();
+  }
+  const pendingDisposalRef = useRef3(null);
+  const enqueue = useCallback2(
+    (event) => {
+      try {
+        ingestRef.current?.transport?.enqueue(
+          event
+        );
+      } catch {
+      }
+    },
+    []
+  );
+  useEffect4(() => {
+    if (pendingDisposalRef.current !== null) {
+      clearTimeout(pendingDisposalRef.current);
+      pendingDisposalRef.current = null;
+    }
+    const setup = ingestRef.current;
+    if (setup.initialFailure) emitFailure(setup.initialFailure);
+    const transport = setup.transport;
+    if (!transport) return;
+    const flush = () => transport.flush({ terminal: true });
+    const onVisibilityChange = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    window.addEventListener("pagehide", flush);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      window.removeEventListener("pagehide", flush);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      pendingDisposalRef.current = setTimeout(() => {
+        pendingDisposalRef.current = null;
+        transport.dispose();
+      }, 0);
+    };
+  }, [emitFailure]);
+  const emitDeposit = useCallback2(
+    (...[payload, fundingMethod]) => {
+      if (modal !== "deposit") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current,
+        funding_method: fundingMethod
+      };
+      onEventRef.current?.(
+        event
+      );
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const emitWithdraw = useCallback2(
+    (payload) => {
+      if (modal !== "withdraw") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current
+      };
+      onEventRef.current?.(event);
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const emitClaim = useCallback2(
+    (payload) => {
+      if (modal !== "claim") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current
+      };
+      onEventRef.current?.(event);
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const context = useMemo3(
+    () => modal === "deposit" ? { modal, emit: emitDeposit } : modal === "withdraw" ? { modal, emit: emitWithdraw } : { modal, emit: emitClaim },
+    [modal, emitDeposit, emitWithdraw, emitClaim]
+  );
+  return /* @__PURE__ */ jsx11(AnalyticsContext.Provider, { value: context, children: props.children });
+}
+function useDepositAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "deposit") return noopDepositEmitter;
+  return context.emit;
+}
+function useWithdrawAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "withdraw") return noopWithdrawEmitter;
+  return context.emit;
+}
+function useClaimAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "claim") return noopClaimEmitter;
+  return context.emit;
+}
+
 // src/core/theme.ts
 var RADIUS_SCALE = {
   none: { sm: "0", md: "0", lg: "0" },
@@ -3139,6 +3688,10 @@ export {
   estimateReceiveAmount,
   formatQuotedReceive,
   formatReceiveEstimate,
+  AnalyticsSession,
+  useDepositAnalyticsEmitter,
+  useWithdrawAnalyticsEmitter,
+  useClaimAnalyticsEmitter,
   resolveThemeMode,
   followSystemAppearance,
   applyTheme,

package/dist/{chunk-YREVFB64.mjs → chunk-VALXN5IO.mjs}

@@ -1,10 +1,10 @@
 import {
   debugError,
   debugLog
-} from "./chunk-EOMT5LKX.mjs";
+} from "./chunk-UX35GYLM.mjs";
 import {
   serviceHeaders
-} from "./chunk-FZ5FZFIG.mjs";
+} from "./chunk-LMG46EP2.mjs";
 
 // src/core/recovery.ts
 var RECOVER_DOMAIN = {
@@ -18,12 +18,13 @@ var RECOVER_TYPES = {
   ]
 };
 var RecoveryError = class extends Error {
-  constructor(message, status, code, retryable = false) {
+  constructor(message, status, code, retryable = false, phase = "response") {
     super(message);
     this.name = "RecoveryError";
     this.status = status;
     this.code = code;
     this.retryable = retryable;
+    this.phase = phase;
   }
 };
 function formatRecoveryError(status, code, serverMessage) {
@@ -95,7 +96,8 @@ async function submitSignedRecovery(params) {
       "Signature request was declined. Approve it in your wallet to recover this deposit.",
       0,
       void 0,
-      true
+      true,
+      "signature"
     );
   }
   if (!signature) {
@@ -103,7 +105,8 @@ async function submitSignedRecovery(params) {
       "Signature request was declined. Approve it in your wallet to recover this deposit.",
       0,
       void 0,
-      true
+      true,
+      "signature"
     );
   }
   const url = `${backendUrl.replace(/\/$/, "")}/deposits/recover`;
@@ -127,7 +130,7 @@ async function submitSignedRecovery(params) {
   } catch (error) {
     debugError(debug, scope, "submitSignedRecovery:network", error);
     const { message, retryable } = formatRecoveryError(0);
-    throw new RecoveryError(message, 0, void 0, retryable);
+    throw new RecoveryError(message, 0, void 0, retryable, "request");
   }
   if (!response.ok) {
     const body = await response.json().catch(() => ({}));
@@ -139,7 +142,13 @@ async function submitSignedRecovery(params) {
       body.code,
       body.error
     );
-    throw new RecoveryError(message, response.status, body.code, retryable);
+    throw new RecoveryError(
+      message,
+      response.status,
+      body.code,
+      retryable,
+      "response"
+    );
   }
   const result = await response.json();
   debugLog(debug, scope, "submitSignedRecovery:success", {