@rhinestone/deposit-modal 0.12.2 → 0.13.0

package/dist/{chunk-J46WDSRD.mjs → chunk-COCBCQQC.mjs}

@@ -24,16 +24,17 @@ import {
   tokenAmountToNumber,
   useExplorerTxUrl,
   useLatestRef
-} from "./chunk-FXXUIK4E.mjs";
+} from "./chunk-EOMT5LKX.mjs";
 import {
   NATIVE_TOKEN_ADDRESS,
+  SOLANA_MAINNET_CAIP2,
   cdnIconUrl,
   getChainIcon,
   getChainName,
   targetChainToCaip2,
   targetChainToChainId,
   toEvmCaip2
-} from "./chunk-3STTWRAN.mjs";
+} from "./chunk-VUATPOWJ.mjs";
 
 // src/core/removed-props.ts
 var MANAGED_ACCOUNT_REMOVALS = {
@@ -62,7 +63,7 @@ var REMOVED_PROPS = {
   }
 };
 var REMOVED_UI_CONFIG_KEYS = {
-  checkLiquidity: "removed \u2014 the liquidity cap is shown on the QR / transfer screen, which checks it directly.",
+  checkLiquidity: "removed \u2014 the modal no longer surfaces a liquidity cap. Route capacity is enforced when the deposit is processed.",
   showHistoryButton: "removed \u2014 deposit history is always offered, from the modal's home screen. There is no way to hide it."
 };
 var warned = /* @__PURE__ */ new Set();
@@ -96,73 +97,23 @@ function warnRemovedProps(component, props) {
   }
 }
 
-// src/core/useTokenPrices.ts
-import { useEffect, useState } from "react";
-function isErc20(token) {
-  return typeof token.chainId === "number" && !!token.address && token.address.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase();
-}
-function caip2For(token) {
-  return `${toEvmCaip2(token.chainId)}:${token.address.toLowerCase()}`;
+// src/core/submission-uncertainty.ts
+var MARKER = "__rhinestoneSubmissionUncertain";
+function markSubmissionUncertain(error) {
+  Object.defineProperty(error, MARKER, {
+    value: true,
+    enumerable: false
+  });
+  return error;
 }
-async function fetchTokenPriceUsd(service, token) {
-  if (isErc20(token)) {
-    const caip2 = caip2For(token);
-    const prices2 = await service.fetchPricesByAddress([caip2]);
-    const price2 = prices2[caip2];
-    return typeof price2 === "number" && price2 > 0 ? price2 : null;
+function isSubmissionUncertain(error) {
+  let current = error;
+  for (let depth = 0; depth < 10; depth += 1) {
+    if (typeof current !== "object" || current === null) return false;
+    if (current[MARKER] === true) return true;
+    current = current.cause;
   }
-  const symbol = token.symbol.toUpperCase();
-  const prices = await service.fetchPrices([symbol]);
-  const price = prices[symbol];
-  return typeof price === "number" && price > 0 ? price : null;
-}
-function useTokenPrices(service, tokens) {
-  const [prices, setPrices] = useState({});
-  const defined = tokens.filter((t) => Boolean(t?.symbol));
-  const entries = [
-    ...new Map(
-      defined.map((token) => {
-        const erc20 = isErc20(token);
-        const caip2 = erc20 ? caip2For(token) : null;
-        const symbol = token.symbol.toUpperCase();
-        return [caip2 ?? `sym:${symbol}`, { symbol, caip2 }];
-      })
-    ).values()
-  ].sort(
-    (a, b) => (a.caip2 ?? a.symbol).localeCompare(b.caip2 ?? b.symbol)
-  );
-  const key = JSON.stringify(entries);
-  useEffect(() => {
-    if (key === "[]") return;
-    let cancelled = false;
-    const parsed = JSON.parse(key);
-    const symbols = [
-      ...new Set(parsed.filter((e) => !e.caip2).map((e) => e.symbol))
-    ];
-    const caip2Ids = [
-      ...new Set(
-        parsed.filter((e) => e.caip2).map((e) => e.caip2)
-      )
-    ];
-    Promise.all([
-      symbols.length > 0 ? service.fetchPrices(symbols) : Promise.resolve({}),
-      caip2Ids.length > 0 ? service.fetchPricesByAddress(caip2Ids) : Promise.resolve({})
-    ]).then(([bySymbol, byAddress]) => {
-      if (cancelled) return;
-      const merged = { ...bySymbol };
-      for (const entry of parsed) {
-        if (!entry.caip2) continue;
-        const price = byAddress[entry.caip2];
-        if (typeof price === "number") merged[entry.symbol] = price;
-      }
-      setPrices(merged);
-    }).catch(() => {
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [service, key]);
-  return prices;
+  return false;
 }
 
 // src/components/steps/ProcessingStep.tsx
@@ -170,16 +121,16 @@ import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2
 
 // src/components/ui/Tooltip.tsx
 import {
-  useState as useState2,
+  useState,
   useRef,
-  useEffect as useEffect2,
+  useEffect,
   useCallback
 } from "react";
 import { createPortal } from "react-dom";
 import { jsx, jsxs } from "react/jsx-runtime";
 function Tooltip({ content, children, className }) {
-  const [open, setOpen] = useState2(false);
-  const [position, setPosition] = useState2(null);
+  const [open, setOpen] = useState(false);
+  const [position, setPosition] = useState(null);
   const triggerRef = useRef(null);
   const bubbleRef = useRef(null);
   const updatePosition = useCallback(() => {
@@ -191,7 +142,7 @@ function Tooltip({ content, children, className }) {
       left: rect.left + rect.width / 2
     });
   }, []);
-  useEffect2(() => {
+  useEffect(() => {
     if (!open) return;
     updatePosition();
     function handleOutside(event) {
@@ -266,10 +217,10 @@ function Tooltip({ content, children, className }) {
 Tooltip.displayName = "Tooltip";
 
 // src/components/ui/FeesAccordion.tsx
-import { useState as useState3 } from "react";
+import { useState as useState2 } from "react";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function FeesAccordion({ total, rows, tooltip }) {
-  const [open, setOpen] = useState3(false);
+  const [open, setOpen] = useState2(false);
   const expandable = rows.length > 0;
   return /* @__PURE__ */ jsxs2("div", { className: "rs-fees-accordion", children: [
     /* @__PURE__ */ jsxs2("div", { className: "rs-fees-accordion-summary", children: [
@@ -555,6 +506,70 @@ function failureMessageForEvent(event) {
   return formatBridgeFailedMessage(event).message;
 }
 
+// src/core/useTokenPrices.ts
+import { useEffect as useEffect2, useState as useState3 } from "react";
+var PRICE_SERVICE_NATIVE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var WRAPPED_SOL_MINT = "So11111111111111111111111111111111111111112";
+var SOL_SYSTEM_PROGRAM = "11111111111111111111111111111111";
+function isSolanaNativeAddress(address) {
+  if (!address) return true;
+  const lower = address.toLowerCase();
+  return lower === "native" || lower === SOL_SYSTEM_PROGRAM;
+}
+function isNativeAddress(address) {
+  if (!address) return true;
+  return address.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
+}
+function caip2For(token) {
+  if (token.chainId === "solana") {
+    const mint = isSolanaNativeAddress(token.address) ? WRAPPED_SOL_MINT : token.address;
+    return mint ? `${SOLANA_MAINNET_CAIP2}:${mint}` : void 0;
+  }
+  if (typeof token.chainId !== "number") return void 0;
+  const address = isNativeAddress(token.address) ? PRICE_SERVICE_NATIVE : token.address;
+  return `${toEvmCaip2(token.chainId)}:${address.toLowerCase()}`;
+}
+async function fetchTokenPriceUsd(service, token) {
+  const caip2 = caip2For(token);
+  if (!caip2) return null;
+  const prices = await service.fetchPricesByAddress([caip2]);
+  const price = prices[caip2];
+  return typeof price === "number" && price > 0 ? price : null;
+}
+function useTokenPrices(service, tokens) {
+  const [prices, setPrices] = useState3({});
+  const defined = tokens.filter((t) => Boolean(t?.symbol));
+  const entries = [
+    ...new Map(
+      defined.flatMap((token) => {
+        const caip2 = caip2For(token);
+        return caip2 ? [{ symbol: token.symbol.toUpperCase(), caip2 }] : [];
+      }).map((entry) => [entry.caip2, entry])
+    ).values()
+  ].sort((a, b) => a.caip2.localeCompare(b.caip2));
+  const key = JSON.stringify(entries);
+  useEffect2(() => {
+    if (key === "[]") return;
+    let cancelled = false;
+    const parsed = JSON.parse(key);
+    const caip2Ids = [...new Set(parsed.map((e) => e.caip2))];
+    service.fetchPricesByAddress(caip2Ids).then((byAddress) => {
+      if (cancelled) return;
+      const merged = {};
+      for (const entry of parsed) {
+        const price = byAddress[entry.caip2];
+        if (typeof price === "number") merged[entry.symbol] = price;
+      }
+      setPrices(merged);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [service, key]);
+  return prices;
+}
+
 // src/components/steps/ProcessingStep.tsx
 import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function SuccessBadge() {
@@ -837,6 +852,9 @@ function getInitialProcessingState(event, txHash) {
   }
   return null;
 }
+function getSettledSourceTxHash(event, fallbackTxHash) {
+  return event?.data?.source?.transactionHash ?? fallbackTxHash;
+}
 function ProcessingStep({
   smartAccount,
   solanaDepositAddress,
@@ -850,6 +868,7 @@ function ProcessingStep({
   amountUsd,
   service,
   directTransfer,
+  sourceTxHashPending,
   initialEvent,
   flowLabel = "deposit",
   debug,
@@ -959,20 +978,26 @@ function ProcessingStep({
     if (!outcome) return;
     if (outcome.type === "complete") {
       const context = processingContextRef.current;
+      const sourceTxHash2 = getSettledSourceTxHash(event, txHash);
       debugLog(debug, "processing", "initial-event:complete", {
         txHash,
+        sourceTxHash: sourceTxHash2,
         destinationTxHash: outcome.destinationTxHash,
         event: event.type
       });
-      onDepositCompleteRef.current?.(txHash, outcome.destinationTxHash, {
-        amount: context.amount,
-        sourceChain: context.sourceChain,
-        sourceToken: context.sourceToken,
-        sourceDecimals: context.sourceDecimals,
-        amountUsd: context.amountUsd,
-        targetChain: context.targetChain,
-        targetToken: context.targetToken
-      });
+      onDepositCompleteRef.current?.(
+        sourceTxHash2,
+        outcome.destinationTxHash,
+        {
+          amount: context.amount,
+          sourceChain: context.sourceChain,
+          sourceToken: context.sourceToken,
+          sourceDecimals: context.sourceDecimals,
+          amountUsd: context.amountUsd,
+          targetChain: context.targetChain,
+          targetToken: context.targetToken
+        }
+      );
       return;
     }
     debugLog(debug, "processing", "initial-event:failed", {
@@ -1101,14 +1126,19 @@ function ProcessingStep({
         if (!isMounted) return;
         if (eventForCurrentTx?.type === "bridge-complete") {
           setState({ type: "complete", lastEvent: eventForCurrentTx });
+          const sourceTxHash2 = getSettledSourceTxHash(
+            eventForCurrentTx,
+            txHash
+          );
           const destinationTxHash2 = eventForCurrentTx.data?.destination?.transactionHash;
           debugLog(debug, "processing", "state:complete", {
             txHash,
+            sourceTxHash: sourceTxHash2,
             destinationTxHash: destinationTxHash2,
             event: eventForCurrentTx.type
           });
           const context = processingContextRef.current;
-          onDepositCompleteRef.current?.(txHash, destinationTxHash2, {
+          onDepositCompleteRef.current?.(sourceTxHash2, destinationTxHash2, {
             amount: context.amount,
             sourceChain: context.sourceChain,
             sourceToken: context.sourceToken,
@@ -1219,12 +1249,15 @@ function ProcessingStep({
   const flowNoun = flowLabel === "withdraw" ? "withdrawal" : "deposit";
   const flowCapitalized = flowLabel === "withdraw" ? "Withdrawal" : "Deposit";
   const destinationTxHash = lastEvent?.data?.destination?.transactionHash || null;
+  const sourceTxHash = getSettledSourceTxHash(lastEvent, txHash);
   const sourceDetails = getEventSourceDetails(lastEvent);
   const displaySourceChain = sourceDetails.chainId ?? sourceChain;
   const displaySourceToken = sourceDetails.token ?? sourceToken;
   const displayAmount = sourceDetails.amount ?? amount;
   const targetChainId = targetChainToChainId(targetChain);
-  const sourceExplorerUrl = explorerTxUrl(displaySourceChain, txHash);
+  const settledSourceTxHash = lastEvent?.data?.source?.transactionHash;
+  const sourceExplorerHash = settledSourceTxHash ?? (sourceTxHashPending ? null : sourceTxHash);
+  const sourceExplorerUrl = sourceExplorerHash ? explorerTxUrl(displaySourceChain, sourceExplorerHash) : null;
   const destExplorerUrl = destinationTxHash ? explorerTxUrl(targetChainId, destinationTxHash) : null;
   const sourceDisplay = (() => {
     const resolved = resolveTokenDisplay(displaySourceToken, displaySourceChain, {
@@ -1748,6 +1781,8 @@ export {
   getExchangeLogoSrc,
   getExchangeLogo,
   Tooltip,
+  markSubmissionUncertain,
+  isSubmissionUncertain,
   getEventTxHash,
   getEventSourceDetails,
   isDepositEvent,

package/dist/chunk-CVGNCUVU.cjs

@@ -0,0 +1,154 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkZMT4ATHRcjs = require('./chunk-ZMT4ATHR.cjs');
+
+
+var _chunkGACIGCSNcjs = require('./chunk-GACIGCSN.cjs');
+
+// src/core/recovery.ts
+var RECOVER_DOMAIN = {
+  name: "Rhinestone Deposit Recovery",
+  version: "1"
+};
+var RECOVER_TYPES = {
+  RecoverDeposit: [
+    { name: "depositId", type: "uint256" },
+    { name: "destination", type: "address" }
+  ]
+};
+var RecoveryError = class extends Error {
+  constructor(message, status, code, retryable = false) {
+    super(message);
+    this.name = "RecoveryError";
+    this.status = status;
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+function formatRecoveryError(status, code, serverMessage) {
+  switch (code) {
+    case "DEPOSIT_NOT_RECOVERABLE":
+      return {
+        message: "This deposit can't be recovered \u2014 it may already have been claimed.",
+        retryable: false
+      };
+    case "RECOVERY_UNSUPPORTED":
+      return {
+        message: "This deposit can't be recovered automatically. Contact support to get your funds back.",
+        retryable: false
+      };
+    case "SIGNATURE_INVALID":
+      return {
+        message: "That signature wasn't accepted for this wallet. Contact support to recover this deposit.",
+        retryable: false
+      };
+    case "VERIFICATION_UNAVAILABLE":
+      return {
+        message: "Couldn't verify your signature just now. Try again shortly.",
+        retryable: true
+      };
+    case "REFUND_RECONCILIATION_REQUIRED":
+      return {
+        message: "Your recovery is being reviewed. Contact support with this deposit if it doesn't arrive.",
+        retryable: false
+      };
+    case "REFUND_FAILED":
+      return {
+        message: _nullishCoalesce(serverMessage, () => ( "The recovery couldn't be completed. Please try again or contact support.")),
+        retryable: true
+      };
+    default:
+      if (status === 0) {
+        return {
+          message: "Couldn't reach the recovery service. Check your connection and try again.",
+          retryable: true
+        };
+      }
+      return {
+        message: _nullishCoalesce(serverMessage, () => ( "The recovery couldn't be completed. Please try again or contact support.")),
+        retryable: true
+      };
+  }
+}
+async function submitSignedRecovery(params) {
+  const { backendUrl, chainId, depositId, signer, destination, signRecovery, debug } = params;
+  const scope = "service:recovery";
+  const typedData = {
+    domain: RECOVER_DOMAIN,
+    types: RECOVER_TYPES,
+    primaryType: "RecoverDeposit",
+    message: { depositId: BigInt(depositId), destination }
+  };
+  let signature;
+  try {
+    signature = await signRecovery({
+      typedData,
+      chainId,
+      signer,
+      depositId,
+      destination
+    });
+  } catch (error) {
+    _chunkZMT4ATHRcjs.debugError.call(void 0, debug, scope, "signRecovery:failed", error);
+    throw new RecoveryError(
+      "Signature request was declined. Approve it in your wallet to recover this deposit.",
+      0,
+      void 0,
+      true
+    );
+  }
+  if (!signature) {
+    throw new RecoveryError(
+      "Signature request was declined. Approve it in your wallet to recover this deposit.",
+      0,
+      void 0,
+      true
+    );
+  }
+  const url = `${backendUrl.replace(/\/$/, "")}/deposits/recover`;
+  _chunkZMT4ATHRcjs.debugLog.call(void 0, debug, scope, "submitSignedRecovery:request", {
+    url,
+    depositId,
+    signer
+  });
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      // The shared const, so recovery carries `x-deposit-modal-version` like
+      // every other backend call. Without it this path would be invisible in the
+      // per-client version telemetry the processor records.
+      headers: _chunkGACIGCSNcjs.serviceHeaders.call(void 0, ),
+      // `depositId` as a string: it is a uint256 upstream and JSON numbers lose
+      // precision well before that range.
+      body: JSON.stringify({ depositId, destination, signature })
+    });
+  } catch (error) {
+    _chunkZMT4ATHRcjs.debugError.call(void 0, debug, scope, "submitSignedRecovery:network", error);
+    const { message, retryable } = formatRecoveryError(0);
+    throw new RecoveryError(message, 0, void 0, retryable);
+  }
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    _chunkZMT4ATHRcjs.debugError.call(void 0, debug, scope, "submitSignedRecovery:failed", body, {
+      status: response.status
+    });
+    const { message, retryable } = formatRecoveryError(
+      response.status,
+      body.code,
+      body.error
+    );
+    throw new RecoveryError(message, response.status, body.code, retryable);
+  }
+  const result = await response.json();
+  _chunkZMT4ATHRcjs.debugLog.call(void 0, debug, scope, "submitSignedRecovery:success", {
+    transactionHash: result.transactionHash
+  });
+  return result;
+}
+
+
+
+
+exports.RecoveryError = RecoveryError; exports.submitSignedRecovery = submitSignedRecovery;