@thru/wallet 0.2.22

package/dist/react.js

@@ -0,0 +1,1151 @@
+"use client";
+import { createThruClient } from '@thru/sdk/client';
+import { createContext, useState, useEffect, useCallback, useContext, useMemo, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/interfaces/accounts.ts
+function resolveSelectedWalletAccount(accounts, selectedAccount) {
+  if (selectedAccount) {
+    return accounts.find((account) => account.address === selectedAccount.address) ?? selectedAccount;
+  }
+  return accounts[0] ?? 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,
+    result.selectedAccount ?? null
+  );
+  return {
+    ...result,
+    accounts: active.accounts,
+    selectedAccount: active.selectedAccount
+  };
+}
+
+// src/interfaces/types.ts
+var AddressType = {
+  THRU: "thru"
+};
+
+// src/protocol/postMessage.ts
+var POST_MESSAGE_REQUEST_TYPES = {
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  SIGN_MESSAGE: "signMessage",
+  SIGN_TRANSACTION: "signTransaction",
+  GET_ACCOUNTS: "getAccounts",
+  GET_CONNECTION_STATE: "getConnectionState",
+  GET_SIGNING_CONTEXT: "getSigningContext",
+  SELECT_ACCOUNT: "selectAccount",
+  MANAGE_ACCOUNTS: "manageAccounts"
+};
+var EMBEDDED_PROVIDER_EVENTS = {
+  CONNECT_START: "connect_start",
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  CONNECT_ERROR: "connect_error",
+  ERROR: "error",
+  LOCK: "lock",
+  UI_SHOW: "ui_show",
+  ACCOUNT_CHANGED: "account_changed"
+};
+var POST_MESSAGE_EVENT_TYPE = "event";
+var IFRAME_READY_EVENT = "iframe:ready";
+var DEFAULT_IFRAME_URL = "http://localhost:3000/embedded";
+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/provider/IframeManager.ts
+var PRODUCTION_IFRAME_ORIGINS = ["https://wallet.thru.org"];
+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
+]);
+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 isDevelopmentHostname(hostname) {
+  return hostname === "localhost" || hostname === "::1" || !hostname.includes(".") || hostname.endsWith(".local") || hostname.endsWith(".ts.net") || isPrivateIpv4Host(hostname);
+}
+function isAllowedDevelopmentOrigin(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  if (typeof window === "undefined") return false;
+  const appHostname = window.location.hostname.toLowerCase();
+  if (!isDevelopmentHostname(appHostname)) return false;
+  return isDevelopmentHostname(url.hostname.toLowerCase());
+}
+function validateIframeOrigin(iframeUrl) {
+  let url;
+  try {
+    url = new URL(iframeUrl);
+  } catch (error) {
+    throw new Error(
+      `Invalid iframe URL: ${iframeUrl}. URL must be a valid absolute URL.`
+    );
+  }
+  const origin = url.origin;
+  const isAllowed = PRODUCTION_IFRAME_ORIGINS.includes(origin) || isAllowedDevelopmentOrigin(url);
+  if (!isAllowed) {
+    throw new Error(
+      `Untrusted iframe origin: ${origin}. Only trusted wallet origins are allowed: ${PRODUCTION_IFRAME_ORIGINS.join(", ")}. Development builds also allow localhost, LAN, and Tailscale wallet origins. This security check prevents malicious websites from loading unauthorized wallet iframes.`
+    );
+  }
+}
+var IframeManager = class {
+  constructor(iframeUrl) {
+    this.iframe = null;
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.messageListener = null;
+    this.readyPromise = null;
+    this.displayMode = "modal";
+    this.inlineContainer = null;
+    this.visible = false;
+    validateIframeOrigin(iframeUrl);
+    this.iframeUrl = iframeUrl;
+    this.iframeOrigin = new URL(iframeUrl).origin;
+    this.frameId = createRequestId("frame");
+  }
+  getIframeSrc() {
+    const url = new URL(this.iframeUrl);
+    url.searchParams.set("tn_frame_id", this.frameId);
+    return url.toString();
+  }
+  /**
+   * Create and inject iframe into DOM
+   * Returns a promise that resolves when iframe is ready
+   */
+  async createIframe() {
+    if (this.readyPromise) {
+      return this.readyPromise;
+    }
+    this.readyPromise = (async () => {
+      if (!this.iframe) {
+        this.iframe = document.createElement("iframe");
+        this.iframe.src = this.getIframeSrc();
+        this.iframe.allow = "publickey-credentials-get; publickey-credentials-create";
+        this.applyIframeStyles();
+        this.setVisibility(false);
+        if (this.displayMode === "inline" && this.inlineContainer) {
+          this.inlineContainer.appendChild(this.iframe);
+        } else {
+          document.body.appendChild(this.iframe);
+        }
+        this.messageListener = this.handleMessage.bind(this);
+        window.addEventListener("message", this.messageListener);
+      }
+      await this.waitForReady();
+    })().catch((error) => {
+      this.readyPromise = null;
+      throw error;
+    });
+    return this.readyPromise;
+  }
+  /**
+   * Wait for iframe to send 'ready' signal
+   */
+  waitForReady() {
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      let readyHandler;
+      const cleanup = () => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        window.removeEventListener("message", readyHandler);
+        clearTimeout(timeout);
+      };
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Iframe ready timeout - wallet failed to load"));
+      }, 1e4);
+      readyHandler = (event) => {
+        if (!this.isMessageFromIframe(event)) {
+          return;
+        }
+        if (event.data?.type === IFRAME_READY_EVENT) {
+          cleanup();
+          resolve();
+        }
+      };
+      window.addEventListener("message", readyHandler);
+    });
+  }
+  /**
+   * Mount iframe inline inside the provided container.
+   */
+  async mountInline(container) {
+    this.inlineContainer = container;
+    this.displayMode = "inline";
+    await this.createIframe();
+    this.showInline();
+  }
+  /**
+   * Show iframe inline (embedded in container).
+   */
+  showInline() {
+    if (!this.iframe) {
+      return;
+    }
+    this.displayMode = "inline";
+    if (this.inlineContainer && this.iframe.parentElement !== this.inlineContainer) {
+      this.inlineContainer.appendChild(this.iframe);
+    }
+    this.applyIframeStyles();
+    this.setVisibility(true);
+  }
+  /**
+   * Show iframe as a full-screen modal.
+   */
+  showModal() {
+    if (!this.iframe) {
+      return;
+    }
+    this.displayMode = "modal";
+    if (this.iframe.parentElement !== document.body) {
+      document.body.appendChild(this.iframe);
+    }
+    this.applyIframeStyles();
+    this.setVisibility(true);
+  }
+  /**
+   * Show iframe modal
+   */
+  show() {
+    this.showModal();
+  }
+  /**
+   * Hide iframe modal
+   */
+  hide() {
+    this.setVisibility(false);
+  }
+  isInline() {
+    return this.displayMode === "inline";
+  }
+  applyIframeStyles() {
+    if (!this.iframe) {
+      return;
+    }
+    if (this.displayMode === "inline") {
+      this.iframe.style.cssText = `
+        position: relative;
+        width: 100%;
+        height: 100%;
+        border: none;
+        z-index: 1;
+        display: block;
+        background: transparent;
+      `;
+      return;
+    }
+    this.iframe.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      border: none;
+      z-index: 999999;
+      display: block;
+      background: rgba(0, 0, 0, 0.5);
+    `;
+  }
+  setVisibility(visible) {
+    if (!this.iframe) {
+      return;
+    }
+    this.visible = visible;
+    this.iframe.style.opacity = visible ? "1" : "0";
+    this.iframe.style.pointerEvents = visible ? "auto" : "none";
+    this.iframe.style.visibility = visible ? "visible" : "hidden";
+  }
+  /**
+   * Send message to iframe and wait for response
+   */
+  async sendMessage(request) {
+    if (this.readyPromise) {
+      await this.readyPromise;
+    } else {
+      await this.createIframe();
+    }
+    if (!this.iframe?.contentWindow) {
+      throw new Error("Iframe not initialized - call createIframe() first");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutMs = SLOW_REQUEST_TYPES.has(request.type) ? SLOW_REQUEST_TIMEOUT_MS : FAST_REQUEST_TIMEOUT_MS;
+      const timeout = setTimeout(() => {
+        this.messageHandlers.delete(request.id);
+        reject(new Error("Request timeout - wallet did not respond"));
+      }, timeoutMs);
+      this.messageHandlers.set(request.id, (response) => {
+        clearTimeout(timeout);
+        this.messageHandlers.delete(request.id);
+        if (response.success) {
+          resolve(response);
+        } else {
+          const error = new Error(response.error?.message || "Unknown error");
+          error.code = response.error?.code;
+          error.data = response.error?.data;
+          reject(error);
+        }
+      });
+      this.iframe.contentWindow.postMessage(request, this.iframeOrigin);
+    });
+  }
+  /**
+   * Handle incoming messages from iframe
+   */
+  handleMessage(event) {
+    if (!this.isMessageFromIframe(event)) {
+      return;
+    }
+    const data = event.data;
+    if (data.id && this.messageHandlers.has(data.id)) {
+      const handler = this.messageHandlers.get(data.id);
+      if (handler) {
+        handler(data);
+      }
+      return;
+    }
+    if (data.type === POST_MESSAGE_EVENT_TYPE) {
+      this.handleEvent(data);
+    }
+  }
+  /**
+   * Handle event broadcasts from iframe
+   */
+  handleEvent(data) {
+    if (this.onEvent) {
+      this.onEvent(data.event, data.data);
+    }
+  }
+  isMessageFromIframe(event) {
+    if (event.origin !== this.iframeOrigin) {
+      return false;
+    }
+    const data = event.data;
+    if (!data || data.frameId !== this.frameId) {
+      return false;
+    }
+    if (!event.source) {
+      return true;
+    }
+    if (this.iframe?.contentWindow && event.source !== this.iframe.contentWindow) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Destroy iframe and cleanup
+   */
+  destroy() {
+    if (this.iframe) {
+      this.iframe.remove();
+      this.iframe = null;
+    }
+    this.readyPromise = null;
+    if (this.messageListener) {
+      window.removeEventListener("message", this.messageListener);
+      this.messageListener = null;
+    }
+    this.messageHandlers.clear();
+  }
+};
+
+// src/provider/chains/ThruChain.ts
+var EmbeddedThruChain = class {
+  constructor(iframeManager, provider) {
+    this.iframeManager = iframeManager;
+    this.provider = provider;
+  }
+  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.iframeManager.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.GET_SIGNING_CONTEXT,
+      origin: window.location.origin
+    });
+    return response.result.signingContext;
+  }
+  async signTransaction(transaction) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    this.iframeManager.show();
+    try {
+      const response = await this.iframeManager.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: window.location.origin
+      });
+      return response.result.signedTransaction;
+    } finally {
+      this.iframeManager.hide();
+    }
+  }
+};
+
+// src/provider/EmbeddedProvider.ts
+var EmbeddedProvider = class {
+  constructor(config) {
+    this.connected = false;
+    this.accounts = [];
+    this.selectedAccount = null;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.inlineMode = false;
+    const iframeUrl = config.iframeUrl || DEFAULT_IFRAME_URL;
+    this.iframeManager = new IframeManager(iframeUrl);
+    this.iframeManager.onEvent = (eventType, payload) => {
+      this.emit(eventType, payload);
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.UI_SHOW) {
+        if (this.inlineMode) {
+          this.iframeManager.showInline();
+        } else {
+          this.iframeManager.showModal();
+        }
+        return;
+      }
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.DISCONNECT || eventType === EMBEDDED_PROVIDER_EVENTS.LOCK) {
+        this.clearConnection();
+        return;
+      }
+      if (eventType === EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED) {
+        const account = payload && payload.account || null;
+        this.refreshAccountCache(account ?? null);
+      }
+    };
+    const addressTypes = config.addressTypes || [AddressType.THRU];
+    if (addressTypes.includes(AddressType.THRU)) {
+      this._thruChain = new EmbeddedThruChain(this.iframeManager, this);
+    }
+  }
+  /**
+   * Initialize the provider (must be called before use)
+   * Creates iframe and waits for it to be ready
+   */
+  async initialize() {
+    await this.iframeManager.createIframe();
+  }
+  /**
+   * Mount the wallet iframe inline in a container (for inline connect button).
+   */
+  async mountInline(container) {
+    this.inlineMode = true;
+    await this.iframeManager.mountInline(container);
+  }
+  /**
+   * Connect to wallet
+   * Shows iframe modal and requests connection
+   */
+  async connect(options) {
+    this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT_START, {});
+    try {
+      if (this.inlineMode) {
+        this.iframeManager.showInline();
+      } else {
+        this.iframeManager.showModal();
+      }
+      const payload = {};
+      if (options?.metadata) {
+        payload.metadata = options.metadata;
+      }
+      const response = await this.iframeManager.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CONNECT,
+        payload,
+        origin: window.location.origin
+      });
+      const result = normalizeWalletAccountResult(response.result);
+      this.connected = true;
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT, result);
+      if (!this.inlineMode) {
+        this.iframeManager.hide();
+      }
+      return result;
+    } catch (error) {
+      if (!this.inlineMode) {
+        this.iframeManager.hide();
+      }
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT_ERROR, { error });
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect() {
+    try {
+      await this.iframeManager.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.DISCONNECT,
+        origin: window.location.origin
+      });
+      this.clearConnection();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.DISCONNECT, {});
+    } catch (error) {
+      this.clearConnection();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ERROR, { error });
+      throw error;
+    } finally {
+      if (!this.inlineMode) {
+        this.iframeManager.hide();
+      }
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get accounts
+   */
+  getAccounts() {
+    return this.accounts;
+  }
+  getSelectedAccount() {
+    return this.selectedAccount;
+  }
+  async selectAccount(publicKey) {
+    if (!this.connected) {
+      throw new Error("Wallet not connected");
+    }
+    const knownAccount = this.accounts.find((acc) => acc.address === publicKey) ?? null;
+    if (!knownAccount) {
+      console.warn(
+        "[EmbeddedProvider] Selecting account not present in local cache"
+      );
+    }
+    const payload = { publicKey };
+    const response = await this.iframeManager.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.SELECT_ACCOUNT,
+      payload,
+      origin: window.location.origin
+    });
+    const account = response.result.account;
+    this.refreshAccountCache(account);
+    return account;
+  }
+  async manageAccounts() {
+    if (!this.connected) {
+      throw new Error("Wallet not connected");
+    }
+    if (this.inlineMode) {
+      this.iframeManager.showInline();
+    } else {
+      this.iframeManager.showModal();
+    }
+    try {
+      const response = await this.iframeManager.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS,
+        origin: window.location.origin
+      });
+      const result = normalizeWalletAccountResult({
+        accounts: response.result.accounts,
+        selectedAccount: response.result.selectedAccount
+      });
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+      if (this.selectedAccount) {
+        this.emit(EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED, {
+          account: this.selectedAccount
+        });
+      }
+      return result;
+    } finally {
+      if (!this.inlineMode) {
+        this.iframeManager.hide();
+      }
+    }
+  }
+  /**
+   * Get Thru chain API
+   */
+  get thru() {
+    if (!this._thruChain) {
+      throw new Error("Thru chain not enabled in provider config");
+    }
+    return this._thruChain;
+  }
+  /**
+   * Event emitter: on
+   */
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  /**
+   * Event emitter: off
+   */
+  off(event, callback) {
+    this.eventListeners.get(event)?.delete(callback);
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emit(event, data) {
+    this.eventListeners.get(event)?.forEach((callback) => {
+      try {
+        callback(data);
+      } catch (error) {
+        console.error(`Error in event listener for ${event}:`, error);
+      }
+    });
+  }
+  /**
+   * Get iframe manager (for chain implementations)
+   * @internal
+   */
+  getIframeManager() {
+    return this.iframeManager;
+  }
+  /**
+   * Destroy provider and cleanup
+   */
+  destroy() {
+    this.iframeManager.destroy();
+    this.eventListeners.clear();
+    this.clearConnection();
+  }
+  refreshAccountCache(account) {
+    if (!account) {
+      this.accounts = [];
+      this.selectedAccount = null;
+      return;
+    }
+    this.accounts = [account];
+    this.selectedAccount = account;
+  }
+  clearConnection() {
+    this.connected = false;
+    this.accounts = [];
+    this.selectedAccount = null;
+  }
+};
+var BrowserSDK = class {
+  constructor(config = {}) {
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.initialized = false;
+    this.connectInFlight = null;
+    this.lastConnectResult = null;
+    this.provider = new EmbeddedProvider({
+      iframeUrl: config.iframeUrl,
+      addressTypes: config.addressTypes || [AddressType.THRU]
+    });
+    this.thruClient = createThruClient({
+      baseUrl: config.rpcUrl
+    });
+    this.setupEventForwarding();
+  }
+  /**
+   * Initialize the SDK (creates iframe)
+   * Must be called before using the SDK
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.provider.initialize();
+    this.initialized = true;
+  }
+  /**
+   * Connect to wallet
+   * Shows wallet modal and requests connection
+   */
+  async connect(options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (this.connectInFlight) {
+      return this.connectInFlight;
+    }
+    if (this.lastConnectResult && this.provider.isConnected()) {
+      return this.lastConnectResult;
+    }
+    this.emit("connect", { status: "connecting" });
+    const inFlight = (async () => {
+      try {
+        const metadata = this.resolveMetadata(options?.metadata);
+        const providerOptions = metadata ? { metadata } : void 0;
+        const result = await this.provider.connect(providerOptions);
+        this.lastConnectResult = result;
+        this.emit("connect", result);
+        return result;
+      } catch (error) {
+        this.emit("error", error);
+        throw error;
+      } finally {
+        this.connectInFlight = null;
+      }
+    })();
+    this.connectInFlight = inFlight;
+    return inFlight;
+  }
+  /**
+   * Mount the wallet iframe inline in a container.
+   */
+  async mountInline(container) {
+    await this.provider.mountInline(container);
+  }
+  /**
+   * Disconnect from wallet
+   */
+  async disconnect() {
+    try {
+      await this.provider.disconnect();
+      this.emit("disconnect", {});
+      this.lastConnectResult = null;
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.provider.isConnected();
+  }
+  /**
+   * Get all accounts
+   */
+  getAccounts() {
+    const accounts = this.provider.getAccounts();
+    this.refreshCachedAccounts(accounts);
+    return accounts;
+  }
+  getSelectedAccount() {
+    return this.provider.getSelectedAccount();
+  }
+  async selectAccount(publicKey) {
+    const account = await this.provider.selectAccount(publicKey);
+    this.refreshCachedAccounts(this.provider.getAccounts(), account);
+    return account;
+  }
+  async manageAccounts() {
+    const result = await this.provider.manageAccounts();
+    this.refreshCachedAccounts(result.accounts, result.selectedAccount);
+    this.emit("accountChanged", result.selectedAccount);
+    return result;
+  }
+  /**
+   * Get Thru chain API (iframe-backed signer)
+   */
+  get thru() {
+    return this.provider.thru;
+  }
+  /**
+   * Event emitter: on
+   */
+  on(event, callback) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(callback);
+  }
+  /**
+   * Event emitter: off
+   */
+  off(event, callback) {
+    this.eventListeners.get(event)?.delete(callback);
+  }
+  /**
+   * Event emitter: once (listen once and auto-remove)
+   */
+  once(event, callback) {
+    const wrappedCallback = (...args) => {
+      callback(...args);
+      this.off(event, wrappedCallback);
+    };
+    this.on(event, wrappedCallback);
+  }
+  /**
+   * Emit event to all listeners
+   */
+  emit(event, data) {
+    this.eventListeners.get(event)?.forEach((callback) => {
+      try {
+        callback(data);
+      } catch (error) {
+        console.error(`Error in SDK event listener for ${event}:`, error);
+      }
+    });
+  }
+  /**
+   * Set up event forwarding from provider to SDK
+   */
+  setupEventForwarding() {
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.CONNECT, (data) => {
+    });
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.DISCONNECT, (data) => {
+      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.emit("lock", data);
+      this.emit("disconnect", { reason: "locked" });
+    });
+    this.provider.on(EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED, (data) => {
+      const account = data?.account ?? data;
+      this.refreshCachedAccounts(this.provider.getAccounts(), account ?? null);
+      this.emit("accountChanged", account);
+    });
+  }
+  /**
+   * Destroy SDK and cleanup
+   */
+  destroy() {
+    this.provider.destroy();
+    this.eventListeners.clear();
+    this.initialized = false;
+    this.connectInFlight = null;
+    this.lastConnectResult = null;
+  }
+  resolveMetadata(input) {
+    const defaultOrigin = typeof window !== "undefined" ? window.location.origin : void 0;
+    if (!defaultOrigin && !input) {
+      return void 0;
+    }
+    const appId = input?.appId || defaultOrigin;
+    const appUrl = this.resolveAppUrl(defaultOrigin, input?.appUrl);
+    const appName = input?.appName || this.deriveAppName(appUrl ?? appId);
+    const metadata = {};
+    if (appId) metadata.appId = appId;
+    if (appUrl) metadata.appUrl = appUrl;
+    if (appName) metadata.appName = appName;
+    if (input?.imageUrl) metadata.imageUrl = input.imageUrl;
+    return metadata;
+  }
+  resolveAppUrl(defaultOrigin, providedUrl) {
+    const candidate = providedUrl || defaultOrigin;
+    if (!candidate) {
+      return void 0;
+    }
+    try {
+      const url = new URL(candidate, defaultOrigin);
+      return url.toString();
+    } catch {
+      return defaultOrigin;
+    }
+  }
+  deriveAppName(source) {
+    if (!source) {
+      return void 0;
+    }
+    try {
+      const hostname = new URL(source).hostname;
+      return hostname || source;
+    } catch {
+      return source;
+    }
+  }
+  getThru() {
+    return this.thruClient;
+  }
+  refreshCachedAccounts(accounts, selectedAccount) {
+    const active = normalizeActiveWalletAccounts(accounts, selectedAccount);
+    if (this.lastConnectResult) {
+      this.lastConnectResult = {
+        ...this.lastConnectResult,
+        accounts: active.accounts,
+        selectedAccount: active.selectedAccount
+      };
+    }
+  }
+};
+var defaultContextValue = {
+  wallet: null,
+  isConnected: false,
+  accounts: [],
+  isConnecting: false,
+  error: null,
+  thru: null,
+  selectedAccount: null,
+  selectAccount: async () => void 0,
+  manageAccounts: async () => ({ accounts: [], selectedAccount: null })
+};
+var ThruContext = createContext(defaultContextValue);
+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);
+  useEffect(() => {
+    const sdkInstance = new BrowserSDK(config);
+    setSdk(sdkInstance);
+    setThru(sdkInstance.getThru());
+    const updateAccountsFromSdk = () => {
+      const active = normalizeActiveWalletAccounts(
+        sdkInstance.getAccounts(),
+        sdkInstance.getSelectedAccount()
+      );
+      setAccounts(active.accounts);
+      setSelectedAccount(active.selectedAccount);
+    };
+    const updateSelectedAccount = (account) => {
+      const active = normalizeActiveWalletAccounts(
+        sdkInstance.getAccounts(),
+        account ?? sdkInstance.getSelectedAccount()
+      );
+      setAccounts(active.accounts);
+      setSelectedAccount(active.selectedAccount);
+    };
+    sdkInstance.initialize().catch((err) => {
+      console.error("Failed to initialize SDK:", err);
+      setError(err);
+    });
+    const handleConnect = (result) => {
+      if (result.status === "connecting") {
+        setIsConnecting(true);
+        setError(null);
+      } else {
+        setIsConnected(true);
+        updateAccountsFromSdk();
+        setIsConnecting(false);
+        setError(null);
+        updateSelectedAccount(result?.selectedAccount ?? null);
+      }
+    };
+    const resetData = () => {
+      setIsConnected(false);
+      setAccounts([]);
+      setIsConnecting(false);
+      setSelectedAccount(null);
+    };
+    const handleDisconnect = () => {
+      resetData();
+    };
+    const handleError = (err) => {
+      setError(err.error || new Error("Unknown error"));
+      setIsConnecting(false);
+    };
+    const handleLock = () => {
+      resetData();
+    };
+    const handleAccountChanged = (account) => {
+      updateAccountsFromSdk();
+      updateSelectedAccount(account ?? void 0);
+    };
+    sdkInstance.on("connect", handleConnect);
+    sdkInstance.on("disconnect", handleDisconnect);
+    sdkInstance.on("error", handleError);
+    sdkInstance.on("lock", handleLock);
+    sdkInstance.on("accountChanged", handleAccountChanged);
+    return () => {
+      sdkInstance.off("connect", handleConnect);
+      sdkInstance.off("disconnect", handleDisconnect);
+      sdkInstance.off("error", handleError);
+      sdkInstance.off("lock", handleLock);
+      sdkInstance.off("accountChanged", handleAccountChanged);
+      sdkInstance.destroy();
+    };
+  }, []);
+  const selectAccount = useCallback(async (account) => {
+    if (!sdk) {
+      throw new Error("BrowserSDK not initialized");
+    }
+    try {
+      const updated = await sdk.selectAccount(account.address);
+      const active = normalizeActiveWalletAccounts(sdk.getAccounts(), updated);
+      setSelectedAccount(active.selectedAccount);
+      setAccounts(active.accounts);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to select account"));
+      throw err;
+    }
+  }, [sdk]);
+  const manageAccounts = useCallback(async () => {
+    if (!sdk) {
+      throw new Error("BrowserSDK not initialized");
+    }
+    try {
+      const result = await sdk.manageAccounts();
+      const activeResult = normalizeWalletAccountResult(result);
+      setSelectedAccount(activeResult.selectedAccount);
+      setAccounts(activeResult.accounts);
+      setIsConnected(Boolean(activeResult.selectedAccount));
+      return activeResult;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to manage accounts"));
+      throw err;
+    }
+  }, [sdk]);
+  return /* @__PURE__ */ jsx(
+    ThruContext.Provider,
+    {
+      value: {
+        thru,
+        wallet: sdk,
+        isConnected,
+        accounts,
+        isConnecting,
+        error,
+        selectedAccount,
+        selectAccount,
+        manageAccounts
+      },
+      children
+    }
+  );
+}
+function useThru() {
+  const context = useContext(ThruContext);
+  return context;
+}
+
+// src/react/hooks/useAccounts.ts
+function useAccounts(options) {
+  const { accounts, selectedAccount, isConnected, isConnecting } = useThru();
+  const externalOnSelect = options?.onAccountSelect;
+  useEffect(() => {
+    if (selectedAccount) {
+      externalOnSelect?.(selectedAccount);
+    }
+  }, [externalOnSelect, selectedAccount]);
+  return useMemo(
+    () => ({
+      accounts,
+      selectedAccount,
+      isConnected,
+      isConnecting
+    }),
+    [accounts, selectedAccount, isConnected, isConnecting]
+  );
+}
+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("SDK not initialized in time"));
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}
+function useWallet() {
+  const {
+    wallet,
+    isConnected,
+    accounts,
+    selectedAccount,
+    selectAccount,
+    manageAccounts,
+    isConnecting
+  } = useThru();
+  const walletRef = useRef(wallet);
+  useEffect(() => {
+    walletRef.current = wallet;
+  }, [wallet]);
+  const disconnect = async () => {
+    if (!wallet) {
+      throw new Error("SDK not initialized");
+    }
+    await wallet.disconnect();
+  };
+  const connect = async (options) => {
+    try {
+      const readySdk = walletRef.current ?? await waitForWallet(() => walletRef.current);
+      const result = await readySdk.connect(options);
+      return result;
+    } catch (err) {
+      const error = err;
+      throw error;
+    }
+  };
+  const mountInline = async (container) => {
+    const readySdk = walletRef.current ?? await waitForWallet(() => walletRef.current);
+    await readySdk.mountInline(container);
+  };
+  const openAccountSettings = async () => {
+    return manageAccounts();
+  };
+  return {
+    wallet: wallet?.thru,
+    accounts,
+    connect,
+    disconnect,
+    mountInline,
+    manageAccounts: openAccountSettings,
+    isConnected: isConnected && !!wallet,
+    isConnecting,
+    selectedAccount,
+    selectAccount
+  };
+}
+
+export { BrowserSDK, ErrorCode, ThruProvider, useAccounts, useThru, useWallet };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map