@thru/wallet 0.2.27 → 0.2.28

package/src/encoding.ts

@@ -0,0 +1,39 @@
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+const BASE64_LOOKUP = new Map<string, number>(
+  [...BASE64_ALPHABET].map((char, index) => [char, index]),
+);
+
+export function base64ToBytes(value: string): Uint8Array {
+  const normalized = value.replace(/\s+/g, "");
+  if (normalized.length === 0) return new Uint8Array();
+  if (normalized.length % 4 === 1) {
+    throw new Error("Invalid base64 data");
+  }
+
+  const padded = normalized.padEnd(
+    normalized.length + ((4 - (normalized.length % 4)) % 4),
+    "=",
+  );
+  const padding = padded.endsWith("==") ? 2 : padded.endsWith("=") ? 1 : 0;
+  const output = new Uint8Array((padded.length / 4) * 3 - padding);
+  let outIdx = 0;
+
+  for (let i = 0; i < padded.length; i += 4) {
+    const chars = padded.slice(i, i + 4);
+    const a = BASE64_LOOKUP.get(chars[0]);
+    const b = BASE64_LOOKUP.get(chars[1]);
+    const c = chars[2] === "=" ? 0 : BASE64_LOOKUP.get(chars[2]);
+    const d = chars[3] === "=" ? 0 : BASE64_LOOKUP.get(chars[3]);
+    if (a === undefined || b === undefined || c === undefined || d === undefined) {
+      throw new Error("Invalid base64 data");
+    }
+
+    const chunk = (a << 18) | (b << 12) | (c << 6) | d;
+    if (outIdx < output.length) output[outIdx++] = (chunk >> 16) & 0xff;
+    if (outIdx < output.length) output[outIdx++] = (chunk >> 8) & 0xff;
+    if (outIdx < output.length) output[outIdx++] = chunk & 0xff;
+  }
+
+  return output;
+}

package/src/index.ts

@@ -6,7 +6,10 @@ export {
 
 export type {
   ConnectedApp, ConnectResult, IThruChain, SignMessageParams,
-  SignMessageResult, ThruSigningContext, ThruTransactionIntent, WalletAccount
+  SignMessageResult, ThruSigningContext, ThruSigningSession,
+  ThruSigningSessionCreateOptions, ThruSigningSessionDescriptor,
+  ThruSigningSessionInstruction, ThruSigningSessionInstructionCreateOptions,
+  ThruSigningSessionTimestamp, ThruTransactionIntent, WalletAccount
 } from './interfaces';
 export {
   AddressType,
@@ -25,3 +28,4 @@ export {
   ErrorCode,
 } from './protocol';
 export * from './protocol';
+export type { SigningSessionStorage } from './signing-sessions';

package/src/interfaces/IThruChain.ts

@@ -1,4 +1,13 @@
-import type { ThruSigningContext, ThruTransactionIntent } from "./types";
+import type {
+  ThruSigningContext,
+  ThruSigningSession,
+  ThruSigningSessionCreateOptions,
+  ThruSigningSessionInstruction,
+  ThruSigningSessionInstructionCreateOptions,
+  ThruPasskeyChallengeIntent,
+  ThruPasskeyChallengeSignature,
+  ThruTransactionIntent,
+} from "./types";
 
 /**
  * Minimal Thru chain interface exposed to SDK consumers.
@@ -34,4 +43,44 @@ export interface IThruChain {
    * account ordering, headers, nonces, and final wire layout.
    */
   signTransaction(transaction: ThruTransactionIntent): Promise<string>;
+
+  /**
+   * Sign a backend-prepared passkey-manager challenge with the wallet-owned
+   * selected passkey and return submit-ready signature fields.
+   */
+  signPasskeyChallenge(
+    challenge: ThruPasskeyChallengeIntent,
+  ): Promise<ThruPasskeyChallengeSignature>;
+
+  /**
+   * Create a temporary wallet-owned signing session. The SDK stores the
+   * returned descriptor in app-local storage; the wallet stores the private key.
+   */
+  createSigningSession(
+    options: ThruSigningSessionCreateOptions,
+  ): Promise<ThruSigningSession>;
+
+  /**
+   * Prepare a temporary signing-session authority instruction without asking
+   * for passkey approval. The returned instruction must be included in a
+   * later passkey-approved transaction before the session can sign.
+   */
+  createSigningSessionInstruction(
+    options: ThruSigningSessionInstructionCreateOptions,
+  ): Promise<ThruSigningSessionInstruction>;
+
+  /**
+   * Confirm that a prepared signing-session instruction landed on-chain and
+   * publish the resulting session descriptor into SDK storage.
+   */
+  confirmSigningSession(id: string): Promise<ThruSigningSession>;
+
+  /** Return a locally known signing session by id. */
+  getSigningSession(id: string): Promise<ThruSigningSession | null>;
+
+  /** Return locally known signing sessions for this SDK app scope only. */
+  getSigningSessions(): Promise<ThruSigningSession[]>;
+
+  /** Delete a locally known session and ask the wallet to delete its key. */
+  revokeSigningSession(id: string): Promise<void>;
 }

package/src/interfaces/types.ts

@@ -66,6 +66,43 @@ export interface ThruTransactionReviewPayload {
   abiReflection?: ThruTransactionReviewAbiReflection;
 }
 
+export type ThruSigningSessionTimestamp = Date | number | bigint | string;
+
+export interface ThruSigningSessionCreateOptions {
+  walletAddress?: string;
+  durationSeconds?: number;
+  expiresAt?: ThruSigningSessionTimestamp;
+  review?: ThruTransactionReviewPayload;
+}
+
+export interface ThruSigningSessionInstructionCreateOptions extends Omit<
+  ThruSigningSessionCreateOptions,
+  "review"
+> {
+  walletAccountIdx: number;
+}
+
+export interface ThruSigningSessionDescriptor {
+  id: string;
+  walletAddress: string;
+  publicKey: string;
+  authIdx: number;
+  expiresAt: number;
+  createdAt: number;
+}
+
+export interface ThruSigningSession extends ThruSigningSessionDescriptor {
+  signTransaction(transaction: ThruTransactionIntent): Promise<string>;
+  revoke(): Promise<void>;
+  toJSON(): ThruSigningSessionDescriptor;
+}
+
+export interface ThruSigningSessionInstruction {
+  session: ThruSigningSession;
+  programAddress: string;
+  instructionData: Uint8Array;
+}
+
 export interface ThruTransactionIntent {
   walletAddress?: string;
   programAddress: string;
@@ -73,6 +110,21 @@ export interface ThruTransactionIntent {
   readWriteAddresses?: string[];
   readOnlyAddresses?: string[];
   review?: ThruTransactionReviewPayload;
+  /** @internal Used by ThruSigningSession handles. */
+  signingSessionId?: string;
+}
+
+export interface ThruPasskeyChallengeIntent {
+  /** base64url-encoded passkey-manager challenge bytes. */
+  challenge: string;
+  walletAddress?: string;
+}
+
+export interface ThruPasskeyChallengeSignature {
+  signatureR: string;
+  signatureS: string;
+  authenticatorData: string;
+  clientDataJSON: string;
 }
 
 export interface ConnectedApp {

package/src/native/NativeSDK.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   ErrorCode,
   EMBEDDED_PROVIDER_EVENTS,
@@ -96,6 +96,20 @@ async function flush(): Promise<void> {
   for (let i = 0; i < 8; i++) await Promise.resolve();
 }
 
+async function wait(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForInjectedRequest(webView: MockWebView): Promise<string> {
+  for (let i = 0; i < 60; i++) {
+    await flush();
+    const script = webView.injected[0];
+    if (script) return script;
+    await wait(50);
+  }
+  throw new Error("Timed out waiting for injected request");
+}
+
 function parseInjectedRequest(script: string): {
   id: string;
   type: string;
@@ -138,6 +152,191 @@ describe("NativeSDK", () => {
     directSdk.destroy();
   });
 
+  it("defaults transparent wallet experience to the transparent native route", () => {
+    const transparentSdk = new NativeSDK({
+      walletExperience: "transparent",
+      origin: "thru-mobile://token-dummy",
+    });
+    const iframeUrl = new URL(transparentSdk.getIframeSrc());
+
+    expect(iframeUrl.origin).toBe("https://wallet.thru.org");
+    expect(iframeUrl.pathname).toBe("/embedded/native/transparent");
+
+    transparentSdk.destroy();
+  });
+
+  it("requests a transparent focus surface for transparent connect", async () => {
+    sdk.destroy();
+    sdk = new NativeSDK({
+      walletUrl: "http://localhost:3000/embedded/native/transparent",
+      walletExperience: "transparent",
+      origin: "thru-mobile://token-dummy",
+    });
+    webView = new MockWebView();
+    sdk.attachWebView(webView);
+    const onShowRequested = vi.fn();
+    const onHideRequested = vi.fn();
+    sdk.setUiHandlers({ onShowRequested, onHideRequested });
+
+    const frameId = frameIdFor(sdk);
+    const promise = sdk.signIn({
+      app_id: "token_dummy_app",
+      app_display_name: "Token Dummy App",
+    });
+
+    sdk.onMessage(readyMessage(frameId));
+    await flush();
+
+    expect(onShowRequested).toHaveBeenCalledTimes(1);
+    const request = parseInjectedRequest(await waitForInjectedRequest(webView));
+    expect(request.type).toBe(POST_MESSAGE_REQUEST_TYPES.CONNECT);
+    expect(request.payload).toEqual({
+      metadata: {
+        appId: "token_dummy_app",
+        appName: "Token Dummy App",
+      },
+    });
+
+    const result = {
+      accounts: [
+        {
+          accountType: "thru",
+          address: "thru_test_address",
+          label: "Account 1",
+        },
+      ],
+      status: "completed",
+    };
+    sdk.onMessage(responseMessage(frameId, request.id, result));
+
+    await expect(promise).resolves.toEqual({
+      ...result,
+      selectedAccount: result.accounts[0],
+    });
+    expect(onHideRequested).toHaveBeenCalledTimes(1);
+  });
+
+  it("sends transparent createAccount requests through the wallet WebView", async () => {
+    sdk.destroy();
+    sdk = new NativeSDK({
+      walletUrl: "http://localhost:3000/embedded/native/transparent",
+      walletExperience: "transparent",
+      origin: "thru-mobile://token-dummy",
+    });
+    webView = new MockWebView();
+    sdk.attachWebView(webView);
+    const onShowRequested = vi.fn();
+    const onHideRequested = vi.fn();
+    const onConnect = vi.fn();
+    sdk.setUiHandlers({ onShowRequested, onHideRequested });
+    sdk.on("connect", onConnect);
+
+    const frameId = frameIdFor(sdk);
+    const promise = sdk.createAccount({
+      accountName: "JCoin Account",
+      metadata: {
+        appId: "token_dummy_app",
+        appName: "Token Dummy App",
+        appUrl: "thru-mobile://token-dummy",
+      },
+    });
+
+    sdk.onMessage(readyMessage(frameId));
+    await flush();
+
+    expect(onShowRequested).toHaveBeenCalledTimes(1);
+    const request = parseInjectedRequest(await waitForInjectedRequest(webView));
+    expect(request.type).toBe(POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT);
+    expect(request.payload).toEqual({
+      accountName: "JCoin Account",
+      metadata: {
+        appId: "token_dummy_app",
+        appName: "Token Dummy App",
+        appUrl: "thru-mobile://token-dummy",
+      },
+    });
+
+    const result = {
+      account: {
+        accountType: "thru",
+        address: "thru_created_address",
+        label: "JCoin Account",
+      },
+      accounts: [
+        {
+          accountType: "thru",
+          address: "thru_created_address",
+          label: "JCoin Account",
+        },
+      ],
+      selectedAccount: {
+        accountType: "thru",
+        address: "thru_created_address",
+        label: "JCoin Account",
+      },
+      signature: "thru_signature",
+      vmError: "0",
+      userErrorCode: "0",
+      executionResult: "0",
+    };
+    sdk.onMessage(responseMessage(frameId, request.id, result));
+
+    await expect(promise).resolves.toEqual(result);
+    expect(onHideRequested).toHaveBeenCalledTimes(1);
+    expect(onConnect).toHaveBeenLastCalledWith({
+      accounts: result.accounts,
+      selectedAccount: result.selectedAccount,
+      status: "completed",
+      metadata: {
+        appId: "token_dummy_app",
+        appName: "Token Dummy App",
+        appUrl: "thru-mobile://token-dummy",
+      },
+    });
+  });
+
+  it("sends transparent passkey challenge signing requests through the wallet WebView", async () => {
+    sdk.destroy();
+    sdk = new NativeSDK({
+      walletUrl: "http://localhost:3000/embedded/native/transparent",
+      walletExperience: "transparent",
+      origin: "thru-mobile://token-dummy",
+    });
+    webView = new MockWebView();
+    sdk.attachWebView(webView);
+    const onShowRequested = vi.fn();
+    const onHideRequested = vi.fn();
+    sdk.setUiHandlers({ onShowRequested, onHideRequested });
+
+    const frameId = frameIdFor(sdk);
+    const promise = sdk.thru.signPasskeyChallenge({
+      challenge: "challenge_base64url",
+      walletAddress: "thru_test_address",
+    });
+
+    sdk.onMessage(readyMessage(frameId));
+    await flush();
+
+    expect(onShowRequested).toHaveBeenCalledTimes(1);
+    const request = parseInjectedRequest(await waitForInjectedRequest(webView));
+    expect(request.type).toBe(POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE);
+    expect(request.payload).toEqual({
+      challenge: "challenge_base64url",
+      walletAddress: "thru_test_address",
+    });
+
+    const result = {
+      signatureR: "01",
+      signatureS: "02",
+      authenticatorData: "authenticator_data_base64",
+      clientDataJSON: "client_data_json_base64",
+    };
+    sdk.onMessage(responseMessage(frameId, request.id, result));
+
+    await expect(promise).resolves.toEqual(result);
+    expect(onHideRequested).toHaveBeenCalledTimes(1);
+  });
+
   it("maps signIn snake-case app metadata to wallet connect metadata", async () => {
     const frameId = frameIdFor(sdk);
     const promise = sdk.signIn({

package/src/native/NativeSDK.ts

@@ -13,6 +13,7 @@ import {
   ErrorCode,
   type ConnectMetadataInput,
   type ConnectRequestPayload,
+  type CreateAccountResult,
   type GetConnectionStateResult,
   type ManageAccountsResult,
   normalizeConnectionStateResult,
@@ -23,8 +24,13 @@ import type {
   WebViewRefLike,
 } from "./provider/WebViewBridge";
 import { createThruClient, type Thru } from "@thru/sdk/client";
+import {
+  SigningSessionDescriptorStore,
+  resolveSigningSessionStorageKey,
+} from "../signing-sessions";
 
 export type IosWebViewMode = "direct" | "shell-iframe";
+export type NativeWalletExperience = "standard" | "transparent";
 
 export type WalletAvailability =
   | {
@@ -66,9 +72,14 @@ export type WalletAvailability =
 
 export interface NativeSDKConfig {
   walletUrl?: string;
+  /** Wallet presentation loaded in the native WebView. Transparent mode
+      signs in without opening the native wallet sheet. */
+  walletExperience?: NativeWalletExperience;
   /** Stamped on every postMessage so wallet's ConnectedAppsStorage can
       scope per-host. Default: 'thru-mobile://app'. */
   origin?: string;
+  /** Default app metadata used for connection and transparent hydration. */
+  metadata?: ConnectMetadataInput;
   rpcUrl?: string;
   addressTypes?: AddressTypeValue[];
   /** iOS-only host mode. Shell iframe is the default; direct is kept
@@ -81,6 +92,8 @@ export interface NativeSDKConfig {
   storageKey?: string;
   /** Override the key used to remember the app-local selected account. */
   selectedAccountStorageKey?: string;
+  /** Override the key used for app-local signing session descriptors. */
+  signingSessionStorageKey?: string;
 }
 
 export interface SignInOptions {
@@ -97,6 +110,11 @@ export interface ConnectOptions {
   intent?: ConnectRequestPayload["intent"];
 }
 
+export interface CreateAccountOptions {
+  accountName?: string;
+  metadata?: ConnectMetadataInput;
+}
+
 export interface RestoreConnectionOptions {
   hydrate?: boolean;
 }
@@ -125,6 +143,10 @@ export interface NativeSDKUiHandlers {
 
 const DEFAULT_STORAGE_KEY = "thru.native-sdk.connection.v1";
 const SELECTED_ACCOUNT_STORAGE_KEY_SUFFIX = ".selected-account.v1";
+const SIGNING_SESSION_STORAGE_KEY_SUFFIX = ".signing-sessions.v1";
+const DEFAULT_NATIVE_WALLET_URL = "https://wallet.thru.org/embedded/native";
+const DEFAULT_TRANSPARENT_WALLET_URL =
+  "https://wallet.thru.org/embedded/native/transparent";
 
 const CHECKING_WALLET_AVAILABILITY: WalletAvailability = {
   status: "checking",
@@ -139,6 +161,20 @@ const CHECKING_WALLET_AVAILABILITY: WalletAvailability = {
   error: null,
 };
 
+function completeAppMetadata(
+  metadata: ConnectMetadataInput | AppMetadata | null | undefined,
+): AppMetadata | undefined {
+  if (!metadata?.appId || !metadata.appName || !metadata.appUrl) {
+    return undefined;
+  }
+  return {
+    appId: metadata.appId,
+    appName: metadata.appName,
+    appUrl: metadata.appUrl,
+    ...(metadata.imageUrl ? { imageUrl: metadata.imageUrl } : {}),
+  };
+}
+
 interface PersistedSelectedAccountSnapshot {
   version: 1;
   origin: string;
@@ -167,6 +203,8 @@ export class NativeSDK {
   private readonly storageKey: string;
   private readonly selectedAccountStorageKey: string;
   private readonly iosWebViewMode: IosWebViewMode;
+  private readonly walletExperience: NativeWalletExperience;
+  private readonly defaultMetadata?: ConnectMetadataInput;
 
   constructor(config: NativeSDKConfig = {}) {
     this.origin = config.origin ?? "thru-mobile://app";
@@ -177,10 +215,35 @@ export class NativeSDK {
       config.selectedAccountStorageKey ??
       `${this.storageKey}${SELECTED_ACCOUNT_STORAGE_KEY_SUFFIX}`;
     this.iosWebViewMode = config.iosWebViewMode ?? "shell-iframe";
+    this.walletExperience = config.walletExperience ?? "standard";
+    this.defaultMetadata = config.metadata;
+    const walletUrl =
+      config.walletUrl ??
+      (this.walletExperience === "transparent"
+        ? DEFAULT_TRANSPARENT_WALLET_URL
+        : DEFAULT_NATIVE_WALLET_URL);
+    const walletOrigin = new URL(walletUrl).origin;
+    const signingSessions = this.storage
+      ? new SigningSessionDescriptorStore(
+          this.storage,
+          resolveSigningSessionStorageKey({
+            walletOrigin,
+            appOrigin: this.origin,
+            storageKey:
+              config.signingSessionStorageKey ??
+              `${this.storageKey}${SIGNING_SESSION_STORAGE_KEY_SUFFIX}`,
+          }),
+        )
+      : undefined;
     this.provider = new NativeProvider({
-      walletUrl: config.walletUrl,
+      walletUrl,
       origin: this.origin,
+      metadata: this.defaultMetadata
+        ? this.resolveMetadata(this.defaultMetadata)
+        : undefined,
       addressTypes: config.addressTypes ?? [AddressType.THRU],
+      signingSessions,
+      walletExperience: this.walletExperience,
     });
     this.setupEventForwarding();
   }
@@ -252,13 +315,13 @@ export class NativeSDK {
 
     const inFlight = (async () => {
       try {
-        this.provider.requestShow();
+        await this.provider.requestShow();
         if (!this.initialized) await this.initialize();
 
         const metadata = this.resolveMetadata(options?.metadata);
         const preferredAccountAddress = isAccountSwitch
           ? null
-          : await this.readSelectedAccountAddress();
+          : options?.preferredAccountAddress ?? (await this.readSelectedAccountAddress());
         const providerOptions =
           metadata || preferredAccountAddress || options?.intent
             ? {
@@ -318,11 +381,57 @@ export class NativeSDK {
     });
   }
 
+  async createAccount(
+    options: CreateAccountOptions = {},
+  ): Promise<CreateAccountResult> {
+    this.emit("connect", { status: "connecting" });
+
+    try {
+      await this.provider.requestShow();
+      if (!this.initialized) await this.initialize();
+
+      const metadata = this.resolveMetadata(options.metadata);
+      const result = await this.provider.createAccount({
+        ...(options.accountName ? { accountName: options.accountName } : {}),
+        ...(metadata ? { metadata } : {}),
+      });
+      const selectedAccount = result.selectedAccount ?? result.account;
+      const activeResult: CreateAccountResult = {
+        ...result,
+        accounts: this.provider.getAccounts(),
+        selectedAccount,
+        account: selectedAccount,
+      };
+      const completedResult: ConnectResult = {
+        accounts: activeResult.accounts,
+        selectedAccount: activeResult.selectedAccount,
+        status: "completed",
+        metadata: completeAppMetadata(metadata),
+      };
+      this.lastConnectResult = completedResult;
+      await this.persistSelectedAccountAddress(
+        activeResult.selectedAccount.address,
+      );
+      await this.clearPersistedConnection();
+      this.setWalletAvailability(
+        walletAvailabilityFromConnectResult(completedResult),
+      );
+      this.emit("connect", completedResult);
+      this.emit("accountChanged", activeResult.selectedAccount);
+      return activeResult;
+    } catch (error) {
+      this.provider.requestHide();
+      this.emit("error", error);
+      throw error;
+    }
+  }
+
   async disconnect(): Promise<void> {
     try {
       await this.provider.disconnect();
       this.emit("disconnect", {});
       this.lastConnectResult = null;
+      await this.persistSelectedAccountAddress(null);
       await this.clearPersistedConnection();
       this.clearAuthorizedAvailability();
     } catch (error) {
@@ -500,11 +609,15 @@ export class NativeSDK {
     if (!this.initialized) await this.initialize();
 
     const metadata =
-      options?.metadata ?? this.lastConnectResult?.metadata ?? undefined;
+      options?.metadata ??
+      this.lastConnectResult?.metadata ??
+      this.defaultMetadata ??
+      undefined;
     const providerOptions = metadata
       ? { metadata: this.resolveMetadata(metadata) }
       : undefined;
-    const preferredAccountAddress = await this.readSelectedAccountAddress();
+    const preferredAccountAddress =
+      options?.preferredAccountAddress ?? (await this.readSelectedAccountAddress());
     const nextProviderOptions =
       providerOptions || preferredAccountAddress
         ? {
@@ -575,18 +688,19 @@ export class NativeSDK {
   private resolveMetadata(
     input?: ConnectMetadataInput,
   ): ConnectMetadataInput | undefined {
-    if (!input) {
+    const effectiveInput = input ?? this.defaultMetadata;
+    if (!effectiveInput) {
       /* On RN we have no window.location.origin; require explicit
          metadata, but stamp the configured origin as appId so the
          wallet can scope per-host. */
       return { appId: this.origin };
     }
     const metadata: ConnectMetadataInput = {
-      appId: input.appId ?? this.origin,
+      appId: effectiveInput.appId ?? this.origin,
     };
-    if (input.appUrl) metadata.appUrl = input.appUrl;
-    if (input.appName) metadata.appName = input.appName;
-    if (input.imageUrl) metadata.imageUrl = input.imageUrl;
+    if (effectiveInput.appUrl) metadata.appUrl = effectiveInput.appUrl;
+    if (effectiveInput.appName) metadata.appName = effectiveInput.appName;
+    if (effectiveInput.imageUrl) metadata.imageUrl = effectiveInput.imageUrl;
     return metadata;
   }
 

package/src/native/index.ts

@@ -2,10 +2,12 @@ export { NativeSDK } from './NativeSDK';
 export type {
   EventCallback,
   ConnectOptions,
+  CreateAccountOptions,
   IosWebViewMode,
   NativeSDKConfig,
   NativeSDKStorage,
   NativeSDKUiHandlers,
+  NativeWalletExperience,
   RestoreConnectionOptions,
   SDKEvent,
   SignInOptions,
@@ -22,10 +24,19 @@ export type {
   IThruChain,
   SignMessageParams,
   SignMessageResult,
+  ThruPasskeyChallengeIntent,
+  ThruPasskeyChallengeSignature,
   ThruSigningContext,
+  ThruSigningSession,
+  ThruSigningSessionCreateOptions,
+  ThruSigningSessionDescriptor,
+  ThruSigningSessionInstruction,
+  ThruSigningSessionInstructionCreateOptions,
+  ThruSigningSessionTimestamp,
   ThruTransactionIntent,
   WalletAccount,
 } from '../interfaces';
+export type { SigningSessionStorage } from '../signing-sessions';
 
 export {
   EMBEDDED_PROVIDER_EVENTS,
@@ -34,6 +45,7 @@ export {
 } from '../protocol';
 export type {
   ConnectMetadataInput,
+  CreateAccountResult,
   GetConnectionStateResult,
   ManageAccountsResult,
 } from '../protocol';