@thru/wallet 0.2.22

package/README.md

@@ -0,0 +1,67 @@
+# @thru/wallet
+
+Low-level browser SDK for embedding the Thru wallet experience. It manages the iframe-based embedded provider, forwards lifecycle events, and exposes a ready-to-use `Thru` RPC client alongside wallet account management utilities.
+
+## Installation
+
+```bash
+npm install @thru/wallet
+```
+
+## Basic Usage
+
+```ts
+import { BrowserSDK } from '@thru/wallet';
+
+// Configure the wallet iframe location and the RPC endpoint to talk to
+const sdk = new BrowserSDK({
+  iframeUrl: 'https://wallet.thru.org/embedded',
+  rpcUrl: 'https://grpc-web.alphanet.thruput.org',
+});
+
+await sdk.initialize(); // injects the iframe once
+
+// Observe lifecycle events
+sdk.on('connect', ({ accounts }) => {
+  console.log('Connected accounts', accounts);
+});
+sdk.on('disconnect', () => console.log('Wallet disconnected'));
+sdk.on('error', (err) => console.error('Wallet error', err));
+
+// Trigger the wallet connect flow
+const result = await sdk.connect();
+const primary = result.accounts[0];
+
+// Use the embedded Thru RPC client
+const thru = sdk.getThru();
+const account = await thru.accounts.get(primary.address);
+
+// Disconnect when finished
+await sdk.disconnect();
+```
+
+### Key Capabilities
+
+- Handles iframe creation and cleanup (`initialize`, `destroy`)
+- Connection helpers (`connect`, `disconnect`, `isConnected`, `selectAccount`)
+- Event emitter for wallet state changes (`connect`, `disconnect`, `lock`, `error`, `accountChanged`)
+- Access to a typed Thru RPC client via `sdk.getThru()` for querying on-chain data or submitting transactions
+
+## React Native
+
+React Native apps use the native wallet entrypoints from this same package:
+
+```tsx
+import { ThruProvider, ThruWalletSheet } from '@thru/wallet/native/react';
+
+export default function Root() {
+  return (
+    <ThruProvider config={{ walletUrl: 'https://wallet.thru.org/embedded' }}>
+      <App />
+      <ThruWalletSheet />
+    </ThruProvider>
+  );
+}
+```
+
+Expo apps should install the config plugin from `@thru/wallet/native/plugin`.

package/android/build.gradle

@@ -0,0 +1,37 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'org.thru.walletnative'
+version = '0.0.1'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+
+useCoreDependencies()
+useExpoPublishing()
+
+useDefaultAndroidSdkVersions()
+
+android {
+  namespace = "org.thru.walletnative"
+
+  defaultConfig {
+    versionCode 1
+    versionName "0.0.1"
+  }
+
+  publishing {
+    multipleVariants {
+      withSourcesJar()
+      withJavadocJar()
+      allVariants()
+    }
+  }
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  implementation 'androidx.webkit:webkit:1.14.0'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/org/thru/walletnative/ThruWebViewBridgeModule.kt

@@ -0,0 +1,77 @@
+package org.thru.walletnative
+
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import androidx.webkit.WebSettingsCompat
+import androidx.webkit.WebViewFeature
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+
+/**
+ * Bridges react-native-webview's `WebView` to androidx.webkit's
+ * `WebSettingsCompat.setWebAuthenticationSupport`, which is required
+ * for `navigator.credentials.create/get` to succeed inside the WebView.
+ * This module does not create or read passkeys itself; it only flips the
+ * WebView setting so the wallet page can own the WebAuthn request.
+ *
+ * react-native-webview does not call this itself today
+ * (https://github.com/react-native-webview/react-native-webview/issues/3807),
+ * so the host (ThruWalletSheet) calls our `enableWebAuthnSupport`
+ * function after the WebView mounts.
+ *
+ * The Gradle deps (`androidx.webkit:webkit:1.14.0`,
+ * `androidx.credentials:credentials*`) are pulled in by our Expo
+ * config plugin; no extra host-app wiring required.
+ */
+class ThruWebViewBridgeModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ThruWebViewBridge")
+
+    /**
+     * Resolve the mounted react-native-webview by native view tag, find
+     * the WebView inside it, and enable WebAuthn support on it.
+     * Returns true if the call landed; false if the feature isn't
+     * supported on this WebView (e.g. ancient WebView version), no
+     * view tag was provided, or no WebView was found.
+     */
+    AsyncFunction("enableWebAuthnSupport") { viewTag: Int? ->
+      runBlocking {
+        withContext(Dispatchers.Main) {
+          val rootView = appContext.currentActivity?.window?.decorView
+            ?: return@withContext false
+          val targetView = viewTag?.let { rootView.findViewById<View>(it) }
+            ?: return@withContext false
+          val webView = findWebView(targetView)
+            ?: return@withContext false
+
+          if (!WebViewFeature.isFeatureSupported(WebViewFeature.WEB_AUTHENTICATION)) {
+            return@withContext false
+          }
+          WebSettingsCompat.setWebAuthenticationSupport(
+            webView.settings,
+            WebSettingsCompat.WEB_AUTHENTICATION_SUPPORT_FOR_APP,
+          )
+          true
+        }
+      }
+    }
+  }
+
+  /** react-native-webview wraps the WebView in an RNCWebView container;
+   *  walk the descendants to find the first WebView. */
+  private fun findWebView(view: View?): WebView? {
+    if (view == null) return null
+    if (view is WebView) return view
+    if (view is ViewGroup) {
+      for (i in 0 until view.childCount) {
+        val found = findWebView(view.getChildAt(i))
+        if (found != null) return found
+      }
+    }
+    return null
+  }
+}

package/app.plugin.cjs

@@ -0,0 +1,101 @@
+/* Expo entrypoint for the config plugin. Keep this file dependency-free so
+   Expo can load it from a clean workspace before package build artifacts exist. */
+
+const DEFAULT_RP_DOMAIN = "wallet.thru.org";
+const APP_BOUND_DOMAIN_CAP = 10;
+const MIN_ANDROID_SDK_FOR_PASSKEYS = 28;
+const ANDROID_SYSTEM_BRIGHTNESS_PERMISSION =
+  "android.permission.WRITE_SETTINGS";
+const IOS_ASSOCIATED_DOMAIN_MODES = new Set([
+  "developer",
+  "managed",
+  "developer+managed",
+]);
+
+const ANDROID_CREDENTIAL_MANAGER_DEPS = [
+  "androidx.credentials:credentials:1.5.0",
+  "androidx.credentials:credentials-play-services-auth:1.5.0",
+  "androidx.webkit:webkit:1.14.0",
+];
+
+function withThruWalletNative(config, opts = {}) {
+  const rpDomain = opts.rpDomain || DEFAULT_RP_DOMAIN;
+  const associatedDomainMode = opts.iosAssociatedDomainMode;
+  if (
+    associatedDomainMode &&
+    !IOS_ASSOCIATED_DOMAIN_MODES.has(associatedDomainMode)
+  ) {
+    throw new Error(
+      `[@thru/wallet/native/plugin] Invalid iosAssociatedDomainMode "${associatedDomainMode}". Expected developer, managed, or developer+managed.`,
+    );
+  }
+
+  if (!config.ios) config.ios = {};
+  if (!config.ios.infoPlist) config.ios.infoPlist = {};
+
+  const existingAppBoundDomains = Array.isArray(
+    config.ios.infoPlist.WKAppBoundDomains,
+  )
+    ? config.ios.infoPlist.WKAppBoundDomains
+    : [];
+  if (!existingAppBoundDomains.includes(rpDomain)) {
+    if (existingAppBoundDomains.length >= APP_BOUND_DOMAIN_CAP) {
+      throw new Error(
+        `[@thru/wallet/native/plugin] WKAppBoundDomains is capped at ${APP_BOUND_DOMAIN_CAP} entries; cannot add ${rpDomain}. Drop an unused domain from your Info.plist before adding the wallet.`,
+      );
+    }
+    config.ios.infoPlist.WKAppBoundDomains = [
+      ...existingAppBoundDomains,
+      rpDomain,
+    ];
+  }
+
+  const webCredentialsDomain = associatedDomainMode
+    ? `webcredentials:${rpDomain}?mode=${associatedDomainMode}`
+    : `webcredentials:${rpDomain}`;
+  const associatedDomains = Array.isArray(config.ios.associatedDomains)
+    ? config.ios.associatedDomains
+    : [];
+  if (!associatedDomains.includes(webCredentialsDomain)) {
+    config.ios.associatedDomains = [
+      ...associatedDomains,
+      webCredentialsDomain,
+    ];
+  }
+
+  if (!config.android) config.android = {};
+  const currentMin = config.android.minSdkVersion || 0;
+  if (currentMin < MIN_ANDROID_SDK_FOR_PASSKEYS) {
+    config.android.minSdkVersion = MIN_ANDROID_SDK_FOR_PASSKEYS;
+  }
+
+  const existingPermissions = Array.isArray(config.android.permissions)
+    ? config.android.permissions.slice()
+    : [];
+  if (!existingPermissions.includes(ANDROID_SYSTEM_BRIGHTNESS_PERMISSION)) {
+    existingPermissions.push(ANDROID_SYSTEM_BRIGHTNESS_PERMISSION);
+  }
+  config.android.permissions = existingPermissions;
+
+  const existingDeps = Array.isArray(config.android.extraDependencies)
+    ? config.android.extraDependencies.slice()
+    : [];
+  for (const dep of ANDROID_CREDENTIAL_MANAGER_DEPS) {
+    if (!existingDeps.includes(dep)) existingDeps.push(dep);
+  }
+  config.android.extraDependencies = existingDeps;
+
+  config.android.extraProguardRules = [
+    config.android.extraProguardRules,
+    "-keep class androidx.credentials.** { *; }",
+    "-keep class androidx.webkit.** { *; }",
+    "-keep class com.google.android.gms.fido.** { *; }",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return config;
+}
+
+module.exports = withThruWalletNative;
+module.exports.default = withThruWalletNative;

package/dist/BrowserSDK-CpRFiJsW.d.ts

@@ -0,0 +1,409 @@
+import { Thru } from '@thru/sdk/client';
+
+declare const AddressType: {
+    readonly THRU: "thru";
+};
+type AddressType = (typeof AddressType)[keyof typeof AddressType];
+interface WalletAccount {
+    accountType: AddressType;
+    address: string;
+    label: string;
+}
+interface AppMetadata {
+    appId: string;
+    appName: string;
+    appUrl: string;
+    imageUrl?: string;
+}
+interface ConnectResult {
+    walletId?: string;
+    accounts: WalletAccount[];
+    selectedAccount?: WalletAccount | null;
+    status?: "pending" | "completed";
+    metadata?: AppMetadata;
+}
+declare const ThruTransactionEncoding: {
+    readonly SIGNING_PAYLOAD_BASE64: "signing_payload_base64";
+    readonly RAW_TRANSACTION_BASE64: "raw_transaction_base64";
+};
+type ThruTransactionEncoding = (typeof ThruTransactionEncoding)[keyof typeof ThruTransactionEncoding];
+interface ThruSigningContext {
+    mode: "managed_fee_payer";
+    selectedAccountPublicKey: string | null;
+    feePayerPublicKey: string;
+    signerPublicKey: string;
+    acceptedInputEncodings: ThruTransactionEncoding[];
+    outputEncoding: typeof ThruTransactionEncoding.RAW_TRANSACTION_BASE64;
+}
+interface ThruTransactionReviewSimulation {
+    before?: string;
+    after?: string;
+}
+interface ThruTransactionReviewAbiReflection {
+    label?: string;
+    kind?: string | null;
+    typeName?: string;
+    value?: unknown;
+    rawHex?: string;
+    source?: string;
+    error?: string;
+}
+interface ThruTransactionReviewPayload {
+    appName?: string;
+    programAddress?: string;
+    abiName?: string;
+    instruction?: string;
+    simulation?: ThruTransactionReviewSimulation;
+    abiReflection?: ThruTransactionReviewAbiReflection;
+}
+interface ThruTransactionIntent {
+    walletAddress?: string;
+    programAddress: string;
+    instructionData: string;
+    readWriteAddresses?: string[];
+    readOnlyAddresses?: string[];
+    review?: ThruTransactionReviewPayload;
+}
+interface ConnectedApp {
+    accountId: number;
+    appId: string;
+    origin: string;
+    metadata: AppMetadata;
+    connectedAt: number;
+    updatedAt: number;
+}
+interface SignMessageParams {
+    message: string | Uint8Array;
+    networkId: string;
+}
+interface SignMessageResult$1 {
+    signature: Uint8Array;
+    publicKey: string;
+}
+
+/**
+ * Minimal Thru chain interface exposed to SDK consumers.
+ * The concrete implementation will evolve as the Thru transaction
+ * flow is fleshed out, but maintaining a dedicated contract now
+ * keeps the Surface area aligned with other chain adapters.
+ */
+interface IThruChain {
+    /** Indicates whether the wallet has approved a Thru connection. */
+    readonly connected: boolean;
+    /**
+     * Initiate a Thru connection flow. Resolves with the connected address once
+     * the user has approved the request.
+     */
+    connect(): Promise<{
+        publicKey: string;
+    }>;
+    /** Disconnect the currently connected Thru account. */
+    disconnect(): Promise<void>;
+    /**
+     * Return the current embedded signing contract for Thru transactions.
+     *
+     * The selected account is the managed wallet account shown to the user.
+     * The fee payer / signer can differ when the wallet routes transactions
+     * through an embedded manager profile.
+     */
+    getSigningContext(): Promise<ThruSigningContext>;
+    /**
+     * Sign a wallet-managed transaction intent and return canonical raw
+     * transaction bytes encoded as base64. The wallet owns fee payer choice,
+     * account ordering, headers, nonces, and final wire layout.
+     */
+    signTransaction(transaction: ThruTransactionIntent): Promise<string>;
+}
+
+declare const POST_MESSAGE_REQUEST_TYPES: {
+    readonly CONNECT: "connect";
+    readonly DISCONNECT: "disconnect";
+    readonly SIGN_MESSAGE: "signMessage";
+    readonly SIGN_TRANSACTION: "signTransaction";
+    readonly GET_ACCOUNTS: "getAccounts";
+    readonly GET_CONNECTION_STATE: "getConnectionState";
+    readonly GET_SIGNING_CONTEXT: "getSigningContext";
+    readonly SELECT_ACCOUNT: "selectAccount";
+    readonly MANAGE_ACCOUNTS: "manageAccounts";
+};
+type RequestType = (typeof POST_MESSAGE_REQUEST_TYPES)[keyof typeof POST_MESSAGE_REQUEST_TYPES];
+declare const EMBEDDED_PROVIDER_EVENTS: {
+    readonly CONNECT_START: "connect_start";
+    readonly CONNECT: "connect";
+    readonly DISCONNECT: "disconnect";
+    readonly CONNECT_ERROR: "connect_error";
+    readonly ERROR: "error";
+    readonly LOCK: "lock";
+    readonly UI_SHOW: "ui_show";
+    readonly ACCOUNT_CHANGED: "account_changed";
+};
+type EmbeddedProviderEvent = (typeof EMBEDDED_PROVIDER_EVENTS)[keyof typeof EMBEDDED_PROVIDER_EVENTS];
+declare const POST_MESSAGE_EVENT_TYPE: "event";
+declare const IFRAME_READY_EVENT: "iframe:ready";
+declare const DEFAULT_IFRAME_URL = "http://localhost:3000/embedded";
+declare const createRequestId: (prefix?: string) => string;
+interface BaseRequest {
+    id: string;
+    origin: string;
+}
+interface ConnectRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.CONNECT;
+    payload: ConnectRequestPayload;
+}
+interface DisconnectRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.DISCONNECT;
+    payload?: undefined;
+}
+interface SignMessageRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE;
+    payload: SignMessagePayload;
+}
+interface SignTransactionRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION;
+    payload: SignTransactionPayload;
+}
+interface GetAccountsRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.GET_ACCOUNTS;
+    payload?: undefined;
+}
+interface GetConnectionStateRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.GET_CONNECTION_STATE;
+    payload: ConnectRequestPayload;
+}
+interface GetSigningContextRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.GET_SIGNING_CONTEXT;
+    payload?: undefined;
+}
+interface SelectAccountRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.SELECT_ACCOUNT;
+    payload: SelectAccountPayload;
+}
+interface ManageAccountsRequestMessage extends BaseRequest {
+    type: typeof POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS;
+    payload?: undefined;
+}
+type PostMessageRequest = ConnectRequestMessage | DisconnectRequestMessage | SignMessageRequestMessage | SignTransactionRequestMessage | GetAccountsRequestMessage | GetConnectionStateRequestMessage | GetSigningContextRequestMessage | SelectAccountRequestMessage | ManageAccountsRequestMessage;
+interface DisconnectResult {
+}
+interface GetAccountsResult {
+    accounts: WalletAccount[];
+}
+interface GetConnectionStateResult {
+    isAuthorized: boolean;
+    isConnected: boolean;
+    isUnlocked: boolean;
+    hasPasskey: boolean;
+    hasWalletAccount: boolean;
+    accounts: WalletAccount[];
+    selectedAccount: WalletAccount | null;
+    metadata: AppMetadata | null;
+}
+interface SelectAccountPayload {
+    publicKey: string;
+}
+interface SelectAccountResult {
+    account: WalletAccount;
+}
+interface ManageAccountsResult {
+    accounts: WalletAccount[];
+    selectedAccount: WalletAccount | null;
+}
+type RequestResultMap = {
+    [POST_MESSAGE_REQUEST_TYPES.CONNECT]: ConnectResult;
+    [POST_MESSAGE_REQUEST_TYPES.DISCONNECT]: DisconnectResult;
+    [POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE]: SignMessageResult;
+    [POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION]: SignTransactionResult;
+    [POST_MESSAGE_REQUEST_TYPES.GET_ACCOUNTS]: GetAccountsResult;
+    [POST_MESSAGE_REQUEST_TYPES.GET_CONNECTION_STATE]: GetConnectionStateResult;
+    [POST_MESSAGE_REQUEST_TYPES.GET_SIGNING_CONTEXT]: GetSigningContextResult;
+    [POST_MESSAGE_REQUEST_TYPES.SELECT_ACCOUNT]: SelectAccountResult;
+    [POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS]: ManageAccountsResult;
+};
+interface ResponseErrorPayload {
+    code: ErrorCode;
+    message: string;
+    data?: unknown;
+}
+type SuccessResponse<TType extends RequestType> = {
+    id: string;
+    success: true;
+    result: RequestResultMap[TType];
+};
+type ErrorResponse = {
+    id: string;
+    success: false;
+    error: ResponseErrorPayload;
+};
+type PostMessageResponse<TType extends RequestType = RequestType> = SuccessResponse<TType> | ErrorResponse;
+type SuccessfulPostMessageResponse<TType extends RequestType = RequestType> = Extract<PostMessageResponse<TType>, {
+    success: true;
+}>;
+type InferPostMessageResponse<TRequest extends PostMessageRequest> = PostMessageResponse<TRequest["type"]>;
+type InferSuccessfulPostMessageResponse<TRequest extends PostMessageRequest> = SuccessfulPostMessageResponse<TRequest["type"]>;
+interface PostMessageEvent<TEvent extends EmbeddedProviderEvent = EmbeddedProviderEvent, TData = any> {
+    type: typeof POST_MESSAGE_EVENT_TYPE;
+    event: TEvent;
+    data?: TData;
+}
+declare const ErrorCode: {
+    readonly USER_REJECTED: "USER_REJECTED";
+    readonly WALLET_LOCKED: "WALLET_LOCKED";
+    readonly INVALID_PASSWORD: "INVALID_PASSWORD";
+    readonly ALREADY_CONNECTED: "ALREADY_CONNECTED";
+    readonly ACCOUNT_NOT_FOUND: "ACCOUNT_NOT_FOUND";
+    readonly ACCOUNT_CHANGED: "ACCOUNT_CHANGED";
+    readonly INVALID_TRANSACTION: "INVALID_TRANSACTION";
+    readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+    readonly INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+type ConnectMetadataInput = Partial<AppMetadata>;
+type ConnectIntent = "default" | "switch-account";
+interface ConnectRequestPayload {
+    metadata?: ConnectMetadataInput;
+    preferredAccountAddress?: string;
+    intent?: ConnectIntent;
+}
+
+interface SignMessagePayload {
+    message: string | number[];
+    accountIndex?: number;
+}
+interface SignMessageResult {
+    signature: number[];
+    publicKey: string;
+}
+/**
+ * Wallet-managed instruction signing intent.
+ *
+ * Dapps provide the instruction data and account context. The wallet owns
+ * signing strategy details such as passkey validation, fee payer choice,
+ * account ordering, headers, nonces, and final wire layout. Review metadata
+ * is treated as untrusted display-only data.
+ */
+interface SignTransactionPayload {
+    walletAddress?: string;
+    programAddress: string;
+    instructionData: string;
+    readWriteAddresses?: string[];
+    readOnlyAddresses?: string[];
+    review?: TransactionReviewPayload;
+}
+interface SignTransactionResult {
+    signedTransaction: string;
+}
+interface TransactionReviewSimulation {
+    before?: string;
+    after?: string;
+}
+interface TransactionReviewAbiReflection {
+    label?: string;
+    kind?: string | null;
+    typeName?: string;
+    value?: unknown;
+    rawHex?: string;
+    source?: string;
+    error?: string;
+}
+interface TransactionReviewPayload {
+    appName?: string;
+    programAddress?: string;
+    abiName?: string;
+    instruction?: string;
+    simulation?: TransactionReviewSimulation;
+    abiReflection?: TransactionReviewAbiReflection;
+}
+interface GetSigningContextResult {
+    signingContext: ThruSigningContext;
+}
+
+interface BrowserSDKConfig {
+    iframeUrl?: string;
+    addressTypes?: AddressType[];
+    rpcUrl?: string;
+}
+interface ConnectOptions {
+    metadata?: ConnectMetadataInput;
+}
+type SDKEvent = 'connect' | 'disconnect' | 'lock' | 'error' | 'accountChanged';
+type EventCallback = (...args: any[]) => void;
+/**
+ * Browser SDK - Main entry point for dApp developers
+ * Wraps EmbeddedProvider with a clean, simple API
+ */
+declare class BrowserSDK {
+    private provider;
+    private eventListeners;
+    private initialized;
+    private thruClient;
+    private connectInFlight;
+    private lastConnectResult;
+    constructor(config?: BrowserSDKConfig);
+    /**
+     * Initialize the SDK (creates iframe)
+     * Must be called before using the SDK
+     */
+    initialize(): Promise<void>;
+    /**
+     * Connect to wallet
+     * Shows wallet modal and requests connection
+     */
+    connect(options?: ConnectOptions): Promise<ConnectResult>;
+    /**
+     * Mount the wallet iframe inline in a container.
+     */
+    mountInline(container: HTMLElement): Promise<void>;
+    /**
+     * Disconnect from wallet
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get all accounts
+     */
+    getAccounts(): WalletAccount[];
+    getSelectedAccount(): WalletAccount | null;
+    selectAccount(publicKey: string): Promise<WalletAccount>;
+    manageAccounts(): Promise<ManageAccountsResult>;
+    /**
+     * Get Thru chain API (iframe-backed signer)
+     */
+    get thru(): IThruChain;
+    /**
+     * Event emitter: on
+     */
+    on(event: SDKEvent, callback: EventCallback): void;
+    /**
+     * Event emitter: off
+     */
+    off(event: SDKEvent, callback: EventCallback): void;
+    /**
+     * Event emitter: once (listen once and auto-remove)
+     */
+    once(event: SDKEvent, callback: EventCallback): void;
+    /**
+     * Emit event to all listeners
+     */
+    private emit;
+    /**
+     * Set up event forwarding from provider to SDK
+     */
+    private setupEventForwarding;
+    /**
+     * Destroy SDK and cleanup
+     */
+    destroy(): void;
+    private resolveMetadata;
+    private resolveAppUrl;
+    private deriveAppName;
+    getThru(): Thru;
+    private refreshCachedAccounts;
+}
+
+export { type TransactionReviewSimulation as $, AddressType as A, BrowserSDK as B, type ConnectIntent as C, DEFAULT_IFRAME_URL as D, EMBEDDED_PROVIDER_EVENTS as E, type SelectAccountPayload as F, type GetAccountsRequestMessage as G, type SelectAccountRequestMessage as H, IFRAME_READY_EVENT as I, type SelectAccountResult as J, type SignMessageParams as K, type SignMessagePayload as L, type ManageAccountsRequestMessage as M, type SignMessageRequestMessage as N, type SignMessageResult$1 as O, POST_MESSAGE_EVENT_TYPE as P, type SignTransactionPayload as Q, type RequestType as R, type SDKEvent as S, type SignTransactionRequestMessage as T, type SignTransactionResult as U, type SuccessfulPostMessageResponse as V, type ThruSigningContext as W, ThruTransactionEncoding as X, type ThruTransactionIntent as Y, type TransactionReviewAbiReflection as Z, type TransactionReviewPayload as _, type AppMetadata as a, type WalletAccount as a0, createRequestId as a1, type BrowserSDKConfig as b, type ConnectMetadataInput as c, type ConnectOptions as d, type ConnectRequestMessage as e, type ConnectRequestPayload as f, type ConnectResult as g, type ConnectedApp as h, type DisconnectRequestMessage as i, type DisconnectResult as j, type EmbeddedProviderEvent as k, ErrorCode as l, type EventCallback as m, type GetAccountsResult as n, type GetConnectionStateRequestMessage as o, type GetConnectionStateResult as p, type GetSigningContextRequestMessage as q, type GetSigningContextResult as r, type IThruChain as s, type InferPostMessageResponse as t, type InferSuccessfulPostMessageResponse as u, type ManageAccountsResult as v, POST_MESSAGE_REQUEST_TYPES as w, type PostMessageEvent as x, type PostMessageRequest as y, type PostMessageResponse as z };