@thru/wallet 0.2.25 → 0.2.28

package/dist/native/react/transparent.js

@@ -0,0 +1,2210 @@
+import { createContext, useState, useEffect, useCallback, useContext, useRef, useMemo } from 'react';
+import { createThruClient } from '@thru/sdk/client';
+import { jsx } from 'react/jsx-runtime';
+import { StyleSheet, Platform, View } from 'react-native';
+import { WebView } from 'react-native-webview';
+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",
+  CREATE_ACCOUNT: "createAccount",
+  DISCONNECT: "disconnect",
+  SIGN_MESSAGE: "signMessage",
+  SIGN_TRANSACTION: "signTransaction",
+  SIGN_PASSKEY_CHALLENGE: "signPasskeyChallenge",
+  GET_ACCOUNTS: "getAccounts",
+  GET_CONNECTION_STATE: "getConnectionState",
+  GET_SIGNING_CONTEXT: "getSigningContext",
+  SELECT_ACCOUNT: "selectAccount",
+  MANAGE_ACCOUNTS: "manageAccounts",
+  CREATE_SIGNING_SESSION: "createSigningSession",
+  CREATE_SIGNING_SESSION_INSTRUCTION: "createSigningSessionInstruction",
+  CONFIRM_SIGNING_SESSION: "confirmSigningSession",
+  REVOKE_SIGNING_SESSION: "revokeSigningSession"
+};
+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/encoding.ts
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_LOOKUP = new Map(
+  [...BASE64_ALPHABET].map((char, index) => [char, index])
+);
+function base64ToBytes(value) {
+  const normalized = value.replace(/\s+/g, "");
+  if (normalized.length === 0) return new Uint8Array();
+  if (normalized.length % 4 === 1) {
+    throw new Error("Invalid base64 data");
+  }
+  const padded = normalized.padEnd(
+    normalized.length + (4 - normalized.length % 4) % 4,
+    "="
+  );
+  const padding = padded.endsWith("==") ? 2 : padded.endsWith("=") ? 1 : 0;
+  const output = new Uint8Array(padded.length / 4 * 3 - padding);
+  let outIdx = 0;
+  for (let i = 0; i < padded.length; i += 4) {
+    const chars = padded.slice(i, i + 4);
+    const a = BASE64_LOOKUP.get(chars[0]);
+    const b = BASE64_LOOKUP.get(chars[1]);
+    const c = chars[2] === "=" ? 0 : BASE64_LOOKUP.get(chars[2]);
+    const d = chars[3] === "=" ? 0 : BASE64_LOOKUP.get(chars[3]);
+    if (a === void 0 || b === void 0 || c === void 0 || d === void 0) {
+      throw new Error("Invalid base64 data");
+    }
+    const chunk = a << 18 | b << 12 | c << 6 | d;
+    if (outIdx < output.length) output[outIdx++] = chunk >> 16 & 255;
+    if (outIdx < output.length) output[outIdx++] = chunk >> 8 & 255;
+    if (outIdx < output.length) output[outIdx++] = chunk & 255;
+  }
+  return output;
+}
+
+// src/signing-sessions.ts
+var STORAGE_VERSION = 1;
+var KEY_PREFIX = "thru.wallet.signing-sessions.v1";
+function encodeKeyPart(input) {
+  return encodeURIComponent(input).replace(
+    /[!'()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function resolveSigningSessionStorageKey(params) {
+  if (params.storageKey) return params.storageKey;
+  return `${KEY_PREFIX}:${encodeKeyPart(params.walletOrigin)}:${encodeKeyPart(params.appOrigin)}`;
+}
+function normalizeExpiresAt(value, label = "expiresAt") {
+  if (value instanceof Date) {
+    const millis = value.getTime();
+    if (!Number.isFinite(millis)) throw new Error(`${label} must be a valid Date`);
+    return Math.floor(millis / 1e3);
+  }
+  if (typeof value === "bigint") {
+    if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`${label} must fit in a JavaScript safe integer`);
+    }
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+      throw new Error(`${label} must be a Unix timestamp in seconds`);
+    }
+    return normalizeExpiresAt(BigInt(trimmed), label);
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a finite positive Unix timestamp`);
+  }
+  return Math.floor(value);
+}
+function resolveSessionExpirySeconds(options) {
+  const hasDuration = options.durationSeconds !== void 0;
+  const hasExpiresAt = options.expiresAt !== void 0;
+  if (hasDuration === hasExpiresAt) {
+    throw new Error("Provide exactly one of durationSeconds or expiresAt");
+  }
+  if (hasDuration) {
+    const duration = options.durationSeconds;
+    if (typeof duration !== "number" || !Number.isFinite(duration) || duration <= 0) {
+      throw new Error("durationSeconds must be a positive number");
+    }
+    return nowSeconds() + Math.floor(duration);
+  }
+  return normalizeExpiresAt(options.expiresAt, "expiresAt");
+}
+function assertSigningSessionWalletAccountIdx(walletAccountIdx) {
+  if (!Number.isInteger(walletAccountIdx) || walletAccountIdx < 2 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be an account index between 2 and 65535");
+  }
+}
+function normalizeDescriptor(descriptor) {
+  return {
+    id: descriptor.id,
+    walletAddress: descriptor.walletAddress,
+    publicKey: descriptor.publicKey,
+    authIdx: Number(descriptor.authIdx),
+    expiresAt: normalizeExpiresAt(descriptor.expiresAt, "descriptor.expiresAt"),
+    createdAt: normalizeExpiresAt(descriptor.createdAt, "descriptor.createdAt")
+  };
+}
+function isActive(descriptor) {
+  return nowSeconds() < descriptor.expiresAt;
+}
+var SigningSessionDescriptorStore = class {
+  constructor(storage, key) {
+    this.storage = storage;
+    this.key = key;
+  }
+  async list() {
+    const sessions = await this.read();
+    const active = sessions.filter(isActive);
+    if (active.length !== sessions.length) {
+      await this.write(active);
+    }
+    return active;
+  }
+  async get(id) {
+    const sessions = await this.list();
+    return sessions.find((session) => session.id === id) ?? null;
+  }
+  async save(descriptor) {
+    const normalized = normalizeDescriptor(descriptor);
+    const sessions = (await this.list()).filter((session) => session.id !== normalized.id);
+    sessions.push(normalized);
+    await this.write(sessions);
+  }
+  async saveReplacingWalletSessions(descriptor) {
+    const normalized = normalizeDescriptor(descriptor);
+    const sessions = (await this.list()).filter(
+      (session) => session.id === normalized.id || session.walletAddress !== normalized.walletAddress
+    );
+    const withoutCurrent = sessions.filter((session) => session.id !== normalized.id);
+    withoutCurrent.push(normalized);
+    await this.write(withoutCurrent);
+  }
+  async remove(id) {
+    const sessions = (await this.list()).filter((session) => session.id !== id);
+    if (sessions.length === 0) {
+      await this.storage.removeItem(this.key);
+      return;
+    }
+    await this.write(sessions);
+  }
+  async read() {
+    const raw = await this.storage.getItem(this.key);
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== STORAGE_VERSION || !Array.isArray(parsed.sessions)) {
+        await this.storage.removeItem(this.key);
+        return [];
+      }
+      return parsed.sessions.map(normalizeDescriptor);
+    } catch {
+      await this.storage.removeItem(this.key);
+      return [];
+    }
+  }
+  async write(sessions) {
+    const payload = {
+      version: STORAGE_VERSION,
+      sessions: sessions.map(normalizeDescriptor)
+    };
+    await this.storage.setItem(this.key, JSON.stringify(payload));
+  }
+};
+
+// src/native/provider/chains/ThruChain.ts
+function descriptorFromWire(session) {
+  return {
+    id: session.id,
+    walletAddress: session.walletAddress,
+    publicKey: session.publicKey,
+    authIdx: session.authIdx,
+    expiresAt: Number(BigInt(session.expiresAt)),
+    createdAt: Number(BigInt(session.createdAt))
+  };
+}
+var NativeThruChain = class {
+  constructor(bridge, provider, origin, signingSessions) {
+    this.bridge = bridge;
+    this.provider = provider;
+    this.origin = origin;
+    this.signingSessions = signingSessions;
+  }
+  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() && !this.provider.isTransparent()) {
+      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) {
+    const signingSessionId = transaction.signingSessionId;
+    if (!signingSessionId && !this.provider.isConnected() && !this.provider.isTransparent()) {
+      throw new Error("Wallet not connected");
+    }
+    const session = signingSessionId ? await this.requireSigningSession(signingSessionId) : null;
+    const shouldShowWallet = !signingSessionId;
+    if (shouldShowWallet) {
+      await this.provider.requestShow();
+    }
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
+        payload: {
+          walletAddress: transaction.walletAddress ?? session?.walletAddress,
+          programAddress: transaction.programAddress,
+          instructionData: transaction.instructionData,
+          readWriteAddresses: transaction.readWriteAddresses,
+          readOnlyAddresses: transaction.readOnlyAddresses,
+          review: transaction.review,
+          signingSessionId
+        },
+        origin: this.origin
+      });
+      return response.result.signedTransaction;
+    } finally {
+      if (shouldShowWallet) {
+        this.provider.requestHide();
+      }
+    }
+  }
+  async signPasskeyChallenge(challenge) {
+    if (!this.provider.isConnected() && !this.provider.isTransparent()) {
+      throw new Error("Wallet not connected");
+    }
+    await this.provider.requestShow();
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE,
+        payload: {
+          challenge: challenge.challenge,
+          walletAddress: challenge.walletAddress
+        },
+        origin: this.origin
+      });
+      return response.result;
+    } finally {
+      this.provider.requestHide();
+    }
+  }
+  async createSigningSession(options) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+    const expiresAt = resolveSessionExpirySeconds(options);
+    await this.provider.requestShow();
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION,
+        payload: {
+          walletAddress: options.walletAddress,
+          expiresAt: String(expiresAt),
+          review: options.review
+        },
+        origin: this.origin
+      });
+      const descriptor = descriptorFromWire(response.result.session);
+      await this.signingSessions.saveReplacingWalletSessions(descriptor);
+      return this.toSigningSession(descriptor);
+    } finally {
+      this.provider.requestHide();
+    }
+  }
+  async createSigningSessionInstruction(options) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+    const expiresAt = resolveSessionExpirySeconds(options);
+    assertSigningSessionWalletAccountIdx(options.walletAccountIdx);
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION,
+      payload: {
+        walletAddress: options.walletAddress,
+        expiresAt: String(expiresAt),
+        walletAccountIdx: options.walletAccountIdx
+      },
+      origin: this.origin
+    });
+    const descriptor = descriptorFromWire(response.result.session);
+    return {
+      session: this.toSigningSession(descriptor),
+      programAddress: response.result.programAddress,
+      instructionData: base64ToBytes(response.result.instructionData)
+    };
+  }
+  async confirmSigningSession(id) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION,
+      payload: { sessionId: id },
+      origin: this.origin
+    });
+    const descriptor = descriptorFromWire(response.result.session);
+    await this.signingSessions.saveReplacingWalletSessions(descriptor);
+    return this.toSigningSession(descriptor);
+  }
+  async getSigningSession(id) {
+    if (!this.signingSessions) return null;
+    const descriptor = await this.signingSessions.get(id);
+    return descriptor ? this.toSigningSession(descriptor) : null;
+  }
+  async getSigningSessions() {
+    if (!this.signingSessions) return [];
+    return (await this.signingSessions.list()).map(
+      (descriptor) => this.toSigningSession(descriptor)
+    );
+  }
+  async revokeSigningSession(id) {
+    try {
+      await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.REVOKE_SIGNING_SESSION,
+        payload: { sessionId: id },
+        origin: this.origin
+      });
+    } finally {
+      await this.signingSessions?.remove(id);
+    }
+  }
+  async requireSigningSession(id) {
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+    const session = await this.signingSessions.get(id);
+    if (!session) {
+      throw new Error("Signing session is not known to this app");
+    }
+    return session;
+  }
+  toSigningSession(descriptor) {
+    return {
+      ...descriptor,
+      signTransaction: (transaction) => this.signTransaction({
+        ...transaction,
+        walletAddress: transaction.walletAddress ?? descriptor.walletAddress,
+        signingSessionId: descriptor.id
+      }),
+      revoke: () => this.revokeSigningSession(descriptor.id),
+      toJSON: () => ({ ...descriptor })
+    };
+  }
+};
+
+// src/native/provider/WebViewBridge.ts
+var PRODUCTION_WALLET_ORIGINS = [
+  "https://wallet.thru.org",
+  "https://wallet.tid.sh"
+];
+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.`
+    );
+  }
+}
+function isNativeEmbeddedWalletPath(pathname) {
+  const normalized = pathname.replace(/\/+$/, "") || "/";
+  return normalized === "/embedded/native" || normalized.startsWith("/embedded/native/");
+}
+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.CREATE_ACCOUNT,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE,
+  POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS,
+  POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION,
+  POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION,
+  POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION
+]);
+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 (!isNativeEmbeddedWalletPath(url.pathname)) {
+      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, frameId: this.frameId })};
+        if (window.__pushIn) {
+          window.__pushIn(msg);
+        } else {
+          window.postMessage(msg, window.location.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 TRANSPARENT_FOCUS_SETTLE_MS = 500;
+var NativeProvider = class {
+  constructor(config = {}) {
+    this.connected = false;
+    this.accounts = [];
+    this.selectedAccount = null;
+    this.isSurfaceShown = false;
+    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.transparent = config.walletExperience === "transparent";
+    this.bridge = new WebViewBridge({ walletUrl });
+    this.bridge.onEvent = (eventType, payload) => {
+      if (this.transparent && eventType === EMBEDDED_PROVIDER_EVENTS.UI_SHOW) {
+        return;
+      }
+      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,
+        config.signingSessions
+      );
+    }
+  }
+  /** 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 or focus the wallet host surface. Transparent hosts use this
+      to give WKWebView a focused document for WebAuthn without showing
+      wallet UI. */
+  async requestShow() {
+    if (this.transparent) {
+      if (!this.isSurfaceShown) {
+        this.isSurfaceShown = true;
+        this.onShowRequested?.();
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, TRANSPARENT_FOCUS_SETTLE_MS)
+      );
+      return;
+    }
+    if (this.isSurfaceShown) return;
+    this.isSurfaceShown = true;
+    this.onShowRequested?.();
+  }
+  /** Close the wallet UI (called internally; also exposed for host). */
+  requestHide() {
+    this.isSurfaceShown = false;
+    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 {
+      await 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);
+      if (!result.selectedAccount) {
+        throw new Error("Wallet did not return an account");
+      }
+      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 createAccount(options) {
+    try {
+      await this.requestShow();
+      const payload = {};
+      if (options?.accountName) payload.accountName = options.accountName;
+      if (options?.metadata) payload.metadata = options.metadata;
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT,
+        payload,
+        origin: this.origin
+      });
+      const normalized = normalizeWalletAccountResult(
+        response.result,
+        response.result.selectedAccount ?? response.result.account
+      );
+      const selectedAccount = normalized.selectedAccount ?? response.result.account;
+      if (!selectedAccount) {
+        throw new Error("Wallet did not return a created account");
+      }
+      const result = {
+        ...response.result,
+        accounts: normalized.accounts,
+        selectedAccount,
+        account: selectedAccount
+      };
+      this.connected = true;
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT, {
+        accounts: result.accounts,
+        selectedAccount: result.selectedAccount,
+        status: "completed",
+        metadata: options?.metadata
+      });
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED, {
+        account: result.selectedAccount
+      });
+      this.requestHide();
+      return result;
+    } catch (error) {
+      this.requestHide();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.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;
+  }
+  isTransparent() {
+    return this.transparent;
+  }
+  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 {
+      await 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 SIGNING_SESSION_STORAGE_KEY_SUFFIX = ".signing-sessions.v1";
+var DEFAULT_NATIVE_WALLET_URL = "https://wallet.thru.org/embedded/native";
+var DEFAULT_TRANSPARENT_WALLET_URL = "https://wallet.thru.org/embedded/native/transparent";
+var CHECKING_WALLET_AVAILABILITY = {
+  status: "checking",
+  isAuthorized: false,
+  isConnected: false,
+  isUnlocked: false,
+  hasPasskey: false,
+  hasWalletAccount: false,
+  accounts: [],
+  selectedAccount: null,
+  metadata: null,
+  error: null
+};
+function completeAppMetadata(metadata) {
+  if (!metadata?.appId || !metadata.appName || !metadata.appUrl) {
+    return void 0;
+  }
+  return {
+    appId: metadata.appId,
+    appName: metadata.appName,
+    appUrl: metadata.appUrl,
+    ...metadata.imageUrl ? { imageUrl: metadata.imageUrl } : {}
+  };
+}
+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.walletExperience = config.walletExperience ?? "standard";
+    this.defaultMetadata = config.metadata;
+    const walletUrl = config.walletUrl ?? (this.walletExperience === "transparent" ? DEFAULT_TRANSPARENT_WALLET_URL : DEFAULT_NATIVE_WALLET_URL);
+    const walletOrigin = new URL(walletUrl).origin;
+    const signingSessions = this.storage ? new SigningSessionDescriptorStore(
+      this.storage,
+      resolveSigningSessionStorageKey({
+        walletOrigin,
+        appOrigin: this.origin,
+        storageKey: config.signingSessionStorageKey ?? `${this.storageKey}${SIGNING_SESSION_STORAGE_KEY_SUFFIX}`
+      })
+    ) : void 0;
+    this.provider = new NativeProvider({
+      walletUrl,
+      origin: this.origin,
+      metadata: this.defaultMetadata ? this.resolveMetadata(this.defaultMetadata) : void 0,
+      addressTypes: config.addressTypes ?? [AddressType.THRU],
+      signingSessions,
+      walletExperience: this.walletExperience
+    });
+    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 {
+        await this.provider.requestShow();
+        if (!this.initialized) await this.initialize();
+        const metadata = this.resolveMetadata(options?.metadata);
+        const preferredAccountAddress = isAccountSwitch ? null : options?.preferredAccountAddress ?? 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 createAccount(options = {}) {
+    this.emit("connect", { status: "connecting" });
+    try {
+      await this.provider.requestShow();
+      if (!this.initialized) await this.initialize();
+      const metadata = this.resolveMetadata(options.metadata);
+      const result = await this.provider.createAccount({
+        ...options.accountName ? { accountName: options.accountName } : {},
+        ...metadata ? { metadata } : {}
+      });
+      const selectedAccount = result.selectedAccount ?? result.account;
+      const activeResult = {
+        ...result,
+        accounts: this.provider.getAccounts(),
+        selectedAccount,
+        account: selectedAccount
+      };
+      const completedResult = {
+        accounts: activeResult.accounts,
+        selectedAccount: activeResult.selectedAccount,
+        status: "completed",
+        metadata: completeAppMetadata(metadata)
+      };
+      this.lastConnectResult = completedResult;
+      await this.persistSelectedAccountAddress(
+        activeResult.selectedAccount.address
+      );
+      await this.clearPersistedConnection();
+      this.setWalletAvailability(
+        walletAvailabilityFromConnectResult(completedResult)
+      );
+      this.emit("connect", completedResult);
+      this.emit("accountChanged", activeResult.selectedAccount);
+      return activeResult;
+    } catch (error) {
+      this.provider.requestHide();
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.provider.disconnect();
+      this.emit("disconnect", {});
+      this.lastConnectResult = null;
+      await this.persistSelectedAccountAddress(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 ?? this.defaultMetadata ?? void 0;
+    const providerOptions = metadata ? { metadata: this.resolveMetadata(metadata) } : void 0;
+    const preferredAccountAddress = options?.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) {
+    const effectiveInput = input ?? this.defaultMetadata;
+    if (!effectiveInput) {
+      return { appId: this.origin };
+    }
+    const metadata = {
+      appId: effectiveInput.appId ?? this.origin
+    };
+    if (effectiveInput.appUrl) metadata.appUrl = effectiveInput.appUrl;
+    if (effectiveInput.appName) metadata.appName = effectiveInput.appName;
+    if (effectiveInput.imageUrl) metadata.imageUrl = effectiveInput.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]);
+  const createAccount = useCallback(
+    async (options) => {
+      if (!sdk) throw new Error("NativeSDK not initialized");
+      try {
+        const result = await sdk.createAccount(options);
+        setSelectedAccount(result.selectedAccount);
+        setAccounts(result.accounts);
+        setIsConnected(true);
+        setIsConnecting(false);
+        setWalletAvailability(sdk.getWalletAvailability());
+        return result;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("createAccount failed")
+        );
+        setIsConnecting(false);
+        throw err;
+      }
+    },
+    [sdk]
+  );
+  return /* @__PURE__ */ jsx(
+    ThruContext.Provider,
+    {
+      value: {
+        thru,
+        wallet: sdk,
+        isConnected,
+        accounts,
+        isConnecting,
+        error,
+        selectedAccount,
+        walletAvailability,
+        selectAccount,
+        createAccount,
+        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
+  );
+}
+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;
+  }
+}
+function ThruTransparentWalletBridge({
+  wallet: walletProp,
+  style,
+  webViewProps
+}) {
+  const thruContext = useContext(ThruContext);
+  const wallet = walletProp ?? thruContext?.wallet ?? null;
+  const webViewRef = useRef(null);
+  const webViewNativeTagRef = useRef(null);
+  const didRefreshWalletAvailabilityRef = useRef(false);
+  const [isFocusSurfaceActive, setIsFocusSurfaceActive] = useState(false);
+  const attachIfReady = useCallback(() => {
+    if (!wallet || !webViewRef.current) return;
+    const ref = {
+      injectJavaScript: (script) => {
+        webViewRef.current?.injectJavaScript(script);
+      }
+    };
+    wallet.attachWebView(ref);
+  }, [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 focusWebViewDocument = useCallback(() => {
+    const webView = webViewRef.current;
+    webView?.requestFocus?.();
+    webViewRef.current?.injectJavaScript(
+      "try { window.focus(); document.body && document.body.focus && document.body.focus(); } catch (_) {} true;"
+    );
+  }, []);
+  const refreshWalletAvailabilityIfReady = useCallback(() => {
+    if (!wallet || didRefreshWalletAvailabilityRef.current) return;
+    didRefreshWalletAvailabilityRef.current = true;
+    void wallet.refreshWalletAvailability();
+  }, [wallet]);
+  useEffect(() => {
+    if (!wallet) return;
+    wallet.setUiHandlers({
+      onShowRequested: () => {
+        setIsFocusSurfaceActive(true);
+      },
+      onHideRequested: () => {
+        setIsFocusSurfaceActive(false);
+      }
+    });
+    return () => {
+      wallet.clearUiHandlers();
+    };
+  }, [focusWebViewDocument, wallet]);
+  useEffect(() => {
+    if (!isFocusSurfaceActive) return;
+    const timers = [0, 50, 120, 250, 500].map(
+      (delay) => setTimeout(focusWebViewDocument, delay)
+    );
+    return () => {
+      timers.forEach(clearTimeout);
+    };
+  }, [focusWebViewDocument, isFocusSurfaceActive]);
+  const webViewSource = useMemo(() => {
+    if (!wallet) return null;
+    if (Platform.OS === "ios" && wallet.getIosWebViewMode() === "direct") {
+      return { uri: wallet.getIframeSrc() };
+    }
+    return {
+      html: getShellHtml({
+        walletUrl: wallet.getIframeSrc(),
+        walletOrigin: wallet.getWalletOrigin()
+      }),
+      baseUrl: wallet.getWalletOrigin()
+    };
+  }, [wallet]);
+  const isDirectWalletSource = Boolean(
+    wallet && Platform.OS === "ios" && wallet.getIosWebViewMode() === "direct"
+  );
+  useEffect(() => {
+    didRefreshWalletAvailabilityRef.current = false;
+  }, [webViewSource]);
+  const handleWebViewLayout = useCallback(
+    (event) => {
+      const target = event.nativeEvent.target;
+      webViewNativeTagRef.current = typeof target === "number" ? target : webViewNativeTagRef.current;
+      void enableAndroidWebAuthnIfNeeded();
+      webViewProps?.onLayout?.(event);
+    },
+    [enableAndroidWebAuthnIfNeeded, webViewProps]
+  );
+  const handleLoadEnd = useCallback(
+    (event) => {
+      attachIfReady();
+      if (isDirectWalletSource) {
+        void enableAndroidWebAuthnIfNeeded().finally(
+          refreshWalletAvailabilityIfReady
+        );
+      } else {
+        void enableAndroidWebAuthnIfNeeded();
+      }
+      webViewProps?.onLoadEnd?.(event);
+    },
+    [
+      attachIfReady,
+      enableAndroidWebAuthnIfNeeded,
+      isDirectWalletSource,
+      refreshWalletAvailabilityIfReady,
+      webViewProps
+    ]
+  );
+  const handleMessage = useCallback(
+    (event) => {
+      let shouldRefreshAfterBridgeReady = false;
+      let shouldCollapseFocusSurface = false;
+      try {
+        const data = JSON.parse(event.nativeEvent.data);
+        shouldRefreshAfterBridgeReady = data.type === "iframe:ready";
+        shouldCollapseFocusSurface = typeof data.id === "string" && typeof data.success === "boolean";
+      } catch {
+      }
+      if (shouldCollapseFocusSurface) {
+        setIsFocusSurfaceActive(false);
+      }
+      wallet?.onMessage({
+        nativeEvent: { data: event.nativeEvent.data }
+      });
+      webViewProps?.onMessage?.(event);
+      if (shouldRefreshAfterBridgeReady) {
+        void enableAndroidWebAuthnIfNeeded().finally(
+          refreshWalletAvailabilityIfReady
+        );
+      }
+    },
+    [
+      enableAndroidWebAuthnIfNeeded,
+      refreshWalletAvailabilityIfReady,
+      wallet,
+      webViewProps
+    ]
+  );
+  if (!webViewSource) return null;
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      collapsable: false,
+      pointerEvents: isFocusSurfaceActive ? "auto" : "none",
+      style: [
+        styles.container,
+        isFocusSurfaceActive ? styles.activeContainer : null,
+        style
+      ],
+      children: /* @__PURE__ */ jsx(
+        WebView,
+        {
+          ...webViewProps,
+          ref: webViewRef,
+          source: webViewSource,
+          originWhitelist: ["*"],
+          javaScriptEnabled: true,
+          domStorageEnabled: true,
+          webviewDebuggingEnabled: __DEV__,
+          sharedCookiesEnabled: true,
+          allowsInlineMediaPlayback: true,
+          mediaPlaybackRequiresUserAction: false,
+          limitsNavigationsToAppBoundDomains: isDirectWalletSource,
+          onLoadStart: (event) => {
+            attachIfReady();
+            void enableAndroidWebAuthnIfNeeded();
+            webViewProps?.onLoadStart?.(event);
+          },
+          onLoadEnd: handleLoadEnd,
+          onLayout: handleWebViewLayout,
+          onMessage: handleMessage,
+          style: [
+            styles.webview,
+            isFocusSurfaceActive ? styles.activeWebview : null,
+            webViewProps?.style
+          ]
+        }
+      )
+    }
+  );
+}
+var styles = StyleSheet.create({
+  container: {
+    height: 1,
+    left: 0,
+    opacity: 0,
+    overflow: "hidden",
+    position: "absolute",
+    top: 0,
+    width: 1
+  },
+  activeContainer: {
+    bottom: 0,
+    height: "100%",
+    opacity: 1,
+    right: 0,
+    width: "100%",
+    zIndex: 2147483647
+  },
+  webview: {
+    backgroundColor: "transparent",
+    height: 1,
+    width: 1
+  },
+  activeWebview: {
+    flex: 1,
+    height: "100%",
+    width: "100%"
+  }
+});
+function useThru() {
+  const ctx = useContext(ThruContext);
+  if (!ctx) {
+    throw new Error("useThru must be used inside <ThruProvider>");
+  }
+  return ctx;
+}
+
+// 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 createTransparentAccount = useCallback(
+    async (options) => {
+      const ready = walletRef.current ?? await waitForWallet(() => walletRef.current);
+      return ready.createAccount(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,
+    createAccount: createTransparentAccount,
+    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, ThruTransparentWalletBridge, enableWebAuthnSupport, useAccounts, useThru, useWallet, useWalletAvailability };
+//# sourceMappingURL=transparent.js.map
+//# sourceMappingURL=transparent.js.map