@rhinestone/deposit-modal 0.12.2 → 0.13.0

package/dist/embed.mjs

@@ -0,0 +1,1268 @@
+import {
+  DepositModalInner
+} from "./chunk-DSIZNRWA.mjs";
+import {
+  markSubmissionUncertain
+} from "./chunk-COCBCQQC.mjs";
+import "./chunk-YREVFB64.mjs";
+import "./chunk-XYJFEN5D.mjs";
+import {
+  primeRuntimeChains
+} from "./chunk-EOMT5LKX.mjs";
+import {
+  MODAL_VERSION,
+  setEmbedHost
+} from "./chunk-FZ5FZFIG.mjs";
+import "./chunk-RN5VKWI6.mjs";
+import {
+  HYPERCORE_SPOT_CAIP2,
+  getChainName
+} from "./chunk-VUATPOWJ.mjs";
+
+// src/embed.tsx
+import { Suspense, lazy, useCallback, useEffect, useRef, useState } from "react";
+
+// src/core/bridge/protocol.ts
+var PROTOCOL_VERSION = 2;
+var PAGE_TO_HOST_CHANNEL = "rhinestoneBridge";
+var HOST_TO_PAGE_CHANNEL = "__rhinestone_bridge";
+var MAX_FRAME_LENGTH = 256 * 1024;
+var BRIDGE_METHOD = {
+  /** Page→host, first frame of the session. Answers `HelloResult`. */
+  HELLO: "hello",
+  /** Page→host: a CAIP-27 wallet request, `Caip27Params`. */
+  WALLET_REQUEST: "wallet.request",
+  /** Page→host: withdraw's transfer. Gated by `CAPABILITY.SEND_TRANSACTION`. */
+  SEND_TRANSACTION: "host.sendTransaction",
+  /** Page→host: claim's signature. Gated by `CAPABILITY.SIGN_RECOVERY`. */
+  SIGN_RECOVERY: "host.signRecovery",
+  /** Page→host: show a payment page outside the web view. Gated by
+   *  `CAPABILITY.OPEN_URL`. */
+  OPEN_URL: "host.openUrl"
+};
+var HOST_METHOD = {
+  /** Host→page: Android's hardware back and iOS's interactive swipe. Answers
+   *  `UiBackResult`. */
+  BACK: "ui.back"
+};
+var CAPABILITY = {
+  SEND_TRANSACTION: BRIDGE_METHOD.SEND_TRANSACTION,
+  SIGN_RECOVERY: BRIDGE_METHOD.SIGN_RECOVERY,
+  OPEN_URL: BRIDGE_METHOD.OPEN_URL
+};
+var ALLOWED_WALLET_METHODS = [
+  "eth_chainId",
+  "eth_accounts",
+  "eth_sendTransaction",
+  "wallet_sendTransaction",
+  "eth_signTypedData_v4",
+  "wallet_switchEthereumChain"
+];
+var SUBMITTING_WALLET_METHODS = [
+  "eth_sendTransaction",
+  "wallet_sendTransaction"
+];
+var BRIDGE_ERROR_DOMAIN = "bridge";
+var BridgeErrorCode = {
+  /** The host has a wallet but cannot reach it — app not installed, session
+   *  dropped mid-request. Distinct from 4900, which means not connected. */
+  WALLET_UNAVAILABLE: 1,
+  /**
+   * The host cannot say whether the transaction reached the network.
+   *
+   * An app switch can be killed by the OS between wallet submission and the
+   * return trip. Without a code for it the host must lie in one direction or
+   * the other, and the safe-looking lie — reporting failure — is the one that
+   * double-spends. The page shows its existing "status is uncertain" copy and
+   * must not offer a retry.
+   */
+  SUBMISSION_UNCERTAIN: 2,
+  /** The page's own deadline expired. Raised page-side, never sent by a host. */
+  REQUEST_TIMEOUT: 3,
+  /** The channel went away with the request outstanding. */
+  CHANNEL_CLOSED: 4,
+  /** The host answered, but not with something the method can return — a null
+   *  transaction hash, an `eth_accounts` that is not an array. */
+  MALFORMED_RESULT: 5
+};
+function bridgeError(code, message, data) {
+  return { domain: BRIDGE_ERROR_DOMAIN, code, message, data };
+}
+
+// src/core/bridge/channel.ts
+var NoHostChannelError = class extends Error {
+  constructor() {
+    super(
+      `No host channel: window.${PAGE_TO_HOST_CHANNEL}.postMessage is not installed`
+    );
+    this.name = "NoHostChannelError";
+  }
+};
+function readHostChannel(target) {
+  const candidate = target[PAGE_TO_HOST_CHANNEL];
+  if (!candidate || typeof candidate.postMessage !== "function") {
+    return void 0;
+  }
+  return candidate;
+}
+function createWindowChannel(target, onInvalidFrame) {
+  return {
+    post(json) {
+      const host = readHostChannel(target);
+      if (!host) throw new NoHostChannelError();
+      host.postMessage(json);
+    },
+    subscribe(onFrame) {
+      const receiver = (frame) => {
+        if (typeof frame !== "string") {
+          onInvalidFrame?.();
+          return;
+        }
+        onFrame(frame);
+      };
+      target[HOST_TO_PAGE_CHANNEL] = receiver;
+      return () => {
+        if (target[HOST_TO_PAGE_CHANNEL] === receiver) {
+          delete target[HOST_TO_PAGE_CHANNEL];
+        }
+      };
+    }
+  };
+}
+
+// src/core/bridge/transport.ts
+import { BaseError } from "viem";
+
+// src/core/bridge/envelope.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isBridgeError(value) {
+  if (!isRecord(value)) return false;
+  if (!isFiniteNumber(value.code)) return false;
+  if (typeof value.message !== "string") return false;
+  if (value.data !== void 0 && typeof value.data !== "string") return false;
+  if (value.domain !== void 0 && value.domain !== BRIDGE_ERROR_DOMAIN) {
+    return false;
+  }
+  return true;
+}
+function parseEnvelope(raw) {
+  if (raw.length > MAX_FRAME_LENGTH) return { ok: false, reason: "too-large" };
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { ok: false, reason: "not-json" };
+  }
+  if (!isRecord(value)) return { ok: false, reason: "not-an-object" };
+  switch (value.kind) {
+    case "event": {
+      if (!isNonEmptyString(value.type)) {
+        return { ok: false, reason: "bad-event" };
+      }
+      return { ok: true, envelope: value };
+    }
+    case "request": {
+      if (!isNonEmptyString(value.id) || !isNonEmptyString(value.method)) {
+        return { ok: false, reason: "bad-request" };
+      }
+      return { ok: true, envelope: value };
+    }
+    case "response": {
+      if (!isNonEmptyString(value.id)) {
+        return { ok: false, reason: "bad-response" };
+      }
+      if (value.ok === true) {
+        if (!("result" in value)) {
+          return { ok: false, reason: "bad-response" };
+        }
+        return { ok: true, envelope: value };
+      }
+      if (value.ok === false && isBridgeError(value.error)) {
+        return { ok: true, envelope: value };
+      }
+      return { ok: false, reason: "bad-response" };
+    }
+    default:
+      return { ok: false, reason: "unknown-kind" };
+  }
+}
+
+// src/core/bridge/transport.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var USER_APPROVAL_TIMEOUT_MS = 18e4;
+function emptyStats() {
+  return {
+    "too-large": 0,
+    "not-json": 0,
+    "not-an-object": 0,
+    "unknown-kind": 0,
+    "bad-event": 0,
+    "bad-request": 0,
+    "bad-response": 0,
+    "not-a-string": 0,
+    "unknown-event": 0,
+    "unknown-method": 0,
+    "unmatched-response": 0,
+    "duplicate-request": 0,
+    closed: 0
+  };
+}
+var BridgeRequestError = class extends BaseError {
+  constructor(error) {
+    super(error.message, { name: "BridgeRequestError" });
+    this.code = error.code;
+    this.domain = error.domain;
+    Object.defineProperty(this, "data", {
+      value: error.data,
+      enumerable: false,
+      writable: false
+    });
+  }
+};
+function isBridgeRequestError(error) {
+  return error instanceof BridgeRequestError;
+}
+function isBridgeCode(error, code) {
+  return isBridgeRequestError(error) && error.domain === BRIDGE_ERROR_DOMAIN && error.code === code;
+}
+function randomSessionId() {
+  const bytes = new Uint8Array(16);
+  const webcrypto = globalThis.crypto;
+  if (webcrypto?.getRandomValues) {
+    webcrypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var REPLAY_CACHE_SIZE = 32;
+function createBridgeTransport(options) {
+  const { channel } = options;
+  const sessionId = options.sessionId ?? randomSessionId();
+  const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const stats = emptyStats();
+  const pending = /* @__PURE__ */ new Map();
+  const inbound = /* @__PURE__ */ new Map();
+  const handlers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let counter = 0;
+  let closed = false;
+  const unsubscribe = channel.subscribe(onFrame);
+  function drop(reason) {
+    stats[reason] += 1;
+  }
+  function send(frame) {
+    channel.post(JSON.stringify(frame));
+  }
+  function notifyPending() {
+    options.onPendingChange?.(pending.size);
+  }
+  function forgetPending(id) {
+    const entry = pending.get(id);
+    if (!entry) return void 0;
+    pending.delete(id);
+    notifyPending();
+    return entry;
+  }
+  function settle(id, settleWith) {
+    const entry = forgetPending(id);
+    if (!entry) {
+      drop("unmatched-response");
+      return;
+    }
+    if (entry.timer !== void 0) clearTimeout(entry.timer);
+    settleWith(entry);
+  }
+  function onFrame(raw) {
+    if (closed) {
+      drop("closed");
+      return;
+    }
+    const parsed = parseEnvelope(raw);
+    if (!parsed.ok) {
+      drop(parsed.reason);
+      return;
+    }
+    const envelope = parsed.envelope;
+    if (envelope.kind === "response") {
+      settle(envelope.id, (entry) => {
+        if (envelope.ok) entry.resolve(envelope.result);
+        else entry.reject(new BridgeRequestError(envelope.error));
+      });
+      return;
+    }
+    if (envelope.kind === "event") {
+      const listener = listeners.get(envelope.type);
+      if (!listener) {
+        drop("unknown-event");
+        return;
+      }
+      listener(envelope.payload);
+      return;
+    }
+    void answer(envelope.id, envelope.method, envelope.params);
+  }
+  function settleInbound(id, response) {
+    inbound.set(id, { status: "settled", response });
+    if (inbound.size > REPLAY_CACHE_SIZE) {
+      for (const [key, value] of inbound) {
+        if (key !== id && value.status === "settled") {
+          inbound.delete(key);
+          break;
+        }
+      }
+    }
+    send(response);
+  }
+  async function answer(id, method, params) {
+    const seen = inbound.get(id);
+    if (seen) {
+      drop("duplicate-request");
+      if (seen.status === "settled") send(seen.response);
+      return;
+    }
+    const handler = handlers.get(method);
+    if (!handler) {
+      drop("unknown-method");
+      send({
+        kind: "response",
+        id,
+        ok: false,
+        error: { code: 4200, message: `Unsupported method: ${method}` }
+      });
+      return;
+    }
+    inbound.set(id, { status: "running" });
+    try {
+      const result = await handler(params);
+      settleInbound(id, { kind: "response", id, ok: true, result: result ?? null });
+    } catch (error) {
+      settleInbound(id, {
+        kind: "response",
+        id,
+        ok: false,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : "Page error"
+        }
+      });
+    }
+  }
+  return {
+    stats,
+    request(method, params, requestOptions) {
+      if (closed) {
+        return Promise.reject(
+          new BridgeRequestError(
+            bridgeError(
+              BridgeErrorCode.CHANNEL_CLOSED,
+              "The connection to the app closed."
+            )
+          )
+        );
+      }
+      counter += 1;
+      const id = `${sessionId}.${counter}`;
+      const timeoutMs = requestOptions?.timeoutMs ?? defaultTimeoutMs;
+      return new Promise((resolve, reject) => {
+        const timer = timeoutMs > 0 ? setTimeout(() => {
+          forgetPending(id);
+          reject(
+            new BridgeRequestError(
+              requestOptions?.uncertainOnTimeout ? bridgeError(
+                BridgeErrorCode.SUBMISSION_UNCERTAIN,
+                "The app did not confirm whether the transaction was sent."
+              ) : bridgeError(
+                BridgeErrorCode.REQUEST_TIMEOUT,
+                "The app did not respond."
+              )
+            )
+          );
+        }, timeoutMs) : void 0;
+        pending.set(id, {
+          resolve,
+          reject,
+          timer
+        });
+        notifyPending();
+        try {
+          send({ kind: "request", id, method, params });
+        } catch (error) {
+          forgetPending(id);
+          if (timer !== void 0) clearTimeout(timer);
+          reject(
+            error instanceof NoHostChannelError ? new BridgeRequestError(
+              bridgeError(
+                BridgeErrorCode.CHANNEL_CLOSED,
+                "The connection to the app closed."
+              )
+            ) : error
+          );
+        }
+      });
+    },
+    emit(type, payload) {
+      if (closed) return;
+      try {
+        send({ kind: "event", type, payload });
+      } catch {
+      }
+    },
+    handle(method, handler) {
+      handlers.set(method, handler);
+    },
+    on(type, handler) {
+      listeners.set(type, handler);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      unsubscribe();
+      const closing = new BridgeRequestError(
+        bridgeError(
+          BridgeErrorCode.CHANNEL_CLOSED,
+          "The connection to the app closed."
+        )
+      );
+      for (const [, entry] of pending) {
+        if (entry.timer !== void 0) clearTimeout(entry.timer);
+        entry.reject(closing);
+      }
+      pending.clear();
+      notifyPending();
+    }
+  };
+}
+
+// src/core/bridge/validate.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var TX_HASH = /^0x[0-9a-fA-F]{64}$/;
+var HEX = /^0x[0-9a-fA-F]+$/;
+function isTxHash(value) {
+  return typeof value === "string" && TX_HASH.test(value);
+}
+function isHex(value) {
+  return typeof value === "string" && HEX.test(value);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function parseWalletState(value) {
+  if (!isRecord2(value)) return void 0;
+  if (typeof value.isReady !== "boolean") return void 0;
+  if (typeof value.isConnected !== "boolean") return void 0;
+  if (!Array.isArray(value.accounts)) return void 0;
+  const accounts = [];
+  for (const entry of value.accounts) {
+    if (isRecord2(entry) && typeof entry.caip10 === "string") {
+      accounts.push({ caip10: entry.caip10 });
+    }
+  }
+  const chainId = typeof value.chainId === "string" ? value.chainId : value.chainId === null ? null : void 0;
+  if (chainId === void 0) return void 0;
+  return {
+    isReady: value.isReady,
+    isConnected: value.isConnected,
+    accounts,
+    chainId,
+    icon: optionalString(value.icon),
+    name: optionalString(value.name)
+  };
+}
+function parseHelloResult(value) {
+  if (!isRecord2(value)) return void 0;
+  if (typeof value.protocol !== "number" || !Number.isFinite(value.protocol)) {
+    return void 0;
+  }
+  const host = isRecord2(value.host) ? value.host : void 0;
+  if (!host) return void 0;
+  const platform = host.platform === "ios" || host.platform === "android" ? host.platform : "other";
+  const wallet = parseWalletState(value.wallet);
+  if (!wallet) return void 0;
+  if (!isRecord2(value.config)) return void 0;
+  const capabilities = Array.isArray(value.capabilities) ? value.capabilities.filter(
+    (entry) => typeof entry === "string"
+  ) : [];
+  return {
+    protocol: value.protocol,
+    host: {
+      platform,
+      app: optionalString(host.app),
+      version: optionalString(host.version)
+    },
+    capabilities,
+    config: value.config,
+    wallet
+  };
+}
+
+// src/core/bridge/wallet.ts
+import { createWalletClient, custom } from "viem";
+var ALLOWED = new Set(ALLOWED_WALLET_METHODS);
+var SWITCH_CONFIRMATION_TIMEOUT_MS = 15e3;
+var HASH_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+var HEX_PATTERN = /^0x[0-9a-fA-F]*$/;
+function evmAccount(state) {
+  return state.accounts.find((account) => account.caip10.startsWith("eip155:"))?.caip10;
+}
+function evmAddressFrom(state) {
+  const caip10 = evmAccount(state);
+  if (!caip10) return void 0;
+  const parts = caip10.split(":");
+  return parts.length === 3 ? parts[2] : void 0;
+}
+function evmChainIdFrom(caip2) {
+  if (!caip2) return void 0;
+  const parts = caip2.split(":");
+  if (parts.length !== 2 || parts[0] !== "eip155") return void 0;
+  const id = Number(parts[1]);
+  return Number.isInteger(id) && id > 0 ? id : void 0;
+}
+function switchTargetChainId(params) {
+  const first = Array.isArray(params) ? params[0] : void 0;
+  if (typeof first !== "object" || first === null) return void 0;
+  const hex = first.chainId;
+  if (typeof hex !== "string") return void 0;
+  const id = Number.parseInt(hex, 16);
+  return Number.isInteger(id) && id > 0 ? id : void 0;
+}
+function syntheticChain(chainId) {
+  return {
+    id: chainId,
+    name: getChainName(chainId),
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [] } }
+  };
+}
+function assertResultShape(method, result) {
+  const bad = (detail) => {
+    const error = new BridgeRequestError(
+      bridgeError(
+        BridgeErrorCode.MALFORMED_RESULT,
+        "The app returned something unexpected. Check your wallet activity before trying again.",
+        `${method}: ${detail}`
+      )
+    );
+    throw SUBMITTING_WALLET_METHODS.includes(method) ? markSubmissionUncertain(error) : error;
+  };
+  switch (method) {
+    case "eth_sendTransaction":
+    case "wallet_sendTransaction":
+      if (typeof result !== "string" || !HASH_PATTERN.test(result)) {
+        bad("expected a 32-byte transaction hash");
+      }
+      return;
+    case "eth_signTypedData_v4":
+      if (typeof result !== "string" || !HEX_PATTERN.test(result)) {
+        bad("expected a hex signature");
+      }
+      return;
+    case "eth_chainId":
+      if (typeof result !== "string" || !HEX_PATTERN.test(result)) {
+        bad("expected a hex quantity");
+      }
+      return;
+    case "eth_accounts":
+      if (!Array.isArray(result)) bad("expected an array of addresses");
+      return;
+    default:
+      return;
+  }
+}
+function createBridgedWalletSession(options) {
+  let state = options.state;
+  const { transport, resolveChain } = options;
+  let cachedClient;
+  let cachedKey;
+  const stateWaiters = /* @__PURE__ */ new Set();
+  async function walletRequest(method, params) {
+    if (!ALLOWED.has(method)) {
+      throw new Error(`Method not supported over the bridge: ${method}`);
+    }
+    const target = switchTargetChainId(params);
+    const chainId = target !== void 0 ? `eip155:${target}` : state.chainId ?? void 0;
+    if (!chainId) {
+      throw new Error("No chain selected for this wallet request");
+    }
+    const submitting = SUBMITTING_WALLET_METHODS.includes(method);
+    const caip27 = { chainId, request: { method, params } };
+    let result;
+    try {
+      result = await transport.request(
+        BRIDGE_METHOD.WALLET_REQUEST,
+        caip27,
+        { timeoutMs: USER_APPROVAL_TIMEOUT_MS, uncertainOnTimeout: submitting }
+      );
+    } catch (error) {
+      if (submitting && isBridgeRequestError(error) && error.code === -32603) {
+        throw markSubmissionUncertain(
+          new BridgeRequestError(
+            bridgeError(
+              BridgeErrorCode.SUBMISSION_UNCERTAIN,
+              "The app could not confirm whether the transaction was sent. Check your wallet activity before trying again.",
+              error.data
+            )
+          )
+        );
+      }
+      if (submitting && isBridgeCode(error, BridgeErrorCode.SUBMISSION_UNCERTAIN)) {
+        throw markSubmissionUncertain(error);
+      }
+      throw error;
+    }
+    assertResultShape(method, result);
+    return result;
+  }
+  const evmTransport = custom({
+    async request({ method, params }) {
+      return walletRequest(method, params);
+    }
+  });
+  function currentClient() {
+    const address = evmAddressFrom(state);
+    const chainId = evmChainIdFrom(state.chainId);
+    if (!address || chainId === void 0) return void 0;
+    const chain = resolveChain(chainId) ?? syntheticChain(chainId);
+    const key = `${address}:${chainId}`;
+    if (cachedClient && cachedKey === key) return cachedClient;
+    cachedClient = createWalletClient({
+      account: address,
+      chain,
+      transport: evmTransport
+    });
+    cachedKey = key;
+    return cachedClient;
+  }
+  function awaitChain(chainId) {
+    if (evmChainIdFrom(state.chainId) === chainId) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      let timer;
+      const waiter = (next) => {
+        if (evmChainIdFrom(next.chainId) !== chainId) return;
+        if (timer !== void 0) clearTimeout(timer);
+        stateWaiters.delete(waiter);
+        resolve();
+      };
+      timer = setTimeout(() => {
+        stateWaiters.delete(waiter);
+        reject(
+          new Error(
+            `Switch to ${resolveChain(chainId)?.name ?? getChainName(chainId)} in your wallet to continue`
+          )
+        );
+      }, SWITCH_CONFIRMATION_TIMEOUT_MS);
+      stateWaiters.add(waiter);
+    });
+  }
+  const session = {
+    get walletClient() {
+      return currentClient();
+    },
+    get canSignEvm() {
+      return state.isConnected && currentClient() !== void 0;
+    },
+    // Reads fall back to `getPublicClient`; a bridged host has no
+    // wallet-backed client to offer.
+    publicClient: void 0,
+    get address() {
+      return evmAddressFrom(state);
+    },
+    get caipAddress() {
+      return evmAccount(state);
+    },
+    get isConnected() {
+      return state.isConnected;
+    },
+    get isReady() {
+      return state.isReady;
+    },
+    get icon() {
+      return state.icon;
+    },
+    isSolana: false,
+    solanaAddress: void 0,
+    solanaProvider: void 0,
+    solanaConnection: void 0,
+    openConnect: () => transport.emit("wallet.connectRequested"),
+    disconnect: () => transport.emit("wallet.disconnectRequested"),
+    switchChain: async (chainId) => {
+      try {
+        await walletRequest("wallet_switchEthereumChain", [
+          { chainId: `0x${chainId.toString(16)}` }
+        ]);
+      } catch (error) {
+        if (isBridgeRequestError(error)) throw new Error(error.message);
+        throw error;
+      }
+      await awaitChain(chainId);
+    }
+  };
+  return {
+    session,
+    applyWalletState(next) {
+      state = next;
+      for (const waiter of [...stateWaiters]) waiter(next);
+      options.onStateChange?.(next);
+    }
+  };
+}
+
+// src/core/bridge/connect.ts
+var BridgeHandshakeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BridgeHandshakeError";
+  }
+};
+async function connectToHost(options) {
+  let invalidFrames = 0;
+  const channel = createWindowChannel(options.target, () => {
+    invalidFrames += 1;
+  });
+  const transport = createBridgeTransport({
+    channel,
+    onPendingChange: options.onPendingChange
+  });
+  const params = {
+    protocol: PROTOCOL_VERSION,
+    modalVersion: MODAL_VERSION
+  };
+  let raw;
+  try {
+    raw = await transport.request(BRIDGE_METHOD.HELLO, params, {
+      timeoutMs: options.helloTimeoutMs
+    });
+  } catch (error) {
+    transport.close();
+    throw error;
+  }
+  const hello = parseHelloResult(raw);
+  if (!hello) {
+    transport.close();
+    throw new BridgeHandshakeError(
+      invalidFrames > 0 ? "The app answered the handshake with something that was not a string frame." : "The app answered the handshake with an unusable payload."
+    );
+  }
+  let config = hello.config;
+  const wallet = createBridgedWalletSession({
+    transport,
+    state: hello.wallet,
+    resolveChain: options.resolveChain,
+    onStateChange: options.onWalletState
+  });
+  transport.on("wallet.state", (payload) => {
+    const next = parseWalletState(payload);
+    if (next) wallet.applyWalletState(next);
+  });
+  transport.on("session.configure", (payload) => {
+    if (typeof payload !== "object" || payload === null) return;
+    config = payload;
+    options.onConfig?.(config);
+  });
+  return {
+    transport,
+    hello,
+    wallet,
+    get config() {
+      return config;
+    },
+    close() {
+      transport.close();
+    }
+  };
+}
+
+// src/core/bridge/capabilities.ts
+async function requestHostTransfer(transport, params) {
+  let result;
+  try {
+    result = await transport.request(
+      BRIDGE_METHOD.SEND_TRANSACTION,
+      params,
+      { timeoutMs: USER_APPROVAL_TIMEOUT_MS, uncertainOnTimeout: true }
+    );
+  } catch (error) {
+    if (error instanceof Error && isBridgeCode(error, BridgeErrorCode.SUBMISSION_UNCERTAIN)) {
+      throw markSubmissionUncertain(error);
+    }
+    throw error;
+  }
+  if (!isTxHash(result?.txHash)) {
+    throw markSubmissionUncertain(
+      new Error(
+        "The app did not return a transaction hash. Check your activity before trying again."
+      )
+    );
+  }
+  return result.txHash;
+}
+async function requestHostRecoverySignature(transport, params) {
+  const result = await transport.request(
+    BRIDGE_METHOD.SIGN_RECOVERY,
+    params,
+    { timeoutMs: USER_APPROVAL_TIMEOUT_MS }
+  );
+  if (!isHex(result?.signature)) {
+    throw new Error("The app did not return a signature.");
+  }
+  return result.signature;
+}
+async function requestHostBrowser(transport, url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error("The payment page address could not be read.");
+  }
+  if (parsed.protocol !== "https:") {
+    throw new Error("The payment page address is not a secure link.");
+  }
+  await transport.request(BRIDGE_METHOD.OPEN_URL, {
+    url
+  });
+}
+
+// src/core/bridge/ui-state.ts
+var SETTLING_SCREENS = /* @__PURE__ */ new Set(["processing"]);
+var HOME_SCREENS = /* @__PURE__ */ new Set(["connect", "form", "lookup"]);
+function isHomeScreen(screen) {
+  return HOME_SCREENS.has(screen);
+}
+function dismissalFor(input) {
+  if (input.walletRequestPending) {
+    return {
+      state: "blocked",
+      reason: "wallet-request-pending",
+      message: "Waiting for your wallet."
+    };
+  }
+  if (input.submitting) {
+    return {
+      state: "blocked",
+      reason: "submission-in-flight",
+      message: "Confirming your deposit."
+    };
+  }
+  if (SETTLING_SCREENS.has(input.screen)) {
+    return {
+      state: "blocked",
+      reason: "settlement-in-progress",
+      message: "Your deposit is on its way."
+    };
+  }
+  return { state: "allowed" };
+}
+function canGoBackNow(input) {
+  return dismissalFor(input).state !== "blocked";
+}
+function uiStateFor(input) {
+  return { screen: input.screen, dismissal: dismissalFor(input) };
+}
+
+// src/core/bridge/viewport.ts
+var VIEWPORT_HEIGHT_PROPERTY = "--rs-embed-viewport-height";
+function trackVisualViewport(win) {
+  const target = win;
+  const viewport = target?.visualViewport;
+  const style = target?.document?.documentElement?.style;
+  if (!viewport || !style) return () => {
+  };
+  const apply = () => {
+    style.setProperty(VIEWPORT_HEIGHT_PROPERTY, `${viewport.height}px`);
+  };
+  apply();
+  viewport.addEventListener("resize", apply);
+  viewport.addEventListener("scroll", apply);
+  return () => {
+    viewport.removeEventListener("resize", apply);
+    viewport.removeEventListener("scroll", apply);
+    style.removeProperty(VIEWPORT_HEIGHT_PROPERTY);
+  };
+}
+
+// src/core/modal-ui-state.ts
+var UNKNOWN_SCREEN = "unknown";
+
+// src/embed.tsx
+import { jsx } from "react/jsx-runtime";
+var WithdrawModal = lazy(
+  () => import("./WithdrawModal-NVRX44IZ.mjs").then((m) => ({ default: m.WithdrawModal }))
+);
+var ClaimModal = lazy(
+  () => import("./ClaimModal-CREZO27I.mjs").then((m) => ({ default: m.ClaimModal }))
+);
+function missingField(config, keys) {
+  const missing = keys.find(
+    (key) => typeof config[key] !== "string" || config[key] === ""
+  );
+  return missing ? {
+    code: "EMBED_CONFIG_INVALID",
+    message: `The app did not supply ${String(missing)}.`
+  } : null;
+}
+var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+function isEvmAddress(value) {
+  return typeof value === "string" && EVM_ADDRESS.test(value);
+}
+function isEvmChainId(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function missingCapability(capabilities, needed, mode) {
+  return capabilities.includes(needed) ? null : {
+    code: "EMBED_CAPABILITY_MISSING",
+    message: `This app cannot run ${mode}: it does not implement ${needed}.`
+  };
+}
+function refusal(config, capabilities) {
+  switch (config.mode) {
+    case "deposit": {
+      const missing = missingField(config, [
+        "backendUrl",
+        "recipient",
+        "targetToken"
+      ]);
+      if (missing) return missing;
+      const { targetChain } = config;
+      const validTarget = typeof targetChain === "number" && Number.isInteger(targetChain) && targetChain > 0 || targetChain === "solana" || targetChain === HYPERCORE_SPOT_CAIP2;
+      return validTarget ? null : {
+        code: "EMBED_CONFIG_INVALID",
+        message: `The app supplied a targetChain this page cannot resolve: ${JSON.stringify(targetChain)}.`
+      };
+    }
+    case "withdraw": {
+      const capability = missingCapability(
+        capabilities,
+        CAPABILITY.SEND_TRANSACTION,
+        "a withdrawal"
+      );
+      if (capability) return capability;
+      const missing = missingField(config, ["backendUrl", "accountAddress"]);
+      if (missing) return missing;
+      const badWithdrawField = !isEvmAddress(config.accountAddress) && "accountAddress" || !isEvmChainId(config.sourceChain) && "sourceChain" || !isEvmAddress(config.sourceToken) && "sourceToken";
+      return badWithdrawField ? {
+        code: "EMBED_CONFIG_INVALID",
+        message: `The app supplied a ${badWithdrawField} this page cannot use.`
+      } : null;
+    }
+    case "claim": {
+      const capability = missingCapability(
+        capabilities,
+        CAPABILITY.SIGN_RECOVERY,
+        "a claim"
+      );
+      if (capability) return capability;
+      return missingField(config, ["backendUrl"]);
+    }
+    default:
+      return {
+        code: "EMBED_MODE_UNSUPPORTED",
+        message: `This page cannot run in ${String(config.mode ?? "an unnamed")} mode.`
+      };
+  }
+}
+function sanitizeConfig(config) {
+  const str = (value) => typeof value === "string" && value !== "" ? value : void 0;
+  const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  const bool = (value) => typeof value === "boolean" ? value : void 0;
+  const arr = (value) => Array.isArray(value) ? value : void 0;
+  const obj = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  const target = (value) => {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+      return value;
+    }
+    return value === "solana" || value === HYPERCORE_SPOT_CAIP2 ? value : void 0;
+  };
+  return {
+    // Raw, because it is the discriminant `refusal` switches on — anything
+    // else has to reach it to be named in the error.
+    mode: config.mode,
+    // Typed like everything else, even though `refusal` also checks them.
+    // Required is a property of the MODE, not of the field: `targetToken` and
+    // `recipient` are required for a deposit and optional seeds for a
+    // withdrawal, so passing them through raw let a withdraw config carry a
+    // non-string into `targetToken.toLowerCase()` and take the page down.
+    // Dropping first means `refusal` still fails the modes that need them, and
+    // the modes that do not simply see an absent seed.
+    backendUrl: str(config.backendUrl),
+    recipient: str(config.recipient),
+    targetChain: target(config.targetChain),
+    targetToken: str(config.targetToken),
+    sourceChain: num(config.sourceChain),
+    sourceToken: str(config.sourceToken),
+    defaultAmount: str(config.defaultAmount),
+    appBalanceUsd: num(config.appBalanceUsd),
+    outputTokenRules: arr(config.outputTokenRules),
+    rejectUnmapped: bool(config.rejectUnmapped),
+    forceRegister: bool(config.forceRegister),
+    enableWallet: bool(config.enableWallet),
+    enableFiatOnramp: bool(config.enableFiatOnramp),
+    enableQrTransfer: bool(config.enableQrTransfer),
+    enableGaslessDeposit: bool(config.enableGaslessDeposit),
+    enableExchangeConnect: bool(config.enableExchangeConnect),
+    fiatMethods: obj(config.fiatMethods),
+    assetMigrations: obj(config.assetMigrations),
+    initialAssetMigration: str(
+      config.initialAssetMigration
+    ),
+    theme: obj(config.theme),
+    uiConfig: obj(config.uiConfig),
+    debug: bool(config.debug),
+    accountAddress: str(config.accountAddress),
+    defaultTxHash: str(config.defaultTxHash),
+    defaultDestination: str(config.defaultDestination)
+  };
+}
+function onrampUnavailable(config, capabilities) {
+  if (config.mode !== "deposit") return null;
+  if (capabilities.includes(CAPABILITY.OPEN_URL)) return null;
+  if (!config.enableFiatOnramp && !config.enableExchangeConnect) return null;
+  return {
+    code: "EMBED_CAPABILITY_MISSING",
+    message: `Fiat and exchange funding are hidden: this app does not implement ${CAPABILITY.OPEN_URL}.`
+  };
+}
+function toModalProps(config, canOpenExternally) {
+  return {
+    isOpen: true,
+    // Native draws the sheet. Inline is what stops the page drawing a scrim
+    // and a second one inside it; the class carries back what an inline mount
+    // otherwise loses — safe-area clearance and the input sizing that stops
+    // iOS zooming on focus, both of which the stylesheet scopes to the overlay.
+    inline: true,
+    className: "rs-embed",
+    onClose: () => {
+    },
+    targetChain: config.targetChain,
+    targetToken: config.targetToken,
+    recipient: config.recipient,
+    backendUrl: config.backendUrl,
+    sourceChain: config.sourceChain,
+    sourceToken: config.sourceToken,
+    defaultAmount: config.defaultAmount,
+    appBalanceUsd: config.appBalanceUsd,
+    outputTokenRules: config.outputTokenRules,
+    rejectUnmapped: config.rejectUnmapped,
+    forceRegister: config.forceRegister,
+    enableWallet: config.enableWallet,
+    enableFiatOnramp: canOpenExternally && config.enableFiatOnramp,
+    enableQrTransfer: config.enableQrTransfer,
+    enableGaslessDeposit: config.enableGaslessDeposit,
+    enableExchangeConnect: canOpenExternally && config.enableExchangeConnect,
+    fiatMethods: config.fiatMethods,
+    assetMigrations: config.assetMigrations,
+    initialAssetMigration: config.initialAssetMigration,
+    theme: config.theme,
+    uiConfig: config.uiConfig,
+    debug: config.debug
+  };
+}
+function DepositEmbed({ target, onFatal }) {
+  const [session, setSession] = useState(null);
+  const [config, setConfig] = useState(null);
+  const [walletPending, setWalletPending] = useState(false);
+  const pendingRef = useRef(false);
+  const completedRef = useRef(false);
+  const uiRef = useRef({
+    screen: UNKNOWN_SCREEN,
+    submitting: false
+  });
+  const onFatalRef = useRef(onFatal);
+  onFatalRef.current = onFatal;
+  useEffect(
+    () => trackVisualViewport(target ?? globalThis.window),
+    [target]
+  );
+  useEffect(() => {
+    let live = true;
+    let opened = null;
+    let chains = [];
+    void (async () => {
+      try {
+        const next = await connectToHost({
+          target: target ?? globalThis.window,
+          resolveChain: (chainId) => chains.find((chain) => chain.id === chainId),
+          onConfig: (updated) => {
+            if (live) setConfig(sanitizeConfig(updated));
+          },
+          onPendingChange: (pending) => {
+            pendingRef.current = pending > 0;
+            if (live) setWalletPending(pending > 0);
+          }
+        });
+        if (!live) {
+          next.close();
+          return;
+        }
+        opened = next;
+        next.transport.handle(HOST_METHOD.BACK, () => {
+          if (!canGoBackNow({
+            ...uiRef.current,
+            walletRequestPending: pendingRef.current
+          })) {
+            return { handled: true };
+          }
+          const back = uiRef.current.back;
+          back?.();
+          return { handled: Boolean(back) };
+        });
+        setEmbedHost(next.hello.host);
+        setSession(next);
+        setConfig(sanitizeConfig(next.hello.config));
+        void primeRuntimeChains(next.hello.config.backendUrl).then((result) => {
+          chains = result;
+        });
+      } catch (error) {
+        if (live) onFatalRef.current?.(error);
+      }
+    })();
+    return () => {
+      live = false;
+      opened?.close();
+      setEmbedHost(null);
+    };
+  }, [target]);
+  const handleUiState = useCallback(
+    (state) => {
+      if (isHomeScreen(state.screen)) completedRef.current = false;
+      uiRef.current = state;
+      session?.transport.emit(
+        "ui.state",
+        uiStateFor({ ...state, walletRequestPending: walletPending })
+      );
+    },
+    [session, walletPending]
+  );
+  const openExternally = useCallback(
+    async (url) => {
+      if (!session) throw new Error("The app is not connected.");
+      await requestHostBrowser(session.transport, url);
+    },
+    [session]
+  );
+  useEffect(() => {
+    if (!session) return;
+    session.transport.emit(
+      "ui.state",
+      uiStateFor({ ...uiRef.current, walletRequestPending: walletPending })
+    );
+  }, [session, walletPending]);
+  const refused = config && session ? refusal(config, session.hello.capabilities) : null;
+  useEffect(() => {
+    if (!session || !refused) return;
+    session.transport.emit("error", refused);
+  }, [session, refused?.code, refused?.message]);
+  const onrampHidden = config && session && !refused ? onrampUnavailable(config, session.hello.capabilities) : null;
+  useEffect(() => {
+    if (!session || !onrampHidden) return;
+    session.transport.emit("error", onrampHidden);
+  }, [session, onrampHidden?.code, onrampHidden?.message]);
+  if (!session || !config || refused) return null;
+  const ready = config;
+  const { transport } = session;
+  const canOpenExternally = session.hello.capabilities.includes(CAPABILITY.OPEN_URL);
+  const shared = {
+    isOpen: true,
+    inline: true,
+    className: "rs-embed",
+    backendUrl: ready.backendUrl,
+    theme: config.theme,
+    uiConfig: config.uiConfig,
+    debug: config.debug,
+    onReady: () => transport.emit("ready"),
+    onEvent: (event) => transport.emit("analytics", event),
+    onError: (data) => transport.emit("error", data),
+    onClose: () => transport.emit("dismissRequested", {
+      source: completedRef.current ? "flow-complete" : "close-button"
+    })
+  };
+  if (ready.mode === "withdraw") {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      WithdrawModal,
+      {
+        ...shared,
+        accountAddress: ready.accountAddress,
+        sourceChain: ready.sourceChain,
+        sourceToken: ready.sourceToken,
+        targetChain: typeof ready.targetChain === "number" ? ready.targetChain : void 0,
+        targetToken: ready.targetToken,
+        recipient: ready.recipient,
+        defaultAmount: ready.defaultAmount,
+        forceRegister: ready.forceRegister,
+        onSendTransaction: async (request) => ({
+          txHash: await requestHostTransfer(transport, {
+            chainId: request.chainId,
+            token: request.token,
+            amount: request.amount.toString(),
+            to: request.to,
+            from: ready.accountAddress
+          })
+        }),
+        onUiState: handleUiState,
+        onLifecycle: (event) => {
+          if (event.type === "complete") completedRef.current = true;
+          transport.emit("lifecycle", event);
+        }
+      }
+    ) });
+  }
+  if (ready.mode === "claim") {
+    return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      ClaimModal,
+      {
+        ...shared,
+        defaultTxHash: ready.defaultTxHash,
+        defaultRefundDestination: ready.defaultDestination,
+        signRecovery: async ({ chainId, signer, depositId, destination }) => (
+          // The fields, not the struct: the host holds the canonical domain
+          // and types, so this cannot become a request to sign anything else.
+          await requestHostRecoverySignature(transport, {
+            chainId,
+            signer,
+            depositId,
+            destination
+          })
+        ),
+        onUiState: handleUiState,
+        onLifecycle: (event) => {
+          if (event.type === "complete") completedRef.current = true;
+          transport.emit("lifecycle", event);
+        }
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx(
+    DepositModalInner,
+    {
+      ...toModalProps(ready, canOpenExternally),
+      openExternally: canOpenExternally ? openExternally : void 0,
+      walletSession: session.wallet.session,
+      hasWalletClientProp: false,
+      onUiState: handleUiState,
+      onReady: () => session.transport.emit("ready"),
+      onLifecycle: (event) => {
+        if (event.type === "complete") completedRef.current = true;
+        session.transport.emit("lifecycle", event);
+      },
+      onEvent: (event) => session.transport.emit("analytics", event),
+      onError: (data) => session.transport.emit("error", data),
+      onClose: () => session.transport.emit("dismissRequested", {
+        source: completedRef.current ? "flow-complete" : "close-button"
+      })
+    }
+  );
+}
+export {
+  DepositEmbed
+};