@thru/wallet 0.2.25 → 0.2.28

package/src/native/provider/NativeProvider.ts

@@ -13,6 +13,8 @@ import {
   createRequestId,
   type ConnectMetadataInput,
   type ConnectRequestPayload,
+  type CreateAccountPayload,
+  type CreateAccountResult,
   type EmbeddedProviderEvent,
   type GetConnectionStateResult,
   type ManageAccountsResult,
@@ -20,6 +22,7 @@ import {
   normalizeConnectionStateResult,
 } from "../../protocol";
 import { NativeThruChain } from "./chains/ThruChain";
+import type { SigningSessionDescriptorStore } from "../../signing-sessions";
 import {
   WebViewBridge,
   type WebViewMessageEventLike,
@@ -28,14 +31,20 @@ import {
 
 const DEFAULT_WALLET_URL = "https://wallet.thru.org/embedded/native";
 const DEFAULT_ORIGIN = "thru-mobile://app";
+const TRANSPARENT_FOCUS_SETTLE_MS = 500;
 
 export interface NativeProviderConfig {
   /** wallet.thru.org/embedded/native URL to load. */
   walletUrl?: string;
+  /** Standard bottom-sheet wallet or transparent auto-signing wallet. */
+  walletExperience?: "standard" | "transparent";
   /** Caller-supplied dapp origin. Stamped on every postMessage so
       wallet's ConnectedAppsStorage can scope per-host. */
   origin?: string;
+  /** Default app metadata used by trusted transparent requests. */
+  metadata?: ConnectMetadataInput;
   addressTypes?: AddressTypeValue[];
+  signingSessions?: SigningSessionDescriptorStore;
 }
 
 export interface ConnectOptions {
@@ -44,6 +53,11 @@ export interface ConnectOptions {
   intent?: ConnectRequestPayload["intent"];
 }
 
+export interface CreateAccountOptions {
+  accountName?: string;
+  metadata?: ConnectMetadataInput;
+}
+
 export type NativeProviderEvent = EmbeddedProviderEvent;
 export type NativeProviderEventCallback = (data?: unknown) => void;
 
@@ -57,10 +71,12 @@ export type NativeProviderEventCallback = (data?: unknown) => void;
 export class NativeProvider {
   private readonly bridge: WebViewBridge;
   private readonly origin: string;
+  private readonly transparent: boolean;
   private _thruChain?: IThruChain;
   private connected = false;
   private accounts: WalletAccount[] = [];
   private selectedAccount: WalletAccount | null = null;
+  private isSurfaceShown = false;
   private readonly eventListeners = new Map<
     string,
     Set<NativeProviderEventCallback>
@@ -73,9 +89,14 @@ export class NativeProvider {
   constructor(config: NativeProviderConfig = {}) {
     const walletUrl = config.walletUrl ?? DEFAULT_WALLET_URL;
     this.origin = config.origin ?? DEFAULT_ORIGIN;
+    this.transparent = config.walletExperience === "transparent";
     this.bridge = new WebViewBridge({ walletUrl });
 
     this.bridge.onEvent = (eventType, payload) => {
+      if (this.transparent && eventType === EMBEDDED_PROVIDER_EVENTS.UI_SHOW) {
+        return;
+      }
+
       this.emit(eventType as NativeProviderEvent, payload);
 
       if (eventType === EMBEDDED_PROVIDER_EVENTS.UI_SHOW) {
@@ -102,7 +123,12 @@ export class NativeProvider {
 
     const addressTypes = config.addressTypes ?? [AddressType.THRU];
     if (addressTypes.includes(AddressType.THRU)) {
-      this._thruChain = new NativeThruChain(this.bridge, this, this.origin);
+      this._thruChain = new NativeThruChain(
+        this.bridge,
+        this,
+        this.origin,
+        config.signingSessions,
+      );
     }
   }
 
@@ -138,13 +164,28 @@ export class NativeProvider {
     await this.bridge.awaitReady();
   }
 
-  /** Open the wallet UI (called internally; also exposed for host). */
-  requestShow(): void {
+  /** Open or focus the wallet host surface. Transparent hosts use this
+      to give WKWebView a focused document for WebAuthn without showing
+      wallet UI. */
+  async requestShow(): Promise<void> {
+    if (this.transparent) {
+      if (!this.isSurfaceShown) {
+        this.isSurfaceShown = true;
+        this.onShowRequested?.();
+      }
+      await new Promise((resolve) =>
+        setTimeout(resolve, TRANSPARENT_FOCUS_SETTLE_MS),
+      );
+      return;
+    }
+    if (this.isSurfaceShown) return;
+    this.isSurfaceShown = true;
     this.onShowRequested?.();
   }
 
   /** Close the wallet UI (called internally; also exposed for host). */
   requestHide(): void {
+    this.isSurfaceShown = false;
     this.onHideRequested?.();
   }
 
@@ -156,7 +197,7 @@ export class NativeProvider {
   async connect(options?: ConnectOptions): Promise<ConnectResult> {
     this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT_START, {});
     try {
-      this.requestShow();
+      await this.requestShow();
       const payload: ConnectRequestPayload = {};
       if (options?.metadata) payload.metadata = options.metadata;
       if (options?.preferredAccountAddress) {
@@ -172,6 +213,9 @@ export class NativeProvider {
       });
 
       const result = normalizeWalletAccountResult(response.result);
+      if (!result.selectedAccount) {
+        throw new Error("Wallet did not return an account");
+      }
       this.connected = true;
       this.accounts = result.accounts;
       this.selectedAccount = result.selectedAccount;
@@ -186,6 +230,59 @@ export class NativeProvider {
     }
   }
 
+  async createAccount(
+    options?: CreateAccountOptions,
+  ): Promise<CreateAccountResult> {
+    try {
+      await this.requestShow();
+      const payload: CreateAccountPayload = {};
+      if (options?.accountName) payload.accountName = options.accountName;
+      if (options?.metadata) payload.metadata = options.metadata;
+
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT,
+        payload,
+        origin: this.origin,
+      });
+
+      const normalized = normalizeWalletAccountResult(
+        response.result,
+        response.result.selectedAccount ?? response.result.account,
+      );
+      const selectedAccount =
+        normalized.selectedAccount ?? response.result.account;
+      if (!selectedAccount) {
+        throw new Error("Wallet did not return a created account");
+      }
+      const result: CreateAccountResult = {
+        ...response.result,
+        accounts: normalized.accounts,
+        selectedAccount,
+        account: selectedAccount,
+      };
+      this.connected = true;
+      this.accounts = result.accounts;
+      this.selectedAccount = result.selectedAccount;
+
+      this.emit(EMBEDDED_PROVIDER_EVENTS.CONNECT, {
+        accounts: result.accounts,
+        selectedAccount: result.selectedAccount,
+        status: "completed",
+        metadata: options?.metadata,
+      });
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ACCOUNT_CHANGED, {
+        account: result.selectedAccount,
+      });
+      this.requestHide();
+      return result;
+    } catch (error) {
+      this.requestHide();
+      this.emit(EMBEDDED_PROVIDER_EVENTS.ERROR, { error });
+      throw error;
+    }
+  }
+
   async getConnectionState(
     options?: ConnectOptions,
   ): Promise<GetConnectionStateResult> {
@@ -247,6 +344,10 @@ export class NativeProvider {
     return this.connected;
   }
 
+  isTransparent(): boolean {
+    return this.transparent;
+  }
+
   hydrateConnection(
     result: ConnectResult,
     selectedAccountAddress?: string | null,
@@ -292,7 +393,7 @@ export class NativeProvider {
   async manageAccounts(): Promise<ManageAccountsResult> {
     if (!this.connected) throw new Error("Wallet not connected");
     try {
-      this.requestShow();
+      await this.requestShow();
       const response = await this.bridge.sendMessage({
         id: createRequestId(),
         type: POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS,

package/src/native/provider/WebViewBridge.test.ts

@@ -170,6 +170,16 @@ describe('WebViewBridge', () => {
     ).toThrow(/Untrusted wallet origin/);
   });
 
+  it('allows wallet.tid.sh in production builds', () => {
+    process.env.NODE_ENV = 'production';
+
+    const productionBridge = new WebViewBridge({
+      walletUrl: 'https://wallet.tid.sh/embedded',
+    });
+    expect(productionBridge.walletOrigin).toBe('https://wallet.tid.sh');
+    productionBridge.destroy();
+  });
+
   it('uses the React Native __DEV__ flag when present', () => {
     process.env.NODE_ENV = 'test';
     (globalThis as typeof globalThis & { __DEV__?: boolean }).__DEV__ = false;
@@ -193,6 +203,16 @@ describe('WebViewBridge', () => {
     expect(src.startsWith('http://localhost:3000/embedded')).toBe(true);
   });
 
+  it('preserves transparent native wallet paths', () => {
+    const transparentBridge = new WebViewBridge({
+      walletUrl: 'http://localhost:3000/embedded/native/transparent',
+    });
+    const src = new URL(transparentBridge.getIframeSrc());
+    expect(src.pathname).toBe('/embedded/native/transparent');
+    expect(src.searchParams.get('tn_frame_id')).toBe(transparentBridge.frameId);
+    transparentBridge.destroy();
+  });
+
   it('resolves awaitReady on IFRAME_READY_EVENT with matching frameId', async () => {
     const ready = bridge.awaitReady();
     bridge.onMessage(readyMessage(bridge.frameId));
@@ -233,7 +253,8 @@ describe('WebViewBridge', () => {
     await flush();
     expect(webView.injected.length).toBe(1);
     expect(webView.injected[0]).toContain('window.__pushIn');
-    expect(webView.injected[0]).toContain('MessageEvent');
+    expect(webView.injected[0]).toContain('window.postMessage');
+    expect(webView.injected[0]).toContain(bridge.frameId);
     expect(webView.injected[0]).toContain(id);
 
     bridge.onMessage(responseMessage(bridge.frameId, id, { accounts: [] }));

package/src/native/provider/WebViewBridge.ts

@@ -16,7 +16,10 @@ import {
    iframe<->ReactNativeWebView postMessage traffic. This bridge only
    speaks the RN side: webView.injectJavaScript out, onMessage in. */
 
-const PRODUCTION_WALLET_ORIGINS = ['https://wallet.thru.org'];
+const PRODUCTION_WALLET_ORIGINS = [
+  'https://wallet.thru.org',
+  'https://wallet.tid.sh',
+];
 
 function isDevelopmentBuild(): boolean {
   const runtime = globalThis as typeof globalThis & {
@@ -88,6 +91,11 @@ function validateWalletOrigin(walletUrl: string): void {
   }
 }
 
+function isNativeEmbeddedWalletPath(pathname: string): boolean {
+  const normalized = pathname.replace(/\/+$/, '') || '/';
+  return normalized === '/embedded/native' || normalized.startsWith('/embedded/native/');
+}
+
 /* Minimal contract for a react-native-webview ref. We accept both refs
    ({ current: WebView }) and direct WebView instances. */
 export interface WebViewRefLike {
@@ -104,9 +112,14 @@ const FAST_REQUEST_TIMEOUT_MS = 30 * 1000;
 
 const SLOW_REQUEST_TYPES: ReadonlySet<string> = new Set([
   POST_MESSAGE_REQUEST_TYPES.CONNECT,
+  POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT,
   POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE,
   POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
+  POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE,
   POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS,
+  POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION,
+  POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION,
+  POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION,
 ]);
 
 export interface WebViewBridgeOptions {
@@ -154,7 +167,7 @@ export class WebViewBridge {
    */
   getIframeSrc(): string {
     const url = new URL(this.walletUrl);
-    if (!url.pathname.endsWith('/native')) {
+    if (!isNativeEmbeddedWalletPath(url.pathname)) {
       url.pathname = `${url.pathname.replace(/\/$/, '')}/native`;
     }
     url.searchParams.set('tn_frame_id', this.frameId);
@@ -246,14 +259,11 @@ export class WebViewBridge {
       });
 
       const script = `try {
-        var msg = ${JSON.stringify(request)};
+        var msg = ${JSON.stringify({ ...request, frameId: this.frameId })};
         if (window.__pushIn) {
           window.__pushIn(msg);
         } else {
-          window.dispatchEvent(new MessageEvent('message', {
-            data: msg,
-            origin: msg.origin || ''
-          }));
+          window.postMessage(msg, window.location.origin);
         }
       } catch (e) {} ; true;`;
       this.webView!.injectJavaScript(script);

package/src/native/provider/chains/ThruChain.ts

@@ -2,11 +2,42 @@ import {
   AddressType,
   type IThruChain,
   type ThruSigningContext,
+  type ThruSigningSession,
+  type ThruSigningSessionCreateOptions,
+  type ThruSigningSessionDescriptor,
+  type ThruSigningSessionInstruction,
+  type ThruSigningSessionInstructionCreateOptions,
+  type ThruPasskeyChallengeIntent,
+  type ThruPasskeyChallengeSignature,
   type ThruTransactionIntent,
 } from "../../../interfaces";
 import { POST_MESSAGE_REQUEST_TYPES, createRequestId } from "../../../protocol";
+import { base64ToBytes } from "../../../encoding";
 import type { NativeProvider } from "../NativeProvider";
 import type { WebViewBridge } from "../WebViewBridge";
+import {
+  SigningSessionDescriptorStore,
+  assertSigningSessionWalletAccountIdx,
+  resolveSessionExpirySeconds,
+} from "../../../signing-sessions";
+
+function descriptorFromWire(session: {
+  id: string;
+  walletAddress: string;
+  publicKey: string;
+  authIdx: number;
+  expiresAt: string;
+  createdAt: string;
+}): ThruSigningSessionDescriptor {
+  return {
+    id: session.id,
+    walletAddress: session.walletAddress,
+    publicKey: session.publicKey,
+    authIdx: session.authIdx,
+    expiresAt: Number(BigInt(session.expiresAt)),
+    createdAt: Number(BigInt(session.createdAt)),
+  };
+}
 
 /**
  * NativeThruChain - mirror of EmbeddedThruChain over the WebView bridge.
@@ -17,11 +48,18 @@ export class NativeThruChain implements IThruChain {
   private readonly bridge: WebViewBridge;
   private readonly provider: NativeProvider;
   private readonly origin: string;
+  private readonly signingSessions?: SigningSessionDescriptorStore;
 
-  constructor(bridge: WebViewBridge, provider: NativeProvider, origin: string) {
+  constructor(
+    bridge: WebViewBridge,
+    provider: NativeProvider,
+    origin: string,
+    signingSessions?: SigningSessionDescriptorStore,
+  ) {
     this.bridge = bridge;
     this.provider = provider;
     this.origin = origin;
+    this.signingSessions = signingSessions;
   }
 
   get connected(): boolean {
@@ -46,7 +84,7 @@ export class NativeThruChain implements IThruChain {
   }
 
   async getSigningContext(): Promise<ThruSigningContext> {
-    if (!this.provider.isConnected()) {
+    if (!this.provider.isConnected() && !this.provider.isTransparent()) {
       throw new Error("Wallet not connected");
     }
     const response = await this.bridge.sendMessage({
@@ -58,28 +96,200 @@ export class NativeThruChain implements IThruChain {
   }
 
   async signTransaction(transaction: ThruTransactionIntent): Promise<string> {
-    if (!this.provider.isConnected()) {
+    const signingSessionId = transaction.signingSessionId;
+    if (
+      !signingSessionId &&
+      !this.provider.isConnected() &&
+      !this.provider.isTransparent()
+    ) {
       throw new Error("Wallet not connected");
     }
 
-    this.provider.requestShow();
+    const session = signingSessionId
+      ? await this.requireSigningSession(signingSessionId)
+      : null;
+    const shouldShowWallet = !signingSessionId;
+    if (shouldShowWallet) {
+      await this.provider.requestShow();
+    }
     try {
       const response = await this.bridge.sendMessage({
         id: createRequestId(),
         type: POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION,
         payload: {
-          walletAddress: transaction.walletAddress,
+          walletAddress: transaction.walletAddress ?? session?.walletAddress,
           programAddress: transaction.programAddress,
           instructionData: transaction.instructionData,
           readWriteAddresses: transaction.readWriteAddresses,
           readOnlyAddresses: transaction.readOnlyAddresses,
           review: transaction.review,
+          signingSessionId,
         },
         origin: this.origin,
       });
       return response.result.signedTransaction;
+    } finally {
+      if (shouldShowWallet) {
+        this.provider.requestHide();
+      }
+    }
+  }
+
+  async signPasskeyChallenge(
+    challenge: ThruPasskeyChallengeIntent,
+  ): Promise<ThruPasskeyChallengeSignature> {
+    if (!this.provider.isConnected() && !this.provider.isTransparent()) {
+      throw new Error("Wallet not connected");
+    }
+    await this.provider.requestShow();
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE,
+        payload: {
+          challenge: challenge.challenge,
+          walletAddress: challenge.walletAddress,
+        },
+        origin: this.origin,
+      });
+      return response.result;
     } finally {
       this.provider.requestHide();
     }
   }
+
+  async createSigningSession(
+    options: ThruSigningSessionCreateOptions,
+  ): Promise<ThruSigningSession> {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+
+    const expiresAt = resolveSessionExpirySeconds(options);
+    await this.provider.requestShow();
+    try {
+      const response = await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION,
+        payload: {
+          walletAddress: options.walletAddress,
+          expiresAt: String(expiresAt),
+          review: options.review,
+        },
+        origin: this.origin,
+      });
+      const descriptor = descriptorFromWire(response.result.session);
+      await this.signingSessions.saveReplacingWalletSessions(descriptor);
+      return this.toSigningSession(descriptor);
+    } finally {
+      this.provider.requestHide();
+    }
+  }
+
+  async createSigningSessionInstruction(
+    options: ThruSigningSessionInstructionCreateOptions,
+  ): Promise<ThruSigningSessionInstruction> {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+
+    const expiresAt = resolveSessionExpirySeconds(options);
+    assertSigningSessionWalletAccountIdx(options.walletAccountIdx);
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION,
+      payload: {
+        walletAddress: options.walletAddress,
+        expiresAt: String(expiresAt),
+        walletAccountIdx: options.walletAccountIdx,
+      },
+      origin: this.origin,
+    });
+    const descriptor = descriptorFromWire(response.result.session);
+    return {
+      session: this.toSigningSession(descriptor),
+      programAddress: response.result.programAddress,
+      instructionData: base64ToBytes(response.result.instructionData),
+    };
+  }
+
+  async confirmSigningSession(id: string): Promise<ThruSigningSession> {
+    if (!this.provider.isConnected()) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+
+    const response = await this.bridge.sendMessage({
+      id: createRequestId(),
+      type: POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION,
+      payload: { sessionId: id },
+      origin: this.origin,
+    });
+    const descriptor = descriptorFromWire(response.result.session);
+    await this.signingSessions.saveReplacingWalletSessions(descriptor);
+    return this.toSigningSession(descriptor);
+  }
+
+  async getSigningSession(id: string): Promise<ThruSigningSession | null> {
+    if (!this.signingSessions) return null;
+    const descriptor = await this.signingSessions.get(id);
+    return descriptor ? this.toSigningSession(descriptor) : null;
+  }
+
+  async getSigningSessions(): Promise<ThruSigningSession[]> {
+    if (!this.signingSessions) return [];
+    return (await this.signingSessions.list()).map((descriptor) =>
+      this.toSigningSession(descriptor),
+    );
+  }
+
+  async revokeSigningSession(id: string): Promise<void> {
+    try {
+      await this.bridge.sendMessage({
+        id: createRequestId(),
+        type: POST_MESSAGE_REQUEST_TYPES.REVOKE_SIGNING_SESSION,
+        payload: { sessionId: id },
+        origin: this.origin,
+      });
+    } finally {
+      await this.signingSessions?.remove(id);
+    }
+  }
+
+  private async requireSigningSession(
+    id: string,
+  ): Promise<ThruSigningSessionDescriptor> {
+    if (!this.signingSessions) {
+      throw new Error("NativeSDKStorage is required for signing sessions");
+    }
+    const session = await this.signingSessions.get(id);
+    if (!session) {
+      throw new Error("Signing session is not known to this app");
+    }
+    return session;
+  }
+
+  private toSigningSession(
+    descriptor: ThruSigningSessionDescriptor,
+  ): ThruSigningSession {
+    return {
+      ...descriptor,
+      signTransaction: (transaction) =>
+        this.signTransaction({
+          ...transaction,
+          walletAddress: transaction.walletAddress ?? descriptor.walletAddress,
+          signingSessionId: descriptor.id,
+        }),
+      revoke: () => this.revokeSigningSession(descriptor.id),
+      toJSON: () => ({ ...descriptor }),
+    };
+  }
 }

package/src/native/react/ThruContext.ts

@@ -1,10 +1,11 @@
 import { createContext } from 'react';
 import type {
+  CreateAccountOptions,
   NativeSDK,
   WalletAvailability,
 } from "../NativeSDK";
 import type { WalletAccount } from "../../interfaces";
-import type { ManageAccountsResult } from "../../protocol";
+import type { CreateAccountResult, ManageAccountsResult } from "../../protocol";
 
 export const CHECKING_WALLET_AVAILABILITY: WalletAvailability = {
   status: 'checking',
@@ -31,6 +32,7 @@ export interface ThruContextValue {
   walletAvailability: WalletAvailability;
   error: Error | null;
   selectAccount: (account: WalletAccount) => Promise<void>;
+  createAccount: (options?: CreateAccountOptions) => Promise<CreateAccountResult>;
   manageAccounts: () => Promise<ManageAccountsResult>;
 }
 

package/src/native/react/ThruProvider.tsx

@@ -6,10 +6,12 @@
 import { type ReactNode, useCallback, useEffect, useState } from "react";
 import {
   NativeSDK,
+  type CreateAccountOptions,
   type NativeSDKConfig,
   type WalletAvailability,
 } from "../NativeSDK";
 import type { WalletAccount } from "../../interfaces";
+import type { CreateAccountResult } from "../../protocol";
 import { CHECKING_WALLET_AVAILABILITY, ThruContext } from "./ThruContext";
 
 export interface ThruProviderProps {
@@ -147,6 +149,28 @@ export function ThruProvider({ children, config }: ThruProviderProps) {
     }
   }, [sdk]);
 
+  const createAccount = useCallback(
+    async (options?: CreateAccountOptions): Promise<CreateAccountResult> => {
+      if (!sdk) throw new Error("NativeSDK not initialized");
+      try {
+        const result = await sdk.createAccount(options);
+        setSelectedAccount(result.selectedAccount);
+        setAccounts(result.accounts);
+        setIsConnected(true);
+        setIsConnecting(false);
+        setWalletAvailability(sdk.getWalletAvailability());
+        return result;
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("createAccount failed"),
+        );
+        setIsConnecting(false);
+        throw err;
+      }
+    },
+    [sdk],
+  );
+
   return (
     <ThruContext.Provider
       value={{
@@ -159,6 +183,7 @@ export function ThruProvider({ children, config }: ThruProviderProps) {
         selectedAccount,
         walletAvailability,
         selectAccount,
+        createAccount,
         manageAccounts,
       }}
     >