@thru/wallet 0.2.22

package/dist/native.js

@@ -0,0 +1,1126 @@
+import { createThruClient } from '@thru/sdk/client';
+
+// 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"
+};
+var ThruTransactionEncoding = {
+  SIGNING_PAYLOAD_BASE64: "signing_payload_base64",
+  RAW_TRANSACTION_BASE64: "raw_transaction_base64"
+};
+
+// 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",
+  WALLET_LOCKED: "WALLET_LOCKED",
+  INVALID_PASSWORD: "INVALID_PASSWORD",
+  ALREADY_CONNECTED: "ALREADY_CONNECTED",
+  ACCOUNT_NOT_FOUND: "ACCOUNT_NOT_FOUND",
+  ACCOUNT_CHANGED: "ACCOUNT_CHANGED",
+  INVALID_TRANSACTION: "INVALID_TRANSACTION",
+  TRANSACTION_FAILED: "TRANSACTION_FAILED",
+  INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+
+// 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;
+}
+
+export { AddressType, EMBEDDED_PROVIDER_EVENTS, ErrorCode, NativeSDK, POST_MESSAGE_REQUEST_TYPES, ThruTransactionEncoding };
+//# sourceMappingURL=native.js.map
+//# sourceMappingURL=native.js.map