@thru/wallet 0.2.22

package/dist/native/react.js

@@ -0,0 +1,2381 @@
+import { createContext, forwardRef, useRef, useState, useMemo, useCallback, useEffect, useImperativeHandle, useContext, Component } from 'react';
+import { createThruClient } from '@thru/sdk/client';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useWindowDimensions, Platform, View, Text, Image, StyleSheet } from 'react-native';
+import BottomSheet, { BottomSheetBackdrop } from '@gorhom/bottom-sheet';
+import { useSharedValue } from 'react-native-reanimated';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { WebView } from 'react-native-webview';
+import QRCodeStyledImport from 'react-native-qrcode-styled';
+import { requireOptionalNativeModule } from 'expo-modules-core';
+
+// src/native/react/ThruProvider.tsx
+
+// src/interfaces/accounts.ts
+function resolveSelectedWalletAccount(accounts, selectedAccount) {
+  if (selectedAccount) {
+    return accounts.find((account) => account.address === selectedAccount.address) ?? selectedAccount;
+  }
+  return accounts[0] ?? null;
+}
+function resolveWalletAccountByAddress(accounts, address) {
+  if (!address) return null;
+  return accounts.find((account) => account.address === address) ?? null;
+}
+function normalizeActiveWalletAccounts(accounts, selectedAccount) {
+  const activeAccount = resolveSelectedWalletAccount(accounts, selectedAccount);
+  return {
+    accounts: activeAccount ? [activeAccount] : [],
+    selectedAccount: activeAccount
+  };
+}
+function normalizeWalletAccountResult(result, selectedAccount) {
+  const active = normalizeActiveWalletAccounts(
+    result.accounts,
+    selectedAccount ?? result.selectedAccount ?? null
+  );
+  return {
+    ...result,
+    accounts: active.accounts,
+    selectedAccount: active.selectedAccount
+  };
+}
+
+// src/interfaces/types.ts
+var AddressType = {
+  THRU: "thru"
+};
+
+// src/protocol/postMessage.ts
+var POST_MESSAGE_REQUEST_TYPES = {
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  SIGN_MESSAGE: "signMessage",
+  SIGN_TRANSACTION: "signTransaction",
+  GET_ACCOUNTS: "getAccounts",
+  GET_CONNECTION_STATE: "getConnectionState",
+  GET_SIGNING_CONTEXT: "getSigningContext",
+  SELECT_ACCOUNT: "selectAccount",
+  MANAGE_ACCOUNTS: "manageAccounts"
+};
+var EMBEDDED_PROVIDER_EVENTS = {
+  CONNECT_START: "connect_start",
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  CONNECT_ERROR: "connect_error",
+  ERROR: "error",
+  LOCK: "lock",
+  UI_SHOW: "ui_show",
+  ACCOUNT_CHANGED: "account_changed"
+};
+var POST_MESSAGE_EVENT_TYPE = "event";
+var IFRAME_READY_EVENT = "iframe:ready";
+var REQUEST_ID_PREFIX = "req";
+var createRequestId = (prefix = REQUEST_ID_PREFIX) => {
+  const random = Math.random().toString(36).slice(2, 11);
+  return `${prefix}_${Date.now()}_${random}`;
+};
+var ErrorCode = {
+  USER_REJECTED: "USER_REJECTED"};
+
+// src/protocol/walletState.ts
+function normalizeConnectionStateResult(result) {
+  if (!result.isAuthorized || !result.hasPasskey) {
+    return { ...result, accounts: [], selectedAccount: null };
+  }
+  return normalizeWalletAccountResult(result);
+}
+
+// src/native/provider/chains/ThruChain.ts
+var NativeThruChain = class {
+  constructor(bridge, provider, origin) {
+    this.bridge = bridge;
+    this.provider = provider;
+    this.origin = origin;
+  }
+  get connected() {
+    return this.provider.isConnected();
+  }
+  async connect() {
+    const result = await this.provider.connect();
+    const selectedAccount = result.selectedAccount;
+    const thruAccount = selectedAccount?.accountType === AddressType.THRU ? selectedAccount : result.accounts.find((addr) => addr.accountType === AddressType.THRU);
+    if (!thruAccount) {
+      throw new Error("Thru address not found in connection result");
+    }
+    return { publicKey: thruAccount.address };
+  }
+  async disconnect() {
+    await this.provider.disconnect();
+  }
+  async getSigningContext() {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.GET_SIGNING_CONTEXT,
+      origin: this.origin
+    });
+    return response.result.signingContext;
+  }
+  async signTransaction(transaction) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    this.provider.requestShow();
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
+        payload: {
+          walletAddress: transaction.walletAddress,
+          programAddress: transaction.programAddress,
+          instructionData: transaction.instructionData,
+          readWriteAddresses: transaction.readWriteAddresses,
+          readOnlyAddresses: transaction.readOnlyAddresses,
+          review: transaction.review
+        },
+        origin: this.origin
+      });
+      return response.result.signedTransaction;
+    } finally {
+      this.provider.requestHide();
+    }
+  }
+};
+
+// src/native/provider/WebViewBridge.ts
+var PRODUCTION_WALLET_ORIGINS = ["https://wallet.thru.org"];
+function isDevelopmentBuild() {
+  const runtime = globalThis;
+  const devFlag = runtime.__DEV__;
+  if (typeof devFlag === "boolean") return devFlag;
+  return runtime.process?.env?.NODE_ENV !== void 0 && runtime.process.env.NODE_ENV !== "production";
+}
+function isPrivateIpv4Host(hostname) {
+  const parts = hostname.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  const [a, b] = parts;
+  return a === 10 || a === 127 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+}
+function isAllowedDevelopmentOrigin(url) {
+  if (!isDevelopmentBuild()) return false;
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  const hostname = url.hostname.toLowerCase();
+  return hostname === "localhost" || hostname === "::1" || !hostname.includes(".") || hostname.endsWith(".local") || hostname.endsWith(".ts.net") || isPrivateIpv4Host(hostname);
+}
+function validateWalletOrigin(walletUrl) {
+  let url;
+  try {
+    url = new URL(walletUrl);
+  } catch {
+    throw new Error(
+      `Invalid wallet URL: ${walletUrl}. URL must be a valid absolute URL.`
+    );
+  }
+  const origin = url.origin;
+  const isAllowed = PRODUCTION_WALLET_ORIGINS.includes(origin) || isAllowedDevelopmentOrigin(url);
+  if (!isAllowed) {
+    throw new Error(
+      `Untrusted wallet origin: ${origin}. Only trusted origins are allowed: ${PRODUCTION_WALLET_ORIGINS.join(", ")}. Development builds also allow localhost, LAN, and Tailscale wallet origins.`
+    );
+  }
+}
+var READY_TIMEOUT_MS = 1e4;
+var SLOW_REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
+var FAST_REQUEST_TIMEOUT_MS = 30 * 1e3;
+var SLOW_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  POST_MESSAGE_REQUEST_TYPES.CONNECT,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
+  POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS
+]);
+var WebViewBridge = class {
+  constructor(options) {
+    this.webView = null;
+    this.ready = false;
+    this.readyPromise = null;
+    this.resolveReady = null;
+    this.rejectReady = null;
+    this.readyTimer = null;
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    validateWalletOrigin(options.walletUrl);
+    this.walletUrl = options.walletUrl;
+    this.walletOrigin = new URL(options.walletUrl).origin;
+    this.frameId = createRequestId("frame");
+  }
+  /**
+   * Compose the URL to load inside the shell <iframe>. The host
+   * (ThruWalletSheet) calls this when building the shell HTML.
+   */
+  getIframeSrc() {
+    const url = new URL(this.walletUrl);
+    if (!url.pathname.endsWith("/native")) {
+      url.pathname = `${url.pathname.replace(/\/$/, "")}/native`;
+    }
+    url.searchParams.set("tn_frame_id", this.frameId);
+    return url.toString();
+  }
+  /**
+   * Hand the bridge a WebView ref. Required before `awaitReady()` /
+   * `sendMessage()` will resolve.
+   */
+  attachWebView(ref) {
+    this.webView = ref;
+  }
+  /**
+   * Mark the bridge ready when the native host loads the wallet as the
+   * top-level WebView document instead of through the shell iframe.
+   */
+  markReady() {
+    if (this.ready) return;
+    this.ready = true;
+    if (this.readyTimer) clearTimeout(this.readyTimer);
+    this.readyTimer = null;
+    const r = this.resolveReady;
+    this.resolveReady = null;
+    this.rejectReady = null;
+    r?.();
+  }
+  /**
+   * Returns a promise that resolves when the iframe sends
+   * IFRAME_READY_EVENT. Idempotent: returns the same promise on
+   * subsequent calls. Rejects after READY_TIMEOUT_MS.
+   */
+  awaitReady() {
+    if (this.ready) return Promise.resolve();
+    if (this.readyPromise) return this.readyPromise;
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+      this.readyTimer = setTimeout(() => {
+        this.readyTimer = null;
+        if (this.rejectReady) {
+          const r = this.rejectReady;
+          this.rejectReady = null;
+          this.resolveReady = null;
+          r(new Error("WebView ready timeout - wallet failed to load"));
+        }
+      }, READY_TIMEOUT_MS);
+    });
+    return this.readyPromise;
+  }
+  /**
+   * Send a request to the iframe (via injectJavaScript -> shell ->
+   * iframe.postMessage) and resolve with the matching response.
+   */
+  async sendMessage(request) {
+    await this.awaitReady();
+    if (!this.webView) {
+      throw new Error("WebView not attached - call attachWebView() first");
+    }
+    const timeoutMs = SLOW_REQUEST_TYPES.has(request.type) ? SLOW_REQUEST_TIMEOUT_MS : FAST_REQUEST_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.messageHandlers.delete(request.id);
+        reject(new Error("Request timeout - wallet did not respond"));
+      }, timeoutMs);
+      this.messageHandlers.set(request.id, (response) => {
+        clearTimeout(timer);
+        this.messageHandlers.delete(request.id);
+        if (response.success) {
+          resolve(
+            response
+          );
+        } else {
+          const err = new Error(response.error?.message || "Unknown error");
+          err.code = response.error?.code;
+          err.data = response.error?.data;
+          reject(err);
+        }
+      });
+      const script = `try {
+        var msg = ${JSON.stringify(request)};
+        if (window.__pushIn) {
+          window.__pushIn(msg);
+        } else {
+          window.dispatchEvent(new MessageEvent('message', {
+            data: msg,
+            origin: msg.origin || ''
+          }));
+        }
+      } catch (e) {} ; true;`;
+      this.webView.injectJavaScript(script);
+    });
+  }
+  /**
+   * Reject all in-flight wallet requests when the native host dismisses the
+   * WebView without waiting for a wallet-side response.
+   */
+  rejectPendingRequests(message = "User rejected the request") {
+    for (const [id, handler] of Array.from(this.messageHandlers.entries())) {
+      handler({
+        id,
+        success: false,
+        error: {
+          code: ErrorCode.USER_REJECTED,
+          message
+        }
+      });
+    }
+  }
+  /**
+   * Hook this into <WebView onMessage>. The shell forwards iframe
+   * postMessage payloads to ReactNativeWebView; we route them here.
+   */
+  onMessage(event) {
+    let data;
+    try {
+      data = JSON.parse(event.nativeEvent.data);
+    } catch {
+      return;
+    }
+    if (!data || typeof data !== "object") return;
+    const msg = data;
+    if (msg.frameId !== this.frameId) return;
+    if (msg.type === IFRAME_READY_EVENT) {
+      this.markReady();
+      return;
+    }
+    if (typeof msg.id === "string" && this.messageHandlers.has(msg.id)) {
+      const handler = this.messageHandlers.get(msg.id);
+      handler(msg);
+      return;
+    }
+    if (msg.type === POST_MESSAGE_EVENT_TYPE) {
+      const evt = msg;
+      this.onEvent?.(evt.event, evt.data);
+    }
+  }
+  /**
+   * Drop pending handlers and clear ready promise. Call when the host
+   * unmounts the WebView.
+   */
+  destroy() {
+    if (this.readyTimer) {
+      clearTimeout(this.readyTimer);
+      this.readyTimer = null;
+    }
+    if (this.rejectReady && this.readyPromise) {
+      this.readyPromise.catch(() => {
+      });
+      this.rejectReady(new Error("Bridge destroyed"));
+    }
+    this.resolveReady = null;
+    this.rejectReady = null;
+    this.readyPromise = null;
+    this.ready = false;
+    this.messageHandlers.clear();
+    this.webView = null;
+  }
+};
+
+// src/native/provider/NativeProvider.ts
+var DEFAULT_WALLET_URL = "https://wallet.thru.org/embedded/native";
+var DEFAULT_ORIGIN = "thru-mobile://app";
+var NativeProvider = class {
+  constructor(config = {}) {
+    this.connected = false;
+    this.accounts = [];
+    this.selectedAccount = null;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    /** Pass through the WebView's `onMessage` event handler. */
+    this.onMessage = (event) => {
+      this.bridge.onMessage(event);
+    };
+    const walletUrl = config.walletUrl ?? DEFAULT_WALLET_URL;
+    this.origin = config.origin ?? DEFAULT_ORIGIN;
+    this.bridge = new WebViewBridge({ walletUrl });
+    this.bridge.onEvent = (eventType, payload) => {
+      this.emit(eventType, payload);
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.UI_SHOW) {
+        this.requestShow();
+        return;
+      }
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.DISCONNECT || eventType === EMBEDDED_PROVIDER_EVENTS.LOCK) {
+        this.clearConnection();
+        this.requestHide();
+        return;
+      }
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED) {
+        const account = payload?.account ?? null;
+        this.refreshAccountCache(account);
+      }
+    };
+    const addressTypes = config.addressTypes ?? [AddressType.THRU];
+    if (addressTypes.includes(AddressType.THRU)) {
+      this._thruChain = new NativeThruChain(this.bridge, this, this.origin);
+    }
+  }
+  /** Hand the bridge a WebView ref. Required before connect/sign. */
+  attachWebView(ref) {
+    this.bridge.attachWebView(ref);
+  }
+  /** Mark a direct top-level WebView wallet document as ready. */
+  markWebViewReady() {
+    this.bridge.markReady();
+  }
+  /** Build the URL to load inside the shell <iframe>. The host shell
+      template should substitute this for WALLET_URL_PLACEHOLDER. */
+  getIframeSrc() {
+    return this.bridge.getIframeSrc();
+  }
+  /** Wallet origin (e.g. https://wallet.thru.org). The shell template
+      should substitute this for WALLET_ORIGIN_PLACEHOLDER. */
+  getWalletOrigin() {
+    return this.bridge.walletOrigin;
+  }
+  /** Wait for the iframe's IFRAME_READY_EVENT handshake. */
+  async initialize() {
+    await this.bridge.awaitReady();
+  }
+  /** Open the wallet UI (called internally; also exposed for host). */
+  requestShow() {
+    this.onShowRequested?.();
+  }
+  /** Close the wallet UI (called internally; also exposed for host). */
+  requestHide() {
+    this.onHideRequested?.();
+  }
+  /** Reject pending requests after a user-driven native sheet dismiss. */
+  rejectPendingRequests(message) {
+    this.bridge.rejectPendingRequests(message);
+  }
+  async connect(options) {
+    this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT_START, {});
+    try {
+      this.requestShow();
+      const payload = {};
+      if (options?.metadata) payload.metadata = options.metadata;
+      if (options?.preferredAccountAddress) {
+        payload.preferredAccountAddress = options.preferredAccountAddress;
+      }
+      if (options?.intent) payload.intent = options.intent;
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CONNECT,
+        payload,
+        origin: this.origin
+      });
+      const result = normalizeWalletAccountResult(response.result);
+      this.connected = true;
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT, result);
+      this.requestHide();
+      return result;
+    } catch (error) {
+      this.requestHide();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT_ERROR, { error });
+      throw error;
+    }
+  }
+  async getConnectionState(options) {
+    const payload = {};
+    if (options?.metadata) payload.metadata = options.metadata;
+    if (options?.preferredAccountAddress) {
+      payload.preferredAccountAddress = options.preferredAccountAddress;
+    }
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.GET_CONNECTION_STATE,
+      payload,
+      origin: this.origin
+    });
+    const result = normalizeConnectionStateResult(response.result);
+    if (result.isAuthorized && result.hasPasskey && result.accounts.length > 0) {
+      this.hydrateConnection(
+        {
+          accounts: result.accounts,
+          status: "completed",
+          metadata: result.metadata ?? void 0,
+          selectedAccount: result.selectedAccount
+        },
+        result.selectedAccount?.address ?? null
+      );
+    } else {
+      this.clearConnection();
+    }
+    return result;
+  }
+  async disconnect() {
+    try {
+      await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.DISCONNECT,
+        origin: this.origin
+      });
+      this.clearConnection();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.DISCONNECT, {});
+    } catch (error) {
+      this.clearConnection();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ERROR, { error });
+      throw error;
+    } finally {
+      this.requestHide();
+    }
+  }
+  isConnected() {
+    return this.connected;
+  }
+  hydrateConnection(result, selectedAccountAddress) {
+    const selectedAccount = resolveWalletAccountByAddress(result.accounts, selectedAccountAddress) ?? result.selectedAccount ?? null;
+    const normalized = normalizeWalletAccountResult(result, selectedAccount);
+    this.connected = true;
+    this.accounts = normalized.accounts;
+    this.selectedAccount = normalized.selectedAccount;
+  }
+  clearConnection() {
+    this.connected = false;
+    this.accounts = [];
+    this.selectedAccount = null;
+  }
+  getAccounts() {
+    return this.accounts;
+  }
+  getSelectedAccount() {
+    return this.selectedAccount;
+  }
+  async selectAccount(publicKey) {
+    if (!this.connected) throw new Error("Wallet not connected");
+    const payload = { publicKey };
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.SELECT_ACCOUNT,
+      payload,
+      origin: this.origin
+    });
+    const account = response.result.account;
+    this.refreshAccountCache(account);
+    return account;
+  }
+  async manageAccounts() {
+    if (!this.connected) throw new Error("Wallet not connected");
+    try {
+      this.requestShow();
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS,
+        origin: this.origin
+      });
+      const result = normalizeWalletAccountResult(response.result);
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+      this.requestHide();
+      return result;
+    } catch (error) {
+      this.requestHide();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ERROR, { error });
+      throw error;
+    }
+  }
+  get thru() {
+    if (!this._thruChain) {
+      throw new Error("Thru chain not enabled in provider config");
+    }
+    return this._thruChain;
+  }
+  on(event, cb) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(cb);
+  }
+  off(event, cb) {
+    this.eventListeners.get(event)?.delete(cb);
+  }
+  /** Internal: used by NativeThruChain. */
+  getBridge() {
+    return this.bridge;
+  }
+  destroy() {
+    this.bridge.destroy();
+    this.eventListeners.clear();
+    this.clearConnection();
+  }
+  emit(event, data) {
+    this.eventListeners.get(event)?.forEach((cb) => {
+      try {
+        cb(data);
+      } catch (err) {
+        console.error(`[NativeProvider] listener error for ${event}:`, err);
+      }
+    });
+  }
+  refreshAccountCache(account) {
+    if (!account) {
+      this.accounts = [];
+      this.selectedAccount = null;
+      return;
+    }
+    this.accounts = [account];
+    this.selectedAccount = account;
+  }
+};
+var DEFAULT_STORAGE_KEY = "thru.native-sdk.connection.v1";
+var SELECTED_ACCOUNT_STORAGE_KEY_SUFFIX = ".selected-account.v1";
+var CHECKING_WALLET_AVAILABILITY = {
+  status: "checking",
+  isAuthorized: false,
+  isConnected: false,
+  isUnlocked: false,
+  hasPasskey: false,
+  hasWalletAccount: false,
+  accounts: [],
+  selectedAccount: null,
+  metadata: null,
+  error: null
+};
+var NativeSDK = class {
+  constructor(config = {}) {
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.initialized = false;
+    this.thruClient = null;
+    this.connectInFlight = null;
+    this.lastConnectResult = null;
+    this.walletAvailability = CHECKING_WALLET_AVAILABILITY;
+    /** Bind to the WebView's `onMessage` handler. */
+    this.onMessage = (event) => {
+      this.provider.onMessage(event);
+    };
+    this.origin = config.origin ?? "thru-mobile://app";
+    this.rpcUrl = config.rpcUrl;
+    this.storage = config.storage;
+    this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+    this.selectedAccountStorageKey = config.selectedAccountStorageKey ?? `${this.storageKey}${SELECTED_ACCOUNT_STORAGE_KEY_SUFFIX}`;
+    this.iosWebViewMode = config.iosWebViewMode ?? "shell-iframe";
+    this.provider = new NativeProvider({
+      walletUrl: config.walletUrl,
+      origin: this.origin,
+      addressTypes: config.addressTypes ?? [AddressType.THRU]
+    });
+    this.setupEventForwarding();
+  }
+  /** Hand the WebView ref to the underlying provider/bridge. */
+  attachWebView(ref) {
+    this.provider.attachWebView(ref);
+  }
+  /** Mark a direct top-level WebView wallet document as ready. */
+  markWebViewReady() {
+    this.provider.markWebViewReady();
+  }
+  /** Build the URL to load inside the shell <iframe>. */
+  getIframeSrc() {
+    return this.provider.getIframeSrc();
+  }
+  /** Wallet origin (e.g. https://wallet.thru.org). */
+  getWalletOrigin() {
+    return this.provider.getWalletOrigin();
+  }
+  /** Bind host UI lifecycle handlers used by custom WebView hosts. */
+  setUiHandlers(handlers) {
+    this.provider.onShowRequested = handlers.onShowRequested;
+    this.provider.onHideRequested = handlers.onHideRequested;
+  }
+  clearUiHandlers() {
+    this.provider.onShowRequested = void 0;
+    this.provider.onHideRequested = void 0;
+  }
+  /** Reject in-flight wallet requests after a user-driven host dismiss. */
+  rejectPendingRequests(message) {
+    this.provider.rejectPendingRequests(message);
+  }
+  /** iOS WebView host mode. Non-iOS hosts should ignore this value. */
+  getIosWebViewMode() {
+    return this.iosWebViewMode;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    await this.provider.initialize();
+    this.initialized = true;
+  }
+  async connect(options) {
+    const isAccountSwitch = options?.intent === "switch-account";
+    if (this.connectInFlight) return this.connectInFlight;
+    if (!isAccountSwitch && this.lastConnectResult && this.provider.isConnected()) {
+      return this.lastConnectResult;
+    }
+    this.emit("connect", { status: "connecting" });
+    const inFlight = (async () => {
+      try {
+        this.provider.requestShow();
+        if (!this.initialized) await this.initialize();
+        const metadata = this.resolveMetadata(options?.metadata);
+        const preferredAccountAddress = isAccountSwitch ? null : await this.readSelectedAccountAddress();
+        const providerOptions = metadata || preferredAccountAddress || options?.intent ? {
+          ...metadata ? { metadata } : {},
+          ...preferredAccountAddress ? { preferredAccountAddress } : {},
+          ...options?.intent ? { intent: options.intent } : {}
+        } : void 0;
+        const result = await this.provider.connect(providerOptions);
+        if (!isAccountSwitch) {
+          await this.applyPreferredSelectedAccount(result.accounts);
+        }
+        const selectedAccount = this.provider.getSelectedAccount() ?? result.selectedAccount ?? null;
+        const activeResult = normalizeWalletAccountResult(
+          {
+            ...result,
+            accounts: this.provider.getAccounts(),
+            selectedAccount
+          },
+          selectedAccount
+        );
+        this.lastConnectResult = activeResult;
+        await this.persistSelectedAccountAddress(
+          activeResult.selectedAccount?.address ?? null
+        );
+        await this.clearPersistedConnection();
+        this.setWalletAvailability(
+          walletAvailabilityFromConnectResult(activeResult)
+        );
+        this.emit("connect", activeResult);
+        return activeResult;
+      } catch (error) {
+        this.provider.requestHide();
+        if (isUserRejectedError(error) && !isAccountSwitch) {
+          this.provider.clearConnection();
+          this.lastConnectResult = null;
+          await this.clearPersistedConnection();
+          this.clearAuthorizedAvailability();
+          this.emit("disconnect", { reason: "user_rejected" });
+        }
+        this.emit("error", error);
+        throw error;
+      } finally {
+        this.connectInFlight = null;
+      }
+    })();
+    this.connectInFlight = inFlight;
+    return inFlight;
+  }
+  async signIn(options) {
+    return this.connect({
+      metadata: this.resolveSignInMetadata(options),
+      ...options.intent ? { intent: options.intent } : {}
+    });
+  }
+  async disconnect() {
+    try {
+      await this.provider.disconnect();
+      this.emit("disconnect", {});
+      this.lastConnectResult = null;
+      await this.clearPersistedConnection();
+      this.clearAuthorizedAvailability();
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  isConnected() {
+    return this.provider.isConnected();
+  }
+  getWalletAvailability() {
+    return this.walletAvailability;
+  }
+  async restoreConnection(options = {}) {
+    await this.clearPersistedConnection();
+    return null;
+  }
+  async syncConnectionState(options) {
+    try {
+      const state = await this.requestConnectionState(options);
+      this.setWalletAvailability(walletAvailabilityFromConnectionState(state));
+      await this.applyConnectionState(state);
+      return state;
+    } catch (error) {
+      this.setWalletAvailability(walletAvailabilityFromError(error));
+      this.emit("error", error);
+      return null;
+    }
+  }
+  async refreshWalletAvailability(options) {
+    try {
+      const state = await this.requestConnectionState(options);
+      const availability = walletAvailabilityFromConnectionState(state);
+      this.setWalletAvailability(availability);
+      await this.applyConnectionState(state);
+      return availability;
+    } catch (error) {
+      const availability = walletAvailabilityFromError(error);
+      this.setWalletAvailability(availability);
+      this.emit("error", error);
+      return availability;
+    }
+  }
+  getAccounts() {
+    const accounts = this.provider.getAccounts();
+    const activeAccounts = this.refreshCachedAccounts(
+      accounts,
+      this.provider.getSelectedAccount()
+    );
+    return activeAccounts;
+  }
+  getSelectedAccount() {
+    return this.provider.getSelectedAccount();
+  }
+  async selectAccount(publicKey) {
+    const account = await this.provider.selectAccount(publicKey);
+    this.refreshCachedAccounts(this.provider.getAccounts(), account);
+    await this.persistSelectedAccountAddress(account.address);
+    return account;
+  }
+  async manageAccounts() {
+    if (!this.initialized) await this.initialize();
+    const result = await this.provider.manageAccounts();
+    const activeResult = normalizeWalletAccountResult(result);
+    const selectedAccount = activeResult.selectedAccount ?? null;
+    this.refreshCachedAccounts(activeResult.accounts, selectedAccount);
+    await this.persistSelectedAccountAddress(selectedAccount?.address ?? null);
+    if (this.lastConnectResult) {
+      this.setWalletAvailability(
+        walletAvailabilityFromConnectResult(this.lastConnectResult)
+      );
+    }
+    this.emit("accountChanged", selectedAccount);
+    return activeResult;
+  }
+  get thru() {
+    return this.provider.thru;
+  }
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  off(event, callback) {
+    this.eventListeners.get(event)?.delete(callback);
+  }
+  once(event, callback) {
+    const wrapped = (...args) => {
+      callback(...args);
+      this.off(event, wrapped);
+    };
+    this.on(event, wrapped);
+  }
+  destroy() {
+    this.provider.destroy();
+    this.eventListeners.clear();
+    this.initialized = false;
+    this.connectInFlight = null;
+    this.lastConnectResult = null;
+    this.walletAvailability = CHECKING_WALLET_AVAILABILITY;
+  }
+  /** Lazily-instantiated Thru chain client. */
+  getThru() {
+    if (!this.thruClient) {
+      this.thruClient = createThruClient({ baseUrl: this.rpcUrl });
+    }
+    return this.thruClient;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  emit(event, data) {
+    this.eventListeners.get(event)?.forEach((cb) => {
+      try {
+        cb(data);
+      } catch (err) {
+        console.error(`[NativeSDK] listener error for ${event}:`, err);
+      }
+    });
+  }
+  setupEventForwarding() {
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.DISCONNECT, (data) => {
+      this.lastConnectResult = null;
+      this.clearAuthorizedAvailability();
+      this.emit("disconnect", data);
+    });
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.ERROR, (data) => {
+      this.emit("error", data);
+    });
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.LOCK, (data) => {
+      this.lastConnectResult = null;
+      this.clearAuthorizedAvailability();
+      this.emit("lock", data);
+      this.emit("disconnect", { reason: "locked" });
+    });
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED, (data) => {
+      const payload = data;
+      const account = payload?.account ?? null;
+      this.refreshCachedAccounts(this.provider.getAccounts(), account);
+      if (account) void this.persistSelectedAccountAddress(account.address);
+      this.emit("accountChanged", account);
+    });
+  }
+  async requestConnectionState(options) {
+    if (!this.initialized) await this.initialize();
+    const metadata = options?.metadata ?? this.lastConnectResult?.metadata ?? void 0;
+    const providerOptions = metadata ? { metadata: this.resolveMetadata(metadata) } : void 0;
+    const preferredAccountAddress = await this.readSelectedAccountAddress();
+    const nextProviderOptions = providerOptions || preferredAccountAddress ? {
+      ...providerOptions ?? {},
+      ...preferredAccountAddress ? { preferredAccountAddress } : {}
+    } : void 0;
+    const state = await this.provider.getConnectionState(nextProviderOptions);
+    return normalizeConnectionStateResult(state);
+  }
+  async applyConnectionState(state) {
+    if (state.isAuthorized && state.hasPasskey && state.accounts.length > 0) {
+      const result = {
+        accounts: state.accounts,
+        selectedAccount: state.selectedAccount,
+        status: "completed",
+        metadata: state.metadata ?? void 0
+      };
+      const activeResult = normalizeWalletAccountResult(result);
+      this.lastConnectResult = activeResult;
+      await this.persistSelectedAccountAddress(
+        this.provider.getSelectedAccount()?.address ?? activeResult.selectedAccount?.address ?? null
+      );
+      await this.clearPersistedConnection();
+      this.emit("connect", activeResult);
+      return;
+    }
+    const wasConnected = this.provider.isConnected() || !!this.lastConnectResult;
+    this.provider.clearConnection();
+    this.lastConnectResult = null;
+    await this.clearPersistedConnection();
+    if (wasConnected) {
+      this.emit("disconnect", { reason: "state_unavailable" });
+    }
+  }
+  setWalletAvailability(availability) {
+    this.walletAvailability = availability;
+    this.emit("availabilityChanged", availability);
+  }
+  clearAuthorizedAvailability() {
+    const previous = this.walletAvailability.status === "ready" ? this.walletAvailability : null;
+    this.setWalletAvailability({
+      status: "ready",
+      isAuthorized: false,
+      isConnected: false,
+      isUnlocked: false,
+      hasPasskey: previous?.hasPasskey ?? false,
+      hasWalletAccount: previous?.hasWalletAccount ?? false,
+      accounts: [],
+      selectedAccount: null,
+      metadata: null,
+      error: null
+    });
+  }
+  resolveMetadata(input) {
+    if (!input) {
+      return { appId: this.origin };
+    }
+    const metadata = {
+      appId: input.appId ?? this.origin
+    };
+    if (input.appUrl) metadata.appUrl = input.appUrl;
+    if (input.appName) metadata.appName = input.appName;
+    if (input.imageUrl) metadata.imageUrl = input.imageUrl;
+    return metadata;
+  }
+  resolveSignInMetadata(options) {
+    const metadata = {
+      appId: options.app_id,
+      appName: options.app_display_name
+    };
+    if (options.app_url) metadata.appUrl = options.app_url;
+    if (options.image_url) metadata.imageUrl = options.image_url;
+    return metadata;
+  }
+  refreshCachedAccounts(accounts, selectedAccount) {
+    const active = normalizeActiveWalletAccounts(accounts, selectedAccount);
+    const nextAccounts = active.accounts;
+    const nextSelectedAccount = active.selectedAccount;
+    if (this.lastConnectResult && this.provider.isConnected()) {
+      this.lastConnectResult = {
+        ...this.lastConnectResult,
+        accounts: nextAccounts,
+        selectedAccount: nextSelectedAccount
+      };
+      if (nextSelectedAccount) {
+        void this.persistSelectedAccountAddress(nextSelectedAccount.address);
+      }
+    }
+    return nextAccounts;
+  }
+  async applyPreferredSelectedAccount(accounts) {
+    const preferredAddress = await this.readSelectedAccountAddress();
+    if (!preferredAddress) return;
+    if (!accounts.some((account) => account.address === preferredAddress)) {
+      return;
+    }
+    if (this.provider.getSelectedAccount()?.address === preferredAddress) {
+      return;
+    }
+    try {
+      await this.provider.selectAccount(preferredAddress);
+    } catch (error) {
+      console.warn("[NativeSDK] Failed to restore selected account:", error);
+    }
+  }
+  async persistSelectedAccountAddress(selectedAccountAddress) {
+    if (!this.storage) return;
+    try {
+      if (!selectedAccountAddress) {
+        await this.storage.removeItem(this.selectedAccountStorageKey);
+        return;
+      }
+      const snapshot = {
+        version: 1,
+        origin: this.origin,
+        walletOrigin: this.provider.getWalletOrigin(),
+        savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        selectedAccountAddress
+      };
+      await this.storage.setItem(
+        this.selectedAccountStorageKey,
+        JSON.stringify(snapshot)
+      );
+    } catch (error) {
+      console.warn("[NativeSDK] Failed to persist selected account:", error);
+    }
+  }
+  async clearPersistedConnection() {
+    if (!this.storage) return;
+    try {
+      await this.storage.removeItem(this.storageKey);
+    } catch (error) {
+      console.warn("[NativeSDK] Failed to clear connection state:", error);
+    }
+  }
+  async readSelectedAccountAddress() {
+    if (!this.storage) return null;
+    try {
+      const raw = await this.storage.getItem(this.selectedAccountStorageKey);
+      if (!raw) return null;
+      const parsed = JSON.parse(
+        raw
+      );
+      if (parsed.version !== 1 || parsed.origin !== this.origin || parsed.walletOrigin !== this.provider.getWalletOrigin() || typeof parsed.selectedAccountAddress !== "string" || parsed.selectedAccountAddress.length === 0) {
+        await this.storage.removeItem(this.selectedAccountStorageKey);
+        return null;
+      }
+      return parsed.selectedAccountAddress;
+    } catch (error) {
+      console.warn("[NativeSDK] Failed to restore selected account:", error);
+      try {
+        await this.storage.removeItem(this.selectedAccountStorageKey);
+      } catch {
+      }
+      return null;
+    }
+  }
+};
+function walletAvailabilityFromConnectResult(result, selectedAccount) {
+  const active = normalizeWalletAccountResult(result, null);
+  const hasActiveAccount = active.accounts.length > 0;
+  return {
+    status: "ready",
+    isAuthorized: hasActiveAccount,
+    isConnected: hasActiveAccount,
+    isUnlocked: true,
+    hasPasskey: hasActiveAccount,
+    hasWalletAccount: hasActiveAccount,
+    accounts: active.accounts,
+    selectedAccount: active.selectedAccount,
+    metadata: result.metadata ?? null,
+    error: null
+  };
+}
+function walletAvailabilityFromConnectionState(state) {
+  const active = normalizeConnectionStateResult(state);
+  const hasWalletAccount = state.hasWalletAccount ?? state.accounts.length > 0;
+  return {
+    status: "ready",
+    isAuthorized: state.isAuthorized,
+    isConnected: state.isAuthorized && state.isConnected,
+    isUnlocked: state.isUnlocked,
+    hasPasskey: state.hasPasskey,
+    hasWalletAccount,
+    accounts: active.accounts,
+    selectedAccount: active.selectedAccount,
+    metadata: state.isAuthorized ? state.metadata : null,
+    error: null
+  };
+}
+function walletAvailabilityFromError(error) {
+  return {
+    status: "error",
+    isAuthorized: false,
+    isConnected: false,
+    isUnlocked: false,
+    hasPasskey: false,
+    hasWalletAccount: false,
+    accounts: [],
+    selectedAccount: null,
+    metadata: null,
+    error: error instanceof Error ? error : new Error("Wallet availability check failed")
+  };
+}
+function isUserRejectedError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.code === ErrorCode.USER_REJECTED;
+}
+var CHECKING_WALLET_AVAILABILITY2 = {
+  status: "checking",
+  isAuthorized: false,
+  isConnected: false,
+  isUnlocked: false,
+  hasPasskey: false,
+  hasWalletAccount: false,
+  accounts: [],
+  selectedAccount: null,
+  metadata: null,
+  error: null
+};
+var ThruContext = createContext(null);
+function ThruProvider({ children, config }) {
+  const [sdk, setSdk] = useState(null);
+  const [thru, setThru] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [accounts, setAccounts] = useState([]);
+  const [isConnecting, setIsConnecting] = useState(false);
+  const [error, setError] = useState(null);
+  const [selectedAccount, setSelectedAccount] = useState(
+    null
+  );
+  const [walletAvailability, setWalletAvailability] = useState(CHECKING_WALLET_AVAILABILITY2);
+  useEffect(() => {
+    const sdkInstance = new NativeSDK(config);
+    setSdk(sdkInstance);
+    setThru(sdkInstance.getThru());
+    const updateAccountsFromSdk = () => setAccounts(sdkInstance.getAccounts());
+    const updateSelectedAccount = (account) => {
+      if (account) {
+        setSelectedAccount(account);
+        return;
+      }
+      const fallback = sdkInstance.getSelectedAccount() ?? sdkInstance.getAccounts()[0] ?? null;
+      setSelectedAccount(fallback);
+    };
+    const handleConnect = (result) => {
+      if (result?.status === "connecting") {
+        setIsConnecting(true);
+        setError(null);
+        return;
+      }
+      setIsConnected(true);
+      updateAccountsFromSdk();
+      setIsConnecting(false);
+      setError(null);
+      setWalletAvailability(sdkInstance.getWalletAvailability());
+      updateSelectedAccount();
+    };
+    const resetData = () => {
+      setIsConnected(false);
+      setAccounts([]);
+      setIsConnecting(false);
+      setSelectedAccount(null);
+    };
+    const handleDisconnect = () => resetData();
+    const handleError = (err) => {
+      setError(err?.error ?? err ?? new Error("Unknown error"));
+      setIsConnecting(false);
+      setWalletAvailability(sdkInstance.getWalletAvailability());
+    };
+    const handleLock = () => resetData();
+    const handleAccountChanged = (account) => {
+      updateAccountsFromSdk();
+      updateSelectedAccount(account ?? void 0);
+    };
+    const handleAvailabilityChanged = (availability) => {
+      setWalletAvailability(availability);
+    };
+    sdkInstance.on("connect", handleConnect);
+    sdkInstance.on("disconnect", handleDisconnect);
+    sdkInstance.on("error", handleError);
+    sdkInstance.on("lock", handleLock);
+    sdkInstance.on("accountChanged", handleAccountChanged);
+    sdkInstance.on("availabilityChanged", handleAvailabilityChanged);
+    void sdkInstance.restoreConnection({ hydrate: false }).catch(handleError);
+    return () => {
+      sdkInstance.off("connect", handleConnect);
+      sdkInstance.off("disconnect", handleDisconnect);
+      sdkInstance.off("error", handleError);
+      sdkInstance.off("lock", handleLock);
+      sdkInstance.off("accountChanged", handleAccountChanged);
+      sdkInstance.off("availabilityChanged", handleAvailabilityChanged);
+      sdkInstance.destroy();
+    };
+  }, []);
+  const selectAccount = useCallback(
+    async (account) => {
+      if (!sdk) throw new Error("NativeSDK not initialized");
+      try {
+        const updated = await sdk.selectAccount(account.address);
+        setSelectedAccount(updated);
+        setAccounts([updated]);
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("selectAccount failed")
+        );
+        throw err;
+      }
+    },
+    [sdk]
+  );
+  const manageAccounts = useCallback(async () => {
+    if (!sdk) throw new Error("NativeSDK not initialized");
+    try {
+      const result = await sdk.manageAccounts();
+      setSelectedAccount(result.selectedAccount);
+      setAccounts(result.accounts);
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("manageAccounts failed"));
+      throw err;
+    }
+  }, [sdk]);
+  return /* @__PURE__ */ jsx(
+    ThruContext.Provider,
+    {
+      value: {
+        thru,
+        wallet: sdk,
+        isConnected,
+        accounts,
+        isConnecting,
+        error,
+        selectedAccount,
+        walletAvailability,
+        selectAccount,
+        manageAccounts
+      },
+      children
+    }
+  );
+}
+
+// src/native/provider/shell.ts
+var SHELL_HTML_TEMPLATE = String.raw`<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+  <title>thru-shell</title>
+  <style>
+    html, body, iframe {
+      margin: 0;
+      padding: 0;
+      width: 100%;
+      height: 100%;
+      border: 0;
+      background: transparent;
+    }
+  </style>
+</head>
+<body>
+  <iframe
+    id="w"
+    data-src="WALLET_URL_PLACEHOLDER"
+    allow="publickey-credentials-get *; publickey-credentials-create *"
+  ></iframe>
+  <script>
+    (function () {
+      var f = document.getElementById('w');
+      var ORIGIN = 'WALLET_ORIGIN_PLACEHOLDER';
+      function frameId() {
+        try {
+          return new URL(f.dataset.src).searchParams.get('tn_frame_id');
+        } catch (err) {
+          return null;
+        }
+      }
+      function postShell(type, data) {
+        var rn = window.ReactNativeWebView;
+        if (!rn || !rn.postMessage) return;
+        try {
+          rn.postMessage(JSON.stringify({
+            type: type,
+            frameId: frameId(),
+            data: data || {}
+          }));
+        } catch (err) {
+          /* drop unserializable messages */
+        }
+      }
+      function postToWallet(msg) {
+        if (!f.contentWindow) return;
+        var outbound = msg;
+        if (msg && typeof msg === 'object') {
+          outbound = Object.assign({}, msg, { frameId: frameId() });
+        }
+        f.contentWindow.postMessage(outbound, ORIGIN);
+      }
+      window.addEventListener('message', function (e) {
+        var fromFrame = e.source === f.contentWindow;
+        var fromWalletOrigin = e.origin === ORIGIN;
+        var hasFrameId = e.data && e.data.frameId === frameId();
+        if (!fromWalletOrigin || (!fromFrame && !hasFrameId)) return;
+        var rn = window.ReactNativeWebView;
+        if (rn && rn.postMessage) {
+          try {
+            rn.postMessage(JSON.stringify(e.data));
+          } catch (err) {
+            /* drop unserializable messages */
+          }
+        }
+      });
+      window.__pushIn = postToWallet;
+      window.addEventListener('thru:native-sheet-dismiss', function () {
+        postToWallet({
+          type: 'thru:native-sheet-dismiss',
+          frameId: frameId()
+        });
+      });
+      f.addEventListener('load', function () {
+        postShell('shell:iframe-load', { src: f.src });
+      });
+      f.addEventListener('error', function () {
+        postShell('shell:iframe-error', { src: f.src });
+      });
+      postShell('shell:loading', { src: f.dataset.src });
+      f.src = f.dataset.src;
+    })();
+  </script>
+</body>
+</html>`;
+var SHELL_PLACEHOLDER_PATTERN = /WALLET_URL_PLACEHOLDER|WALLET_ORIGIN_PLACEHOLDER/g;
+function getShellHtml(opts) {
+  return SHELL_HTML_TEMPLATE.replace(
+    SHELL_PLACEHOLDER_PATTERN,
+    (placeholder) => placeholder === "WALLET_URL_PLACEHOLDER" ? opts.walletUrl : opts.walletOrigin
+  );
+}
+function useThru() {
+  const ctx = useContext(ThruContext);
+  if (!ctx) {
+    throw new Error("useThru must be used inside <ThruProvider>");
+  }
+  return ctx;
+}
+var Native = requireOptionalNativeModule(
+  "ThruWebViewBridge"
+);
+async function enableWebAuthnSupport(viewTag) {
+  if (Platform.OS !== "android") return false;
+  if (!Native) return false;
+  try {
+    return await Native.enableWebAuthnSupport(viewTag);
+  } catch (err) {
+    console.warn("[@thru/wallet/native/react] enableWebAuthnSupport failed:", err);
+    return false;
+  }
+}
+var DEFAULT_SHEET_BACKGROUND_COLOR = "#f9fbfb";
+var DEFAULT_SNAP_POINTS = ["50%", "85%"];
+var DEFAULT_FIT_CONTENT_MAX_SHEET_RATIO = 0.75;
+var DEFAULT_FIT_CONTENT_MIN_SHEET_RATIO = 0;
+var SHEET_HANDLE_HEIGHT = 10;
+var NATIVE_CONTENT_HEIGHT_MESSAGE = "wallet:content-height";
+var NATIVE_SCREEN_BRIGHTNESS_MESSAGE = "wallet:screen-brightness";
+var NATIVE_PAIR_DEVICE_QR_MESSAGE = "wallet:pair-device-qr";
+var NATIVE_PAIR_DEVICE_QR_STATUS_MESSAGE = "wallet:pair-device-qr-status";
+var NATIVE_BOTTOM_INSET_PARAM = "tn_native_bottom_inset";
+var NATIVE_QR_IMPORT_UNAVAILABLE_REASON = "react-native-qrcode-styled component unavailable";
+var NATIVE_QR_DARK_COLOR = "#151b1e";
+var NATIVE_QR_ACCENT_COLOR = "#239f97";
+var NATIVE_QR_ACCENT_DARK_COLOR = "#0a766f";
+var NATIVE_QR_GRADIENT = {
+  type: "linear",
+  options: {
+    colors: [
+      NATIVE_QR_DARK_COLOR,
+      NATIVE_QR_ACCENT_DARK_COLOR,
+      NATIVE_QR_ACCENT_COLOR
+    ],
+    start: [0, 0],
+    end: [1, 1],
+    locations: [0, 0.55, 1]
+  }
+};
+var NATIVE_QR_OUTER_EYE_OPTIONS = {
+  borderRadius: "34%",
+  color: NATIVE_QR_DARK_COLOR
+};
+var NATIVE_QR_INNER_EYE_OPTIONS = {
+  borderRadius: "50%",
+  color: NATIVE_QR_ACCENT_COLOR,
+  scale: 0.86
+};
+var NATIVE_QR_WARMUP_DATA = "thru:qr-warmup";
+var brightnessModulePromise = null;
+function getBrightnessModule() {
+  brightnessModulePromise ?? (brightnessModulePromise = import('expo-brightness').catch((error) => {
+    console.warn(
+      "[ThruWalletSheet] expo-brightness is unavailable in this native build:",
+      error
+    );
+    return null;
+  }));
+  return brightnessModulePromise;
+}
+async function getPreviousScreenBrightnessState(brightness) {
+  const previousState = {
+    brightness: await brightness.getBrightnessAsync(),
+    didSetSystemBrightness: false,
+    systemBrightness: null,
+    systemBrightnessMode: null,
+    wasUsingSystemBrightness: null
+  };
+  if (Platform.OS !== "android") return previousState;
+  const [systemBrightness, systemBrightnessMode, wasUsingSystemBrightness] = await Promise.all([
+    brightness.getSystemBrightnessAsync().catch(() => null),
+    brightness.getSystemBrightnessModeAsync().catch(() => null),
+    brightness.isUsingSystemBrightnessAsync().catch(() => null)
+  ]);
+  previousState.systemBrightness = systemBrightness;
+  previousState.systemBrightnessMode = systemBrightnessMode;
+  previousState.wasUsingSystemBrightness = wasUsingSystemBrightness;
+  return previousState;
+}
+function isReactComponentLike(input) {
+  if (typeof input === "function") return true;
+  if (typeof input !== "object" || input === null) return false;
+  const reactType = input.$$typeof;
+  return reactType === /* @__PURE__ */ Symbol.for("react.forward_ref") || reactType === /* @__PURE__ */ Symbol.for("react.memo") || reactType === /* @__PURE__ */ Symbol.for("react.lazy");
+}
+function resolveQRCodeComponent(module, namedExport) {
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [module];
+  for (let idx = 0; idx < candidates.length; idx++) {
+    const candidate = candidates[idx];
+    if (isReactComponentLike(candidate)) return candidate;
+    if (typeof candidate !== "object" || candidate === null || seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    const record = candidate;
+    candidates.push(record[namedExport], record.default);
+  }
+  return null;
+}
+var RESOLVED_QR_CODE_STYLED = resolveQRCodeComponent(
+  QRCodeStyledImport,
+  "QRCodeStyled"
+);
+function parsePairDeviceQrFrame(input) {
+  if (!input || typeof input !== "object") return null;
+  const frame = input;
+  const { top, left, width, height } = frame;
+  if (typeof top !== "number" || typeof left !== "number" || typeof width !== "number" || typeof height !== "number" || !Number.isFinite(top) || !Number.isFinite(left) || !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    return null;
+  }
+  return { top, left, width, height };
+}
+function getPairDeviceQrStatusScript(status, approveUrl, reason) {
+  const message = JSON.stringify({
+    type: NATIVE_PAIR_DEVICE_QR_STATUS_MESSAGE,
+    data: { status, approveUrl, reason }
+  });
+  return `
+    (function () {
+      var message = ${JSON.stringify(message)};
+      try {
+        var parsed = JSON.parse(message);
+        if (typeof window.__pushIn === 'function') {
+          window.__pushIn(parsed);
+        } else {
+          window.dispatchEvent(new MessageEvent('message', {
+            data: parsed,
+            origin: window.location.origin
+          }));
+        }
+      } catch (error) {}
+    })();
+    true;
+  `;
+}
+var OptionalNativeQrBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error) {
+    this.props.onError(error);
+  }
+  render() {
+    if (this.state.hasError) return null;
+    return this.props.children;
+  }
+};
+function appendNativeBottomInset(urlValue, bottomInset) {
+  try {
+    const url = new URL(urlValue);
+    url.searchParams.set(
+      NATIVE_BOTTOM_INSET_PARAM,
+      String(Math.max(0, Math.ceil(bottomInset)))
+    );
+    return url.toString();
+  } catch {
+    return urlValue;
+  }
+}
+var ThruWalletSheet = forwardRef(function ThruWalletSheet2({
+  snapPoints,
+  initialOpenIndex,
+  backgroundColor = DEFAULT_SHEET_BACKGROUND_COLOR
+}, ref) {
+  const { wallet } = useThru();
+  const { height } = useWindowDimensions();
+  const insets = useSafeAreaInsets();
+  const sheetRef = useRef(null);
+  const webViewRef = useRef(null);
+  const webViewNativeTagRef = useRef(null);
+  const brightnessQueueRef = useRef(Promise.resolve());
+  const previousScreenBrightnessRef = useRef(null);
+  const didRefreshWalletAvailabilityRef = useRef(false);
+  const isProviderClosingRef = useRef(false);
+  const isSheetOpenRef = useRef(false);
+  const containerLayoutState = useSharedValue({
+    height,
+    offset: { top: 0, bottom: 0, left: 0, right: 0 }
+  });
+  const [shellHtml, setShellHtml] = useState(null);
+  const [directWalletUrl, setDirectWalletUrl] = useState(null);
+  const [hasBridgeMessage, setHasBridgeMessage] = useState(false);
+  const [walletLoadStatus, setWalletLoadStatus] = useState("Loading wallet...");
+  const [webViewError, setWebViewError] = useState(null);
+  const [webContentHeight, setWebContentHeight] = useState(null);
+  const [webContentMaxSheetRatio, setWebContentMaxSheetRatio] = useState(
+    DEFAULT_FIT_CONTENT_MAX_SHEET_RATIO
+  );
+  const [webContentMinSheetRatio, setWebContentMinSheetRatio] = useState(
+    DEFAULT_FIT_CONTENT_MIN_SHEET_RATIO
+  );
+  const [pairDeviceQr, setPairDeviceQr] = useState(
+    null
+  );
+  const [QRCodeStyled, setQRCodeStyled] = useState(() => RESOLVED_QR_CODE_STYLED);
+  const [isNativeQrUnavailable, setIsNativeQrUnavailable] = useState(
+    () => RESOLVED_QR_CODE_STYLED === null
+  );
+  const [nativeQrUnavailableReason, setNativeQrUnavailableReason] = useState(
+    () => RESOLVED_QR_CODE_STYLED ? null : NATIVE_QR_IMPORT_UNAVAILABLE_REASON
+  );
+  const shouldFitContent = !snapPoints || snapPoints.length === 0;
+  const configuredSnapPoints = useMemo(
+    () => snapPoints && snapPoints.length > 0 ? snapPoints : DEFAULT_SNAP_POINTS,
+    [snapPoints]
+  );
+  const memoSnapPoints = useMemo(() => {
+    if (!shouldFitContent || webContentHeight == null)
+      return configuredSnapPoints;
+    const maxSheetHeight = Math.floor(height * webContentMaxSheetRatio);
+    const minSheetHeight = Math.floor(
+      height * Math.min(webContentMinSheetRatio, webContentMaxSheetRatio)
+    );
+    const fittedSheetHeight = Math.min(
+      Math.max(webContentHeight + SHEET_HANDLE_HEIGHT, minSheetHeight),
+      maxSheetHeight
+    );
+    if (fittedSheetHeight >= maxSheetHeight - 1) {
+      return [maxSheetHeight];
+    }
+    return [fittedSheetHeight, maxSheetHeight];
+  }, [
+    configuredSnapPoints,
+    height,
+    shouldFitContent,
+    webContentHeight,
+    webContentMaxSheetRatio,
+    webContentMinSheetRatio
+  ]);
+  const openIndex = Math.max(
+    0,
+    Math.min(initialOpenIndex ?? 0, memoSnapPoints.length - 1)
+  );
+  const snapToSheetIndex = useCallback(
+    (index) => {
+      const maxIndex = Math.max(0, memoSnapPoints.length - 1);
+      sheetRef.current?.snapToIndex(Math.max(0, Math.min(index, maxIndex)));
+    },
+    [memoSnapPoints.length]
+  );
+  const enqueueBrightnessTask = useCallback((task) => {
+    const queuedTask = brightnessQueueRef.current.then(task, task);
+    brightnessQueueRef.current = queuedTask.catch(() => {
+    });
+  }, []);
+  const restoreScreenBrightness = useCallback(() => {
+    enqueueBrightnessTask(async () => {
+      const previousState = previousScreenBrightnessRef.current;
+      previousScreenBrightnessRef.current = null;
+      if (!previousState) return;
+      try {
+        const brightness = await getBrightnessModule();
+        if (!brightness) return;
+        if (Platform.OS === "android") {
+          if (previousState.didSetSystemBrightness && previousState.systemBrightness !== null) {
+            try {
+              await brightness.setSystemBrightnessAsync(
+                previousState.systemBrightness
+              );
+              if (previousState.systemBrightnessMode !== null) {
+                await brightness.setSystemBrightnessModeAsync(
+                  previousState.systemBrightnessMode
+                );
+              }
+            } catch {
+            }
+          }
+          if (previousState.wasUsingSystemBrightness) {
+            try {
+              await brightness.restoreSystemBrightnessAsync();
+              return;
+            } catch {
+            }
+          }
+        }
+        await brightness.setBrightnessAsync(previousState.brightness);
+      } catch (error) {
+        console.warn(
+          "[ThruWalletSheet] Failed to restore screen brightness:",
+          error
+        );
+      }
+    });
+  }, [enqueueBrightnessTask]);
+  const maximizeScreenBrightness = useCallback(() => {
+    enqueueBrightnessTask(async () => {
+      try {
+        const brightness = await getBrightnessModule();
+        if (!brightness) return;
+        if (previousScreenBrightnessRef.current == null) {
+          previousScreenBrightnessRef.current = await getPreviousScreenBrightnessState(brightness);
+        }
+        await brightness.setBrightnessAsync(1);
+        if (Platform.OS === "android") {
+          try {
+            await brightness.setSystemBrightnessAsync(1);
+            if (previousScreenBrightnessRef.current) {
+              previousScreenBrightnessRef.current.didSetSystemBrightness = true;
+            }
+          } catch {
+          }
+        }
+      } catch (error) {
+        console.warn(
+          "[ThruWalletSheet] Failed to maximize screen brightness:",
+          error
+        );
+      }
+    });
+  }, [enqueueBrightnessTask]);
+  const sendPairDeviceQrStatus = useCallback(
+    (status, approveUrl, reason) => {
+      webViewRef.current?.injectJavaScript(
+        getPairDeviceQrStatusScript(status, approveUrl, reason ?? void 0)
+      );
+    },
+    []
+  );
+  const handleNativeQrError = useCallback(
+    (error) => {
+      console.warn("[ThruWalletSheet] Failed to render native QR:", error);
+      const reason = error instanceof Error ? `react-native-qrcode-styled render failed: ${error.message}` : "react-native-qrcode-styled render failed";
+      if (pairDeviceQr) {
+        sendPairDeviceQrStatus("unavailable", pairDeviceQr.approveUrl, reason);
+      }
+      setNativeQrUnavailableReason(reason);
+      setIsNativeQrUnavailable(true);
+      setPairDeviceQr(null);
+    },
+    [pairDeviceQr, sendPairDeviceQrStatus]
+  );
+  useEffect(() => {
+    containerLayoutState.value = {
+      height,
+      offset: { top: 0, bottom: 0, left: 0, right: 0 }
+    };
+  }, [containerLayoutState, height]);
+  useEffect(() => {
+    return () => {
+      restoreScreenBrightness();
+    };
+  }, [restoreScreenBrightness]);
+  useEffect(() => {
+    if (!wallet) return;
+    const walletUrl = appendNativeBottomInset(
+      wallet.getIframeSrc(),
+      insets.bottom
+    );
+    const useDirectWallet = Platform.OS === "ios" && wallet.getIosWebViewMode() === "direct";
+    if (useDirectWallet) {
+      setDirectWalletUrl(walletUrl);
+      setShellHtml(null);
+    } else {
+      const html = getShellHtml({
+        walletUrl,
+        walletOrigin: wallet.getWalletOrigin()
+      });
+      setShellHtml(html);
+      setDirectWalletUrl(null);
+    }
+    setHasBridgeMessage(false);
+    setWalletLoadStatus("Loading wallet...");
+    setWebViewError(null);
+    setWebContentHeight(null);
+    setWebContentMaxSheetRatio(DEFAULT_FIT_CONTENT_MAX_SHEET_RATIO);
+    setWebContentMinSheetRatio(DEFAULT_FIT_CONTENT_MIN_SHEET_RATIO);
+    setPairDeviceQr(null);
+    setQRCodeStyled(() => RESOLVED_QR_CODE_STYLED);
+    setNativeQrUnavailableReason(
+      RESOLVED_QR_CODE_STYLED ? null : NATIVE_QR_IMPORT_UNAVAILABLE_REASON
+    );
+    setIsNativeQrUnavailable(RESOLVED_QR_CODE_STYLED === null);
+    didRefreshWalletAvailabilityRef.current = false;
+  }, [insets.bottom, wallet]);
+  useEffect(() => {
+    if (!pairDeviceQr) return;
+    if (pairDeviceQr.qrDataUrl || QRCodeStyled && !isNativeQrUnavailable) {
+      sendPairDeviceQrStatus("ready", pairDeviceQr.approveUrl);
+    } else if (isNativeQrUnavailable) {
+      sendPairDeviceQrStatus(
+        "unavailable",
+        pairDeviceQr.approveUrl,
+        nativeQrUnavailableReason
+      );
+    }
+  }, [
+    QRCodeStyled,
+    isNativeQrUnavailable,
+    nativeQrUnavailableReason,
+    pairDeviceQr,
+    sendPairDeviceQrStatus
+  ]);
+  const isDirectWalletSource = directWalletUrl !== null;
+  const attachIfReady = useCallback(() => {
+    if (!wallet || !webViewRef.current) return;
+    const ref2 = {
+      injectJavaScript: (script) => {
+        webViewRef.current?.injectJavaScript(script);
+      }
+    };
+    wallet.attachWebView(ref2);
+  }, [wallet]);
+  const enableAndroidWebAuthnIfNeeded = useCallback(async () => {
+    if (Platform.OS !== "android") return false;
+    const enabled = await enableWebAuthnSupport(webViewNativeTagRef.current);
+    webViewRef.current?.injectJavaScript(
+      "window.dispatchEvent(new Event('thru:native-webauthn-ready')); true;"
+    );
+    return enabled;
+  }, []);
+  const handleWebViewLayout = useCallback(
+    (event) => {
+      const target = event.nativeEvent.target;
+      webViewNativeTagRef.current = typeof target === "number" ? target : webViewNativeTagRef.current;
+      void enableAndroidWebAuthnIfNeeded();
+    },
+    [enableAndroidWebAuthnIfNeeded]
+  );
+  const refreshWalletAvailabilityIfReady = useCallback(() => {
+    if (!wallet || didRefreshWalletAvailabilityRef.current) return;
+    didRefreshWalletAvailabilityRef.current = true;
+    void wallet.refreshWalletAvailability();
+  }, [wallet]);
+  const handleLoadEnd = useCallback(() => {
+    attachIfReady();
+    if (isDirectWalletSource) {
+      wallet?.markWebViewReady();
+      setHasBridgeMessage(true);
+      setWebViewError(null);
+      void enableAndroidWebAuthnIfNeeded().finally(
+        refreshWalletAvailabilityIfReady
+      );
+    }
+  }, [
+    attachIfReady,
+    enableAndroidWebAuthnIfNeeded,
+    isDirectWalletSource,
+    refreshWalletAvailabilityIfReady,
+    wallet
+  ]);
+  useEffect(() => {
+    if (!wallet) return;
+    wallet.setUiHandlers({
+      onShowRequested: () => {
+        isProviderClosingRef.current = false;
+        snapToSheetIndex(openIndex);
+      },
+      onHideRequested: () => {
+        isProviderClosingRef.current = true;
+        sheetRef.current?.close();
+      }
+    });
+    return () => {
+      wallet.clearUiHandlers();
+    };
+  }, [wallet, openIndex, snapToSheetIndex]);
+  useEffect(() => {
+    if (!isSheetOpenRef.current) return;
+    const animationFrame = requestAnimationFrame(() => {
+      snapToSheetIndex(openIndex);
+    });
+    return () => cancelAnimationFrame(animationFrame);
+  }, [height, memoSnapPoints, openIndex, snapToSheetIndex]);
+  const walletOrigin = wallet?.getWalletOrigin();
+  const webViewSource = useMemo(() => {
+    if (directWalletUrl) return { uri: directWalletUrl };
+    if (shellHtml) {
+      return { html: shellHtml, baseUrl: walletOrigin ?? "about:blank" };
+    }
+    return null;
+  }, [directWalletUrl, shellHtml, walletOrigin]);
+  useEffect(() => {
+    if (!webViewSource) return;
+    attachIfReady();
+    void enableAndroidWebAuthnIfNeeded();
+  }, [attachIfReady, enableAndroidWebAuthnIfNeeded, webViewSource]);
+  const limitsNavigationsToAppBoundDomains = Platform.OS === "ios" && isDirectWalletSource;
+  const handleMessage = useCallback(
+    (event) => {
+      let shouldRefreshAfterBridgeReady = false;
+      try {
+        const data = JSON.parse(event.nativeEvent.data);
+        if (data.type === NATIVE_CONTENT_HEIGHT_MESSAGE) {
+          const nextMaxSheetRatio = data.data?.maxSheetRatio;
+          const nextMinSheetRatio = data.data?.minSheetRatio;
+          setWebContentMaxSheetRatio(
+            typeof nextMaxSheetRatio === "number" && Number.isFinite(nextMaxSheetRatio) && nextMaxSheetRatio > 0 && nextMaxSheetRatio <= 1 ? nextMaxSheetRatio : DEFAULT_FIT_CONTENT_MAX_SHEET_RATIO
+          );
+          setWebContentMinSheetRatio(
+            typeof nextMinSheetRatio === "number" && Number.isFinite(nextMinSheetRatio) && nextMinSheetRatio >= 0 && nextMinSheetRatio <= 1 ? nextMinSheetRatio : DEFAULT_FIT_CONTENT_MIN_SHEET_RATIO
+          );
+          if (data.data?.fitContent === false) {
+            setWebContentHeight(null);
+            return;
+          }
+          const nextHeight = data.data?.height;
+          if (typeof nextHeight === "number" && Number.isFinite(nextHeight) && nextHeight > 0) {
+            setWebContentHeight(Math.ceil(nextHeight));
+          }
+          return;
+        }
+        if (data.type === NATIVE_PAIR_DEVICE_QR_MESSAGE) {
+          if (data.data?.visible === false) {
+            setPairDeviceQr(null);
+            return;
+          }
+          const approveUrl = data.data?.approveUrl;
+          const frame = parsePairDeviceQrFrame(data.data?.frame);
+          if (typeof approveUrl === "string" && approveUrl && frame) {
+            const qrDataUrl = typeof data.data?.qrDataUrl === "string" && data.data.qrDataUrl.startsWith("data:image/") ? data.data.qrDataUrl : void 0;
+            if (isNativeQrUnavailable) {
+              sendPairDeviceQrStatus(
+                "unavailable",
+                approveUrl,
+                nativeQrUnavailableReason
+              );
+              return;
+            }
+            setPairDeviceQr({ approveUrl, frame, qrDataUrl });
+            sendPairDeviceQrStatus("rendering", approveUrl);
+          }
+          return;
+        }
+        if (data.type === NATIVE_SCREEN_BRIGHTNESS_MESSAGE) {
+          if (data.data?.mode === "max") {
+            maximizeScreenBrightness();
+          } else if (data.data?.mode === "restore") {
+            restoreScreenBrightness();
+          }
+          return;
+        }
+        if (data.type === "shell:loading") {
+          setWalletLoadStatus("Loading wallet iframe...");
+          return;
+        }
+        if (data.type === "shell:iframe-load") {
+          setWebViewError(null);
+          setWalletLoadStatus(
+            "Wallet iframe loaded. Waiting for wallet app..."
+          );
+          return;
+        }
+        if (data.type === "shell:iframe-error") {
+          if (hasBridgeMessage) {
+            console.warn(
+              "[ThruWalletSheet] Ignoring post-ready wallet iframe error:",
+              data.data
+            );
+            return;
+          }
+          setWebViewError(
+            `Wallet iframe failed to load${data.data?.src ? `: ${data.data.src}` : ""}`
+          );
+          return;
+        }
+        if (data.type === "iframe:ready") {
+          setHasBridgeMessage(true);
+          setWebViewError(null);
+          shouldRefreshAfterBridgeReady = true;
+        }
+      } catch {
+      }
+      wallet?.onMessage({
+        nativeEvent: { data: event.nativeEvent.data }
+      });
+      if (shouldRefreshAfterBridgeReady) {
+        void enableAndroidWebAuthnIfNeeded().finally(
+          refreshWalletAvailabilityIfReady
+        );
+      }
+    },
+    [
+      enableAndroidWebAuthnIfNeeded,
+      hasBridgeMessage,
+      isNativeQrUnavailable,
+      nativeQrUnavailableReason,
+      maximizeScreenBrightness,
+      refreshWalletAvailabilityIfReady,
+      restoreScreenBrightness,
+      sendPairDeviceQrStatus,
+      wallet
+    ]
+  );
+  useImperativeHandle(
+    ref,
+    () => ({
+      expand: (index) => snapToSheetIndex(index ?? openIndex),
+      close: () => sheetRef.current?.close()
+    }),
+    [openIndex, snapToSheetIndex]
+  );
+  const handleSheetChange = useCallback(
+    (index) => {
+      isSheetOpenRef.current = index !== -1;
+      if (index !== -1) return;
+      restoreScreenBrightness();
+      setPairDeviceQr(null);
+      if (isProviderClosingRef.current) {
+        isProviderClosingRef.current = false;
+        return;
+      }
+      wallet?.rejectPendingRequests();
+      webViewRef.current?.injectJavaScript(
+        "window.dispatchEvent(new Event('thru:native-sheet-dismiss')); true;"
+      );
+    },
+    [restoreScreenBrightness, wallet]
+  );
+  const pairDeviceQrSize = pairDeviceQr ? Math.max(
+    96,
+    Math.floor(
+      Math.min(pairDeviceQr.frame.width, pairDeviceQr.frame.height) - 32
+    )
+  ) : 0;
+  const pairDeviceQrBadgeFontSize = Math.max(16, pairDeviceQrSize * 0.1);
+  const renderHandle = useCallback(
+    () => /* @__PURE__ */ jsx(View, { style: [styles.handleContainer, { backgroundColor }], children: /* @__PURE__ */ jsx(View, { style: styles.handleIndicator }) }),
+    [backgroundColor]
+  );
+  const renderBackdrop = useCallback(
+    (props) => /* @__PURE__ */ jsx(
+      BottomSheetBackdrop,
+      {
+        ...props,
+        appearsOnIndex: 0,
+        disappearsOnIndex: -1,
+        opacity: 0.38,
+        pressBehavior: "close"
+      }
+    ),
+    []
+  );
+  return /* @__PURE__ */ jsx(
+    BottomSheet,
+    {
+      ref: sheetRef,
+      index: -1,
+      snapPoints: memoSnapPoints,
+      containerLayoutState,
+      enableDynamicSizing: false,
+      enableContentPanningGesture: false,
+      handleComponent: renderHandle,
+      backdropComponent: renderBackdrop,
+      enablePanDownToClose: true,
+      onChange: handleSheetChange,
+      backgroundStyle: { backgroundColor },
+      children: /* @__PURE__ */ jsxs(View, { style: [styles.body, { backgroundColor }], children: [
+        QRCodeStyled ? /* @__PURE__ */ jsx(
+          View,
+          {
+            collapsable: false,
+            pointerEvents: "none",
+            style: styles.nativeQrWarmup,
+            children: /* @__PURE__ */ jsx(
+              QRCodeStyled,
+              {
+                data: NATIVE_QR_WARMUP_DATA,
+                size: 64,
+                color: NATIVE_QR_DARK_COLOR,
+                errorCorrectionLevel: "L",
+                padding: 0,
+                pieceScale: 1.025
+              }
+            )
+          }
+        ) : null,
+        webViewSource ? /* @__PURE__ */ jsx(
+          WebView,
+          {
+            ref: webViewRef,
+            source: webViewSource,
+            originWhitelist: ["*"],
+            javaScriptEnabled: true,
+            domStorageEnabled: true,
+            webviewDebuggingEnabled: __DEV__,
+            nestedScrollEnabled: true,
+            sharedCookiesEnabled: true,
+            allowsInlineMediaPlayback: true,
+            mediaPlaybackRequiresUserAction: false,
+            limitsNavigationsToAppBoundDomains,
+            onLoadStart: () => {
+              attachIfReady();
+              void enableAndroidWebAuthnIfNeeded();
+            },
+            onLoadEnd: handleLoadEnd,
+            onLayout: handleWebViewLayout,
+            onError: (event) => {
+              const description = event.nativeEvent.description || "Wallet WebView failed to load";
+              if (hasBridgeMessage) {
+                console.warn(
+                  "[ThruWalletSheet] Ignoring post-ready WebView error:",
+                  event.nativeEvent
+                );
+                return;
+              }
+              setWebViewError(description);
+              console.warn("[ThruWalletSheet] WebView error:", description);
+            },
+            onHttpError: (event) => {
+              const status = event.nativeEvent.statusCode;
+              const description = `Wallet returned HTTP ${status}`;
+              if (hasBridgeMessage) {
+                console.warn(
+                  "[ThruWalletSheet] Ignoring post-ready WebView HTTP error:",
+                  event.nativeEvent
+                );
+                return;
+              }
+              setWebViewError(description);
+              console.warn(
+                "[ThruWalletSheet] WebView HTTP error:",
+                description
+              );
+            },
+            onMessage: handleMessage,
+            style: [styles.webview, { backgroundColor }]
+          }
+        ) : null,
+        webViewSource && (!isDirectWalletSource && !hasBridgeMessage || webViewError) ? /* @__PURE__ */ jsxs(
+          View,
+          {
+            pointerEvents: "none",
+            style: [styles.loadingOverlay, { backgroundColor }],
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: styles.loadingTitle, children: webViewError ? "Wallet failed to load" : walletLoadStatus }),
+              webViewError ? /* @__PURE__ */ jsx(Text, { style: styles.loadingDetail, children: webViewError }) : null
+            ]
+          }
+        ) : null,
+        pairDeviceQr && (pairDeviceQr.qrDataUrl || QRCodeStyled) ? /* @__PURE__ */ jsx(
+          View,
+          {
+            pointerEvents: "none",
+            style: [
+              styles.nativeQrOverlay,
+              {
+                height: pairDeviceQr.frame.height,
+                left: pairDeviceQr.frame.left,
+                top: pairDeviceQr.frame.top,
+                width: pairDeviceQr.frame.width
+              }
+            ],
+            children: /* @__PURE__ */ jsx(
+              OptionalNativeQrBoundary,
+              {
+                onError: handleNativeQrError,
+                children: /* @__PURE__ */ jsx(View, { style: styles.nativeQrCard, children: pairDeviceQr.qrDataUrl ? /* @__PURE__ */ jsx(
+                  Image,
+                  {
+                    resizeMode: "contain",
+                    source: { uri: pairDeviceQr.qrDataUrl },
+                    style: [
+                      styles.nativeQrImage,
+                      {
+                        height: pairDeviceQrSize,
+                        width: pairDeviceQrSize
+                      }
+                    ]
+                  }
+                ) : QRCodeStyled ? /* @__PURE__ */ jsxs(
+                  View,
+                  {
+                    style: [
+                      styles.nativeQrStyledFallback,
+                      {
+                        height: pairDeviceQrSize,
+                        width: pairDeviceQrSize
+                      }
+                    ],
+                    children: [
+                      /* @__PURE__ */ jsx(
+                        QRCodeStyled,
+                        {
+                          data: pairDeviceQr.approveUrl,
+                          size: pairDeviceQrSize,
+                          color: NATIVE_QR_DARK_COLOR,
+                          gradient: NATIVE_QR_GRADIENT,
+                          errorCorrectionLevel: "H",
+                          innerEyesOptions: NATIVE_QR_INNER_EYE_OPTIONS,
+                          isPiecesGlued: true,
+                          outerEyesOptions: NATIVE_QR_OUTER_EYE_OPTIONS,
+                          padding: 0,
+                          pieceBorderRadius: "42%",
+                          pieceCornerType: "rounded",
+                          pieceLiquidRadius: "30%",
+                          pieceScale: 1.02,
+                          style: styles.nativeQrSvg
+                        }
+                      ),
+                      /* @__PURE__ */ jsx(View, { style: styles.nativeQrFallbackBadge, children: /* @__PURE__ */ jsx(
+                        Text,
+                        {
+                          style: [
+                            styles.nativeQrFallbackBadgeText,
+                            {
+                              fontSize: pairDeviceQrBadgeFontSize,
+                              lineHeight: pairDeviceQrBadgeFontSize * 1.05
+                            }
+                          ],
+                          children: "J"
+                        }
+                      ) })
+                    ]
+                  }
+                ) : null })
+              },
+              pairDeviceQr.approveUrl
+            )
+          }
+        ) : null
+      ] })
+    }
+  );
+});
+var styles = StyleSheet.create({
+  body: { flex: 1 },
+  handleContainer: {
+    alignItems: "center",
+    height: SHEET_HANDLE_HEIGHT,
+    justifyContent: "flex-start",
+    paddingTop: 4
+  },
+  handleIndicator: {
+    backgroundColor: "#cdd5db",
+    borderRadius: 999,
+    height: 4,
+    width: 42
+  },
+  loadingDetail: {
+    color: "#4b635f",
+    fontSize: 13,
+    lineHeight: 18,
+    maxWidth: 280,
+    textAlign: "center"
+  },
+  loadingOverlay: {
+    alignItems: "center",
+    bottom: 0,
+    gap: 8,
+    justifyContent: "center",
+    left: 0,
+    padding: 24,
+    position: "absolute",
+    right: 0,
+    top: 0
+  },
+  loadingTitle: {
+    color: "#172b29",
+    fontSize: 16,
+    fontWeight: "600",
+    textAlign: "center"
+  },
+  nativeQrCard: {
+    alignItems: "center",
+    backgroundColor: "#ffffff",
+    borderColor: "#dbe4e8",
+    borderRadius: 8,
+    borderWidth: StyleSheet.hairlineWidth,
+    flex: 1,
+    justifyContent: "center"
+  },
+  nativeQrOverlay: {
+    elevation: 16,
+    position: "absolute",
+    zIndex: 16
+  },
+  nativeQrImage: {
+    backgroundColor: "#ffffff"
+  },
+  nativeQrFallbackBadge: {
+    alignItems: "center",
+    aspectRatio: 1,
+    backgroundColor: "#ffffff",
+    borderColor: "#d1e1e1",
+    borderRadius: 999,
+    borderWidth: StyleSheet.hairlineWidth,
+    justifyContent: "center",
+    left: "41.5%",
+    position: "absolute",
+    top: "41.5%",
+    width: "17%"
+  },
+  nativeQrFallbackBadgeText: {
+    color: NATIVE_QR_ACCENT_DARK_COLOR,
+    fontWeight: "700",
+    includeFontPadding: false,
+    textAlign: "center"
+  },
+  nativeQrStyledFallback: {
+    alignItems: "center",
+    backgroundColor: "#ffffff",
+    justifyContent: "center"
+  },
+  nativeQrSvg: {
+    backgroundColor: "#ffffff"
+  },
+  nativeQrWarmup: {
+    height: 64,
+    left: -128,
+    opacity: 0,
+    position: "absolute",
+    top: -128,
+    width: 64,
+    zIndex: -1
+  },
+  webview: { flex: 1, backgroundColor: "transparent" }
+});
+
+// src/native/react/hooks/waitForWallet.ts
+function waitForWallet(getWallet, timeout = 5e3, interval = 100) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      const sdk = getWallet();
+      if (sdk) return resolve(sdk);
+      if (Date.now() - start > timeout) {
+        return reject(new Error("NativeSDK not initialized in time"));
+      }
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}
+
+// src/native/react/hooks/useWallet.ts
+function useWallet() {
+  const {
+    wallet,
+    isConnected,
+    isConnecting,
+    accounts,
+    selectedAccount,
+    selectAccount,
+    manageAccounts,
+    walletAvailability
+  } = useThru();
+  const walletRef = useRef(wallet);
+  useEffect(() => {
+    walletRef.current = wallet;
+  }, [wallet]);
+  const connect = useCallback(async (options) => {
+    const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    return ready.connect(options);
+  }, []);
+  const signIn = useCallback(async (options) => {
+    const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    return ready.signIn(options);
+  }, []);
+  const disconnect = useCallback(async () => {
+    const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    await ready.disconnect();
+  }, []);
+  const refreshWalletAvailability = useCallback(async (options) => {
+    const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    return ready.refreshWalletAvailability(options);
+  }, []);
+  return {
+    /** Chain interface (`provider.thru`); undefined until connected. */
+    wallet: wallet?.thru,
+    accounts,
+    connect,
+    signIn,
+    disconnect,
+    isConnected: isConnected && !!wallet,
+    isConnecting,
+    selectedAccount,
+    selectAccount,
+    manageAccounts,
+    walletAvailability,
+    hasPasskey: walletAvailability.hasPasskey,
+    hasWalletAccount: walletAvailability.hasWalletAccount,
+    isWalletAvailabilityLoading: walletAvailability.status === "checking",
+    refreshWalletAvailability
+  };
+}
+function useWalletAvailability() {
+  const { wallet, walletAvailability } = useThru();
+  const walletRef = useRef(wallet);
+  useEffect(() => {
+    walletRef.current = wallet;
+  }, [wallet]);
+  const refreshWalletAvailability = async (options) => {
+    const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    return ready.refreshWalletAvailability(options);
+  };
+  return {
+    walletAvailability,
+    refreshWalletAvailability,
+    hasPasskey: walletAvailability.hasPasskey,
+    hasWalletAccount: walletAvailability.hasWalletAccount,
+    isAuthorized: walletAvailability.isAuthorized,
+    isWalletAvailabilityLoading: walletAvailability.status === "checking",
+    accounts: walletAvailability.accounts,
+    selectedAccount: walletAvailability.selectedAccount,
+    error: walletAvailability.error
+  };
+}
+function useAccounts({ onAccountSelect } = {}) {
+  const { accounts, selectedAccount, isConnected, isConnecting } = useThru();
+  const lastSeen = useRef(null);
+  useEffect(() => {
+    if (!selectedAccount) {
+      lastSeen.current = null;
+      return;
+    }
+    if (lastSeen.current === selectedAccount.address) return;
+    lastSeen.current = selectedAccount.address;
+    onAccountSelect?.(selectedAccount);
+  }, [selectedAccount, onAccountSelect]);
+  return {
+    accounts,
+    selectedAccount,
+    isConnected,
+    isConnecting
+  };
+}
+
+export { ThruContext, ThruProvider, ThruWalletSheet, enableWebAuthnSupport, useAccounts, useThru, useWallet, useWalletAvailability };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map