@rhinestone/deposit-modal 0.12.2 → 0.14.0

package/dist/embed.cjs

@@ -0,0 +1,1476 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkYCQZJQO6cjs = require('./chunk-YCQZJQO6.cjs');
+
+
+var _chunk7ICSHJFEcjs = require('./chunk-7ICSHJFE.cjs');
+require('./chunk-X2IPAPXU.cjs');
+require('./chunk-LZFRL2AL.cjs');
+
+
+var _chunkV2OBGLJDcjs = require('./chunk-V2OBGLJD.cjs');
+
+
+
+var _chunk6KG642KHcjs = require('./chunk-6KG642KH.cjs');
+require('./chunk-DW2EQA2U.cjs');
+
+
+
+var _chunk4KCSH4T3cjs = require('./chunk-4KCSH4T3.cjs');
+
+// src/embed.tsx
+var _react = require('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",
+  /**
+   * Page→host, from a SUB-FRAME. Gated by `CAPABILITY.PROBE_FRAME_SCOPE`.
+   *
+   * The one request a host is meant to ignore. See `frame-scope.ts`: the page
+   * sends it from a frame that is not the main one, and a host that answers has
+   * proved it acts on sub-frame traffic — which means it would act on a wallet
+   * request from there too.
+   */
+  PROBE_FRAME_SCOPE: "bridge.probeFrameScope"
+};
+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,
+  PROBE_FRAME_SCOPE: BRIDGE_METHOD.PROBE_FRAME_SCOPE
+};
+var PAGE_EVENT = {
+  READY: "ready",
+  LIFECYCLE: "lifecycle",
+  ANALYTICS: "analytics",
+  ERROR: "error",
+  UI_STATE: "ui.state",
+  WALLET_CONNECT_REQUESTED: "wallet.connectRequested",
+  WALLET_DISCONNECT_REQUESTED: "wallet.disconnectRequested",
+  DISMISS_REQUESTED: "dismissRequested"
+};
+var PASSTHROUGH_EVENTS = [
+  PAGE_EVENT.LIFECYCLE,
+  PAGE_EVENT.ANALYTICS,
+  PAGE_EVENT.ERROR
+];
+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") {
+          _optionalChain([onInvalidFrame, 'optionalCall', _ => _()]);
+          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
+var _viem = require('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 (e) {
+    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 _viem.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 (_optionalChain([webcrypto, 'optionalAccess', _2 => _2.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 = _nullishCoalesce(options.sessionId, () => ( randomSessionId()));
+  const defaultTimeoutMs = _nullishCoalesce(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() {
+    let counted = 0;
+    for (const [, entry] of pending) if (entry.counted) counted += 1;
+    _optionalChain([options, 'access', _3 => _3.onPendingChange, 'optionalCall', _4 => _4(counted)]);
+  }
+  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: _nullishCoalesce(result, () => ( null)) });
+    } catch (error) {
+      settleInbound(id, {
+        kind: "response",
+        id,
+        ok: false,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : "Page error"
+        }
+      });
+    }
+  }
+  function issue(method, params, requestOptions, post, counted) {
+    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 = _nullishCoalesce(_optionalChain([requestOptions, 'optionalAccess', _5 => _5.timeoutMs]), () => ( defaultTimeoutMs));
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0 ? setTimeout(() => {
+        forgetPending(id);
+        reject(
+          new BridgeRequestError(
+            _optionalChain([requestOptions, 'optionalAccess', _6 => _6.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,
+        counted
+      });
+      notifyPending();
+      try {
+        post(JSON.stringify({ 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
+        );
+      }
+    });
+  }
+  return {
+    stats,
+    request(method, params, requestOptions) {
+      return issue(
+        method,
+        params,
+        requestOptions,
+        (json) => channel.post(json),
+        true
+      );
+    },
+    requestVia(post, method, params, requestOptions) {
+      return issue(method, params, requestOptions, post, false);
+    },
+    emit(type, payload) {
+      if (closed) return;
+      try {
+        send({ kind: "event", type, payload });
+      } catch (e2) {
+      }
+    },
+    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/frame-scope.ts
+var PROBE_TIMEOUT_MS = 750;
+var FRAME_OPEN_TIMEOUT_MS = 150;
+var PROBE_MARKER_ID = "rs-frame-probe";
+function subFramePosters(inner) {
+  const posters = [];
+  const push = (candidate) => {
+    const channel = candidate;
+    if (typeof _optionalChain([channel, 'optionalAccess', _7 => _7.postMessage]) !== "function") return;
+    const post = channel.postMessage;
+    posters.push((json) => post.call(channel, json));
+  };
+  push(inner[PAGE_TO_HOST_CHANNEL]);
+  push(inner.ReactNativeWebView);
+  const webkit = inner.webkit;
+  const handlers = _optionalChain([webkit, 'optionalAccess', _8 => _8.messageHandlers]);
+  if (handlers && typeof handlers === "object") {
+    for (const name of Object.keys(handlers)) push(handlers[name]);
+  }
+  return posters;
+}
+function openProbeFrame(doc) {
+  return new Promise((resolve) => {
+    let frame;
+    try {
+      frame = doc.createElement("iframe");
+    } catch (e3) {
+      resolve(void 0);
+      return;
+    }
+    frame.setAttribute("aria-hidden", "true");
+    frame.setAttribute("title", "");
+    frame.style.cssText = "position:absolute;width:0;height:0;border:0;visibility:hidden";
+    let settled = false;
+    const done = (win) => {
+      if (settled) return;
+      settled = true;
+      if (!win) {
+        frame.remove();
+        resolve(void 0);
+        return;
+      }
+      resolve({ win, close: () => frame.remove() });
+    };
+    frame.addEventListener("load", () => {
+      if (!_optionalChain([frame, 'access', _9 => _9.contentDocument, 'optionalAccess', _10 => _10.getElementById, 'call', _11 => _11(PROBE_MARKER_ID)])) return;
+      done(_nullishCoalesce(frame.contentWindow, () => ( void 0)));
+    });
+    frame.addEventListener("error", () => done(void 0));
+    setTimeout(() => done(void 0), FRAME_OPEN_TIMEOUT_MS);
+    try {
+      frame.srcdoc = `<!doctype html><meta charset=utf-8><i id=${PROBE_MARKER_ID}></i>`;
+      doc.body.appendChild(frame);
+    } catch (e4) {
+      frame.remove();
+      done(void 0);
+    }
+  });
+}
+async function probeChannelScope(options) {
+  const doc = options.doc;
+  if (!_optionalChain([doc, 'optionalAccess', _12 => _12.body])) return "unknown";
+  const frame = await (_nullishCoalesce(options.openFrame, () => ( openProbeFrame)))(doc);
+  if (!frame) return "unknown";
+  try {
+    const posters = subFramePosters(frame.win);
+    if (posters.length === 0) return "main-frame";
+    let delivered = 0;
+    try {
+      await options.issue((json) => {
+        for (const post of posters) {
+          try {
+            post(json);
+            delivered += 1;
+          } catch (e5) {
+          }
+        }
+      });
+      return "all-frames";
+    } catch (error) {
+      if (delivered === 0) return "unknown";
+      if (isBridgeCode(error, BridgeErrorCode.REQUEST_TIMEOUT)) {
+        return "main-frame";
+      }
+      if (isBridgeCode(error, BridgeErrorCode.CHANNEL_CLOSED)) return "unknown";
+      if (isBridgeRequestError(error)) return "all-frames";
+      return "unknown";
+    }
+  } finally {
+    frame.close();
+  }
+}
+var CHANNEL_SCOPE_ADVICE = `[rhinestone] This app answered ${BRIDGE_METHOD.PROBE_FRAME_SCOPE} sent from a sub-frame, so any frame in its web view can drive the wallet. Fix it natively: drop a message unless frameInfo.isMainFrame (iOS) or onPostMessage's isMainFrame (Android). Scoping the ${PAGE_TO_HOST_CHANNEL} shim is not enough \u2014 the primitive under it is in every frame regardless. Wallet, withdraw and claim are withheld until then.`;
+var advised = false;
+function adviseOnChannelScope(scope) {
+  if (scope !== "all-frames" || advised) return;
+  advised = true;
+  console.error(CHANNEL_SCOPE_ADVICE);
+}
+
+// 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
+
+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 _optionalChain([state, 'access', _13 => _13.accounts, 'access', _14 => _14.find, 'call', _15 => _15((account) => account.caip10.startsWith("eip155:")), 'optionalAccess', _16 => _16.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: _chunk4KCSH4T3cjs.getChainName.call(void 0, 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) ? _chunk7ICSHJFEcjs.markSubmissionUncertain.call(void 0, 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}` : _nullishCoalesce(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 _chunk7ICSHJFEcjs.markSubmissionUncertain.call(void 0, 
+          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 _chunk7ICSHJFEcjs.markSubmissionUncertain.call(void 0, error);
+      }
+      throw error;
+    }
+    assertResultShape(method, result);
+    return result;
+  }
+  const evmTransport = _viem.custom.call(void 0, {
+    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 = _nullishCoalesce(resolveChain(chainId), () => ( syntheticChain(chainId)));
+    const key = `${address}:${chainId}`;
+    if (cachedClient && cachedKey === key) return cachedClient;
+    cachedClient = _viem.createWalletClient.call(void 0, {
+      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 ${_nullishCoalesce(_optionalChain([resolveChain, 'call', _17 => _17(chainId), 'optionalAccess', _18 => _18.name]), () => ( _chunk4KCSH4T3cjs.getChainName.call(void 0, 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);
+      _optionalChain([options, 'access', _19 => _19.onStateChange, 'optionalCall', _20 => _20(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: _chunk6KG642KHcjs.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;
+    _optionalChain([options, 'access', _21 => _21.onConfig, 'optionalCall', _22 => _22(config)]);
+  });
+  const probeable = hello.capabilities.includes(CAPABILITY.PROBE_FRAME_SCOPE);
+  let channelScope = probeable ? "probing" : "unknown";
+  let announceSettled = () => {
+  };
+  const channelScopeSettled = probeable ? new Promise((resolve) => {
+    announceSettled = resolve;
+  }) : Promise.resolve(channelScope);
+  const settleScope = (next) => {
+    channelScope = next;
+    adviseOnChannelScope(next);
+    _optionalChain([options, 'access', _23 => _23.onChannelScope, 'optionalCall', _24 => _24(next)]);
+    announceSettled(next);
+  };
+  if (probeable) {
+    void probeChannelScope({
+      doc: options.probeDocument !== void 0 ? options.probeDocument : globalThis.document,
+      issue: (post) => transport.requestVia(
+        post,
+        BRIDGE_METHOD.PROBE_FRAME_SCOPE,
+        {},
+        { timeoutMs: PROBE_TIMEOUT_MS }
+      )
+    }).then(settleScope).catch(() => settleScope("unknown"));
+  }
+  return {
+    transport,
+    hello,
+    wallet,
+    get config() {
+      return config;
+    },
+    get channelScope() {
+      return channelScope;
+    },
+    channelScopeSettled,
+    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 _chunk7ICSHJFEcjs.markSubmissionUncertain.call(void 0, error);
+    }
+    throw error;
+  }
+  if (!isTxHash(_optionalChain([result, 'optionalAccess', _25 => _25.txHash]))) {
+    throw _chunk7ICSHJFEcjs.markSubmissionUncertain.call(void 0, 
+      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(_optionalChain([result, 'optionalAccess', _26 => _26.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 (e6) {
+    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 = _optionalChain([target, 'optionalAccess', _27 => _27.visualViewport]);
+  const style = _optionalChain([target, 'optionalAccess', _28 => _28.document, 'optionalAccess', _29 => _29.documentElement, 'optionalAccess', _30 => _30.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
+var _jsxruntime = require('react/jsx-runtime');
+var WithdrawModal = _react.lazy.call(void 0, 
+  () => Promise.resolve().then(() => _interopRequireWildcard(require("./WithdrawModal-VP6PMIRO.cjs"))).then((m) => ({ default: m.WithdrawModal }))
+);
+var ClaimModal = _react.lazy.call(void 0, 
+  () => Promise.resolve().then(() => _interopRequireWildcard(require("./ClaimModal-IKTJU43Y.cjs"))).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}.`
+  };
+}
+var UNSCOPED_CHANNEL_CODE = "EMBED_CHANNEL_UNSCOPED";
+var UNSCOPED_REQUEST_MESSAGE = "This app cannot complete the request: every frame in its web view can reach the bridge channel.";
+function unscopedRefusal(mode) {
+  return {
+    code: UNSCOPED_CHANNEL_CODE,
+    message: `This app cannot run ${mode}: every frame in its web view can reach the bridge channel, so the page will not send it a signing request.`
+  };
+}
+function refusal(config, capabilities, channelScope) {
+  if (channelScope === "all-frames") {
+    if (config.mode === "withdraw") return unscopedRefusal("a withdrawal");
+    if (config.mode === "claim") return unscopedRefusal("a claim");
+  }
+  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 === _chunk4KCSH4T3cjs.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(_nullishCoalesce(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 === _chunk4KCSH4T3cjs.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),
+    enableAnalyticsIngest: bool(config.enableAnalyticsIngest),
+    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, walletWithheld) {
+  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,
+    // Explicit `false`, not an absent flag: `DepositFlow` defaults
+    // `enableWallet` to true, so leaving it undefined would offer the wallet
+    // row on exactly the host it is being withheld from.
+    enableWallet: walletWithheld ? false : config.enableWallet,
+    enableFiatOnramp: canOpenExternally && config.enableFiatOnramp,
+    enableQrTransfer: config.enableQrTransfer,
+    enableGaslessDeposit: config.enableGaslessDeposit,
+    enableExchangeConnect: canOpenExternally && config.enableExchangeConnect,
+    enableAnalyticsIngest: config.enableAnalyticsIngest,
+    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] = _react.useState.call(void 0, null);
+  const [config, setConfig] = _react.useState.call(void 0, null);
+  const [walletPending, setWalletPending] = _react.useState.call(void 0, false);
+  const [channelScope, setChannelScope] = _react.useState.call(void 0, "unknown");
+  const pendingRef = _react.useRef.call(void 0, false);
+  const completedRef = _react.useRef.call(void 0, false);
+  const uiRef = _react.useRef.call(void 0, {
+    screen: UNKNOWN_SCREEN,
+    submitting: false
+  });
+  const onFatalRef = _react.useRef.call(void 0, onFatal);
+  onFatalRef.current = onFatal;
+  _react.useEffect.call(void 0, 
+    () => trackVisualViewport(_nullishCoalesce(target, () => ( globalThis.window))),
+    [target]
+  );
+  _react.useEffect.call(void 0, () => {
+    let live = true;
+    let opened = null;
+    let chains = [];
+    void (async () => {
+      try {
+        const next = await connectToHost({
+          target: _nullishCoalesce(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);
+          },
+          onChannelScope: (scope) => {
+            if (live) setChannelScope(scope);
+          }
+        });
+        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;
+          _optionalChain([back, 'optionalCall', _31 => _31()]);
+          return { handled: Boolean(back) };
+        });
+        _chunk6KG642KHcjs.setEmbedHost.call(void 0, next.hello.host);
+        setSession(next);
+        setChannelScope(next.channelScope);
+        setConfig(sanitizeConfig(next.hello.config));
+        void _chunkV2OBGLJDcjs.primeRuntimeChains.call(void 0, next.hello.config.backendUrl).then((result) => {
+          chains = result;
+        });
+      } catch (error) {
+        if (live) _optionalChain([onFatalRef, 'access', _32 => _32.current, 'optionalCall', _33 => _33(error)]);
+      }
+    })();
+    return () => {
+      live = false;
+      _optionalChain([opened, 'optionalAccess', _34 => _34.close, 'call', _35 => _35()]);
+      _chunk6KG642KHcjs.setEmbedHost.call(void 0, null);
+    };
+  }, [target]);
+  const handleUiState = _react.useCallback.call(void 0, 
+    (state) => {
+      if (isHomeScreen(state.screen)) completedRef.current = false;
+      uiRef.current = state;
+      _optionalChain([session, 'optionalAccess', _36 => _36.transport, 'access', _37 => _37.emit, 'call', _38 => _38(
+        "ui.state",
+        uiStateFor({ ...state, walletRequestPending: walletPending })
+      )]);
+    },
+    [session, walletPending]
+  );
+  const openExternally = _react.useCallback.call(void 0, 
+    async (url) => {
+      if (!session) throw new Error("The app is not connected.");
+      await requestHostBrowser(session.transport, url);
+    },
+    [session]
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!session) return;
+    session.transport.emit(
+      "ui.state",
+      uiStateFor({ ...uiRef.current, walletRequestPending: walletPending })
+    );
+  }, [session, walletPending]);
+  const refused = config && session ? refusal(config, session.hello.capabilities, channelScope) : null;
+  const walletWithheld = channelScope === "all-frames" || channelScope === "probing";
+  const refuseIfUnscoped = _react.useCallback.call(void 0, async () => {
+    if (!session) throw new Error("The app is not connected.");
+    const scope = await session.channelScopeSettled;
+    if (scope === "all-frames") throw new Error(UNSCOPED_REQUEST_MESSAGE);
+  }, [session]);
+  _react.useEffect.call(void 0, () => {
+    if (!session || !refused) return;
+    session.transport.emit("error", refused);
+  }, [session, _optionalChain([refused, 'optionalAccess', _39 => _39.code]), _optionalChain([refused, 'optionalAccess', _40 => _40.message])]);
+  const onrampHidden = config && session && !refused ? onrampUnavailable(config, session.hello.capabilities) : null;
+  _react.useEffect.call(void 0, () => {
+    if (!session || !onrampHidden) return;
+    session.transport.emit("error", onrampHidden);
+  }, [session, _optionalChain([onrampHidden, 'optionalAccess', _41 => _41.code]), _optionalChain([onrampHidden, 'optionalAccess', _42 => _42.message])]);
+  const walletHidden = session && !refused && channelScope === "all-frames" ? {
+    code: UNSCOPED_CHANNEL_CODE,
+    message: "Wallet funding is hidden: every frame in this app's web view can reach the bridge channel. Scope the injected channel to the main frame."
+  } : null;
+  _react.useEffect.call(void 0, () => {
+    if (!session || !walletHidden) return;
+    session.transport.emit("error", walletHidden);
+  }, [session, _optionalChain([walletHidden, 'optionalAccess', _43 => _43.code]), _optionalChain([walletHidden, 'optionalAccess', _44 => _44.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,
+    enableAnalyticsIngest: ready.enableAnalyticsIngest,
+    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__ */ _jsxruntime.jsx.call(void 0, _react.Suspense, { fallback: null, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      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) => {
+          await refuseIfUnscoped();
+          return {
+            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__ */ _jsxruntime.jsx.call(void 0, _react.Suspense, { fallback: null, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      ClaimModal,
+      {
+        ...shared,
+        defaultTxHash: ready.defaultTxHash,
+        defaultRefundDestination: ready.defaultDestination,
+        signRecovery: async ({ chainId, signer, depositId, destination }) => {
+          await refuseIfUnscoped();
+          return await requestHostRecoverySignature(transport, {
+            chainId,
+            signer,
+            depositId,
+            destination
+          });
+        },
+        onUiState: handleUiState,
+        onLifecycle: (event) => {
+          if (event.type === "complete") completedRef.current = true;
+          transport.emit("lifecycle", event);
+        }
+      }
+    ) });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkYCQZJQO6cjs.DepositModalInner,
+    {
+      ...toModalProps(ready, canOpenExternally, walletWithheld),
+      openExternally: canOpenExternally ? openExternally : void 0,
+      walletSession: walletWithheld ? void 0 : session.wallet.session,
+      walletIntegration: "host_supplied",
+      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"
+      })
+    }
+  );
+}
+
+
+exports.DepositEmbed = DepositEmbed;