@thru/wallet 0.2.27 → 0.2.29

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,
       }}
     >

package/src/native/react/ThruTransparentWalletBridge.tsx

@@ -0,0 +1,281 @@
+/* Hidden native wallet WebView for transparent integrations. Hosts compose
+   this alongside <ThruProvider config={{ walletExperience: "transparent" }}>
+   so wallet requests can run without opening bottom-sheet UI. */
+
+import {
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ComponentProps,
+} from "react";
+import {
+  Platform,
+  StyleSheet,
+  View,
+  type LayoutChangeEvent,
+  type StyleProp,
+  type ViewStyle,
+} from "react-native";
+import {
+  WebView,
+  type WebViewMessageEvent,
+  type WebView as WebViewType,
+} from "react-native-webview";
+import { getShellHtml } from "../provider/shell";
+import type { NativeSDK } from "../NativeSDK";
+import type { WebViewRefLike } from "../provider/WebViewBridge";
+import { enableWebAuthnSupport } from "./android-webauthn";
+import { ThruContext } from "./ThruContext";
+
+type WebViewLoadEndEvent = Parameters<
+  NonNullable<ComponentProps<typeof WebView>["onLoadEnd"]>
+>[0];
+
+export interface ThruTransparentWalletBridgeProps {
+  wallet?: NativeSDK | null;
+  style?: StyleProp<ViewStyle>;
+  webViewProps?: Partial<ComponentProps<typeof WebView>>;
+}
+
+export function ThruTransparentWalletBridge({
+  wallet: walletProp,
+  style,
+  webViewProps,
+}: ThruTransparentWalletBridgeProps) {
+  const thruContext = useContext(ThruContext);
+  const wallet = walletProp ?? thruContext?.wallet ?? null;
+  const webViewRef = useRef<WebViewType | null>(null);
+  const webViewNativeTagRef = useRef<number | null>(null);
+  const didRefreshWalletAvailabilityRef = useRef(false);
+  const [isFocusSurfaceActive, setIsFocusSurfaceActive] = useState(false);
+
+  const attachIfReady = useCallback(() => {
+    if (!wallet || !webViewRef.current) return;
+    const ref: WebViewRefLike = {
+      injectJavaScript: (script: string) => {
+        webViewRef.current?.injectJavaScript(script);
+      },
+    };
+    wallet.attachWebView(ref);
+  }, [wallet]);
+
+  const enableAndroidWebAuthnIfNeeded = useCallback(async () => {
+    if (Platform.OS !== "android") return false;
+    const enabled = await enableWebAuthnSupport(webViewNativeTagRef.current);
+    webViewRef.current?.injectJavaScript(
+      "window.dispatchEvent(new Event('thru:native-webauthn-ready')); true;",
+    );
+    return enabled;
+  }, []);
+
+  const focusWebViewDocument = useCallback(() => {
+    const webView = webViewRef.current as (WebViewType & {
+      requestFocus?: () => void;
+    }) | null;
+    webView?.requestFocus?.();
+    webViewRef.current?.injectJavaScript(
+      "try { window.focus(); document.body && document.body.focus && document.body.focus(); } catch (_) {} true;",
+    );
+  }, []);
+
+  const refreshWalletAvailabilityIfReady = useCallback(() => {
+    if (!wallet || didRefreshWalletAvailabilityRef.current) return;
+    didRefreshWalletAvailabilityRef.current = true;
+    void wallet.refreshWalletAvailability();
+  }, [wallet]);
+
+  useEffect(() => {
+    if (!wallet) return;
+    wallet.setUiHandlers({
+      onShowRequested: () => {
+        setIsFocusSurfaceActive(true);
+      },
+      onHideRequested: () => {
+        setIsFocusSurfaceActive(false);
+      },
+    });
+    return () => {
+      wallet.clearUiHandlers();
+    };
+  }, [focusWebViewDocument, wallet]);
+
+  useEffect(() => {
+    if (!isFocusSurfaceActive) return;
+    const timers = [0, 50, 120, 250, 500].map((delay) =>
+      setTimeout(focusWebViewDocument, delay),
+    );
+    return () => {
+      timers.forEach(clearTimeout);
+    };
+  }, [focusWebViewDocument, isFocusSurfaceActive]);
+
+  const webViewSource = useMemo(() => {
+    if (!wallet) return null;
+    if (Platform.OS === "ios" && wallet.getIosWebViewMode() === "direct") {
+      return { uri: wallet.getIframeSrc() };
+    }
+    return {
+      html: getShellHtml({
+        walletUrl: wallet.getIframeSrc(),
+        walletOrigin: wallet.getWalletOrigin(),
+      }),
+      baseUrl: wallet.getWalletOrigin(),
+    };
+  }, [wallet]);
+
+  const isDirectWalletSource = Boolean(
+    wallet &&
+      Platform.OS === "ios" &&
+      wallet.getIosWebViewMode() === "direct",
+  );
+
+  useEffect(() => {
+    didRefreshWalletAvailabilityRef.current = false;
+  }, [webViewSource]);
+
+  const handleWebViewLayout = useCallback(
+    (event: LayoutChangeEvent) => {
+      const target = (event.nativeEvent as { target?: unknown }).target;
+      webViewNativeTagRef.current =
+        typeof target === "number" ? target : webViewNativeTagRef.current;
+      void enableAndroidWebAuthnIfNeeded();
+      webViewProps?.onLayout?.(event);
+    },
+    [enableAndroidWebAuthnIfNeeded, webViewProps],
+  );
+
+  const handleLoadEnd = useCallback(
+    (event: WebViewLoadEndEvent) => {
+      attachIfReady();
+      if (isDirectWalletSource) {
+        void enableAndroidWebAuthnIfNeeded().finally(
+          refreshWalletAvailabilityIfReady,
+        );
+      } else {
+        void enableAndroidWebAuthnIfNeeded();
+      }
+      webViewProps?.onLoadEnd?.(event);
+    },
+    [
+      attachIfReady,
+      enableAndroidWebAuthnIfNeeded,
+      isDirectWalletSource,
+      refreshWalletAvailabilityIfReady,
+      webViewProps,
+    ],
+  );
+
+  const handleMessage = useCallback(
+    (event: WebViewMessageEvent) => {
+      let shouldRefreshAfterBridgeReady = false;
+      let shouldCollapseFocusSurface = false;
+      try {
+        const data = JSON.parse(event.nativeEvent.data) as {
+          id?: unknown;
+          success?: unknown;
+          type?: string;
+        };
+        shouldRefreshAfterBridgeReady = data.type === "iframe:ready";
+        shouldCollapseFocusSurface =
+          typeof data.id === "string" && typeof data.success === "boolean";
+      } catch {
+        /* Let the bridge ignore malformed messages. */
+      }
+
+      if (shouldCollapseFocusSurface) {
+        setIsFocusSurfaceActive(false);
+      }
+
+      wallet?.onMessage({
+        nativeEvent: { data: event.nativeEvent.data },
+      });
+      webViewProps?.onMessage?.(event);
+
+      if (shouldRefreshAfterBridgeReady) {
+        void enableAndroidWebAuthnIfNeeded().finally(
+          refreshWalletAvailabilityIfReady,
+        );
+      }
+    },
+    [
+      enableAndroidWebAuthnIfNeeded,
+      refreshWalletAvailabilityIfReady,
+      wallet,
+      webViewProps,
+    ],
+  );
+
+  if (!webViewSource) return null;
+
+  return (
+    <View
+      collapsable={false}
+      pointerEvents={isFocusSurfaceActive ? "auto" : "none"}
+      style={[
+        styles.container,
+        isFocusSurfaceActive ? styles.activeContainer : null,
+        style,
+      ]}
+    >
+      <WebView
+        {...webViewProps}
+        ref={webViewRef}
+        source={webViewSource}
+        originWhitelist={["*"]}
+        javaScriptEnabled
+        domStorageEnabled
+        webviewDebuggingEnabled={__DEV__}
+        sharedCookiesEnabled
+        allowsInlineMediaPlayback
+        mediaPlaybackRequiresUserAction={false}
+        limitsNavigationsToAppBoundDomains={isDirectWalletSource}
+        onLoadStart={(event) => {
+          attachIfReady();
+          void enableAndroidWebAuthnIfNeeded();
+          webViewProps?.onLoadStart?.(event);
+        }}
+        onLoadEnd={handleLoadEnd}
+        onLayout={handleWebViewLayout}
+        onMessage={handleMessage}
+        style={[
+          styles.webview,
+          isFocusSurfaceActive ? styles.activeWebview : null,
+          webViewProps?.style,
+        ]}
+      />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    height: 1,
+    left: 0,
+    opacity: 0,
+    overflow: "hidden",
+    position: "absolute",
+    top: 0,
+    width: 1,
+  },
+  activeContainer: {
+    bottom: 0,
+    height: "100%",
+    opacity: 1,
+    right: 0,
+    width: "100%",
+    zIndex: 2147483647,
+  },
+  webview: {
+    backgroundColor: "transparent",
+    height: 1,
+    width: 1,
+  },
+  activeWebview: {
+    flex: 1,
+    height: "100%",
+    width: "100%",
+  },
+});

package/src/native/react/hooks/useWallet.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useRef } from 'react';
 import type { ConnectResult, IThruChain } from "../../../interfaces";
-import type { ConnectOptions, SignInOptions } from "../../NativeSDK";
+import type { CreateAccountResult } from "../../../protocol";
+import type { ConnectOptions, CreateAccountOptions, SignInOptions } from "../../NativeSDK";
 import { useThru } from './useThru';
 import { waitForWallet } from './waitForWallet';
 
@@ -38,6 +39,15 @@ export function useWallet() {
     return ready.signIn(options);
   }, []);
 
+  const createTransparentAccount = useCallback(
+    async (options?: CreateAccountOptions): Promise<CreateAccountResult> => {
+      const ready =
+        walletRef.current ?? (await waitForWallet(() => walletRef.current));
+      return ready.createAccount(options);
+    },
+    [],
+  );
+
   const disconnect = useCallback(async (): Promise<void> => {
     const ready =
       walletRef.current ?? (await waitForWallet(() => walletRef.current));
@@ -56,6 +66,7 @@ export function useWallet() {
     accounts,
     connect,
     signIn,
+    createAccount: createTransparentAccount,
     disconnect,
     isConnected: isConnected && !!wallet,
     isConnecting,

package/src/native/react/index.ts

@@ -8,6 +8,8 @@ export type {
   ThruWalletSheetProps,
   ThruWalletSheetHandle,
 } from './ThruWalletSheet';
+export { ThruTransparentWalletBridge } from './ThruTransparentWalletBridge';
+export type { ThruTransparentWalletBridgeProps } from './ThruTransparentWalletBridge';
 
 export { useWallet } from './hooks/useWallet';
 export { useWalletAvailability } from './hooks/useWalletAvailability';
@@ -19,11 +21,20 @@ export { enableWebAuthnSupport } from './android-webauthn';
 export type {
   WalletAccount,
   ConnectResult,
+  ThruSigningSession,
+  ThruSigningSessionCreateOptions,
+  ThruSigningSessionDescriptor,
+  ThruSigningSessionInstruction,
+  ThruSigningSessionInstructionCreateOptions,
+  ThruSigningSessionTimestamp,
+  ThruTransactionIntent,
 } from "../../interfaces";
+export type { SigningSessionStorage } from "../../signing-sessions";
 
 export type {
   IosWebViewMode,
   NativeSDKStorage,
+  NativeWalletExperience,
   WalletAvailability,
 } from "../NativeSDK";
 export type { ManageAccountsResult } from "../../protocol";

package/src/native/react/transparent.ts

@@ -0,0 +1,35 @@
+export { ThruProvider } from './ThruProvider';
+export type { ThruProviderProps } from './ThruProvider';
+export { ThruContext } from './ThruContext';
+export type { ThruContextValue } from './ThruContext';
+
+export { ThruTransparentWalletBridge } from './ThruTransparentWalletBridge';
+export type { ThruTransparentWalletBridgeProps } from './ThruTransparentWalletBridge';
+
+export { useWallet } from './hooks/useWallet';
+export { useWalletAvailability } from './hooks/useWalletAvailability';
+export { useAccounts } from './hooks/useAccounts';
+export { useThru } from './hooks/useThru';
+
+export { enableWebAuthnSupport } from './android-webauthn';
+
+export type {
+  WalletAccount,
+  ConnectResult,
+  ThruSigningSession,
+  ThruSigningSessionCreateOptions,
+  ThruSigningSessionDescriptor,
+  ThruSigningSessionInstruction,
+  ThruSigningSessionInstructionCreateOptions,
+  ThruSigningSessionTimestamp,
+  ThruTransactionIntent,
+} from "../../interfaces";
+export type { SigningSessionStorage } from "../../signing-sessions";
+
+export type {
+  IosWebViewMode,
+  NativeSDKStorage,
+  NativeWalletExperience,
+  WalletAvailability,
+} from "../NativeSDK";
+export type { ManageAccountsResult } from "../../protocol";

package/src/protocol/postMessage.ts

@@ -7,14 +7,20 @@ import type {
 
 export const POST_MESSAGE_REQUEST_TYPES = {
   CONNECT: "connect",
+  CREATE_ACCOUNT: "createAccount",
   DISCONNECT: "disconnect",
   SIGN_MESSAGE: "signMessage",
   SIGN_TRANSACTION: "signTransaction",
+  SIGN_PASSKEY_CHALLENGE: "signPasskeyChallenge",
   GET_ACCOUNTS: "getAccounts",
   GET_CONNECTION_STATE: "getConnectionState",
   GET_SIGNING_CONTEXT: "getSigningContext",
   SELECT_ACCOUNT: "selectAccount",
   MANAGE_ACCOUNTS: "manageAccounts",
+  CREATE_SIGNING_SESSION: "createSigningSession",
+  CREATE_SIGNING_SESSION_INSTRUCTION: "createSigningSessionInstruction",
+  CONFIRM_SIGNING_SESSION: "confirmSigningSession",
+  REVOKE_SIGNING_SESSION: "revokeSigningSession",
 } as const;
 
 export type RequestType =
@@ -38,7 +44,7 @@ export const POST_MESSAGE_EVENT_TYPE = "event" as const;
 
 export const IFRAME_READY_EVENT = "iframe:ready" as const;
 
-export const DEFAULT_IFRAME_URL = "http://localhost:3000/embedded";
+export const DEFAULT_IFRAME_URL = "http://localhost:3010/embedded";
 
 const REQUEST_ID_PREFIX = "req";
 
@@ -62,6 +68,11 @@ export interface DisconnectRequestMessage extends BaseRequest {
   payload?: undefined;
 }
 
+export interface CreateAccountRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT;
+  payload: CreateAccountPayload;
+}
+
 export interface SignMessageRequestMessage extends BaseRequest {
   type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE;
   payload: SignMessagePayload;
@@ -72,6 +83,11 @@ export interface SignTransactionRequestMessage extends BaseRequest {
   payload: SignTransactionPayload;
 }
 
+export interface SignPasskeyChallengeRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE;
+  payload: SignPasskeyChallengePayload;
+}
+
 export interface GetAccountsRequestMessage extends BaseRequest {
   type: typeof POST_MESSAGE_REQUEST_TYPES.GET_ACCOUNTS;
   payload?: undefined;
@@ -97,21 +113,62 @@ export interface ManageAccountsRequestMessage extends BaseRequest {
   payload?: undefined;
 }
 
+export interface CreateSigningSessionRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION;
+  payload: CreateSigningSessionPayload;
+}
+
+export interface CreateSigningSessionInstructionRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION;
+  payload: CreateSigningSessionInstructionPayload;
+}
+
+export interface ConfirmSigningSessionRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION;
+  payload: ConfirmSigningSessionPayload;
+}
+
+export interface RevokeSigningSessionRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.REVOKE_SIGNING_SESSION;
+  payload: RevokeSigningSessionPayload;
+}
+
 export type PostMessageRequest =
   | ConnectRequestMessage
+  | CreateAccountRequestMessage
   | DisconnectRequestMessage
   | SignMessageRequestMessage
   | SignTransactionRequestMessage
+  | SignPasskeyChallengeRequestMessage
   | GetAccountsRequestMessage
   | GetConnectionStateRequestMessage
   | GetSigningContextRequestMessage
   | SelectAccountRequestMessage
-  | ManageAccountsRequestMessage;
+  | ManageAccountsRequestMessage
+  | CreateSigningSessionRequestMessage
+  | CreateSigningSessionInstructionRequestMessage
+  | ConfirmSigningSessionRequestMessage
+  | RevokeSigningSessionRequestMessage;
 
 export interface DisconnectResult {
   // Empty object keeps compatibility with existing consumers expecting a success payload
 }
 
+export interface CreateAccountPayload {
+  accountName?: string;
+  metadata?: ConnectMetadataInput;
+}
+
+export interface CreateAccountResult {
+  account: WalletAccount;
+  accounts: WalletAccount[];
+  selectedAccount: WalletAccount;
+  signature: string | null;
+  vmError: string | null;
+  userErrorCode: string | null;
+  executionResult: string | null;
+}
+
 export interface GetAccountsResult {
   accounts: WalletAccount[];
 }
@@ -142,14 +199,20 @@ export interface ManageAccountsResult {
 
 type RequestResultMap = {
   [POST_MESSAGE_REQUEST_TYPES.CONNECT]: ConnectResult;
+  [POST_MESSAGE_REQUEST_TYPES.CREATE_ACCOUNT]: CreateAccountResult;
   [POST_MESSAGE_REQUEST_TYPES.DISCONNECT]: DisconnectResult;
   [POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE]: SignMessageResult;
   [POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION]: SignTransactionResult;
+  [POST_MESSAGE_REQUEST_TYPES.SIGN_PASSKEY_CHALLENGE]: SignPasskeyChallengeResult;
   [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;
+  [POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION]: CreateSigningSessionResult;
+  [POST_MESSAGE_REQUEST_TYPES.CREATE_SIGNING_SESSION_INSTRUCTION]: CreateSigningSessionInstructionResult;
+  [POST_MESSAGE_REQUEST_TYPES.CONFIRM_SIGNING_SESSION]: ConfirmSigningSessionResult;
+  [POST_MESSAGE_REQUEST_TYPES.REVOKE_SIGNING_SESSION]: RevokeSigningSessionResult;
 };
 
 interface ResponseErrorPayload {
@@ -248,12 +311,74 @@ export interface SignTransactionPayload {
   readWriteAddresses?: string[];
   readOnlyAddresses?: string[];
   review?: TransactionReviewPayload;
+  signingSessionId?: string;
 }
 
 export interface SignTransactionResult {
   signedTransaction: string;
 }
 
+export interface SignPasskeyChallengePayload {
+  /** base64url-encoded challenge bytes from a backend passkey-manager flow. */
+  challenge: string;
+  /** Optional expected wallet address for the selected transparent account. */
+  walletAddress?: string;
+}
+
+export interface SignPasskeyChallengeResult {
+  signatureR: string;
+  signatureS: string;
+  authenticatorData: string;
+  clientDataJSON: string;
+}
+
+export interface CreateSigningSessionPayload {
+  walletAddress?: string;
+  expiresAt: string;
+  review?: TransactionReviewPayload;
+}
+
+export interface CreateSigningSessionInstructionPayload {
+  walletAddress?: string;
+  expiresAt: string;
+  walletAccountIdx: number;
+}
+
+export interface SigningSessionDescriptorPayload {
+  id: string;
+  walletAddress: string;
+  publicKey: string;
+  authIdx: number;
+  expiresAt: string;
+  createdAt: string;
+}
+
+export interface CreateSigningSessionResult {
+  session: SigningSessionDescriptorPayload;
+}
+
+export interface CreateSigningSessionInstructionResult {
+  session: SigningSessionDescriptorPayload;
+  programAddress: string;
+  instructionData: string;
+}
+
+export interface ConfirmSigningSessionPayload {
+  sessionId: string;
+}
+
+export interface ConfirmSigningSessionResult {
+  session: SigningSessionDescriptorPayload;
+}
+
+export interface RevokeSigningSessionPayload {
+  sessionId: string;
+}
+
+export interface RevokeSigningSessionResult {
+  // Empty object keeps compatibility with existing consumers expecting a success payload
+}
+
 export interface TransactionReviewSimulation {
   before?: string;
   after?: string;

package/src/provider/EmbeddedProvider.ts

@@ -20,10 +20,12 @@ import {
 } from '../protocol';
 import { IframeManager } from './IframeManager';
 import { EmbeddedThruChain } from './chains/ThruChain';
+import type { SigningSessionDescriptorStore } from '../signing-sessions';
 
 export interface EmbeddedProviderConfig {
   iframeUrl?: string;
   addressTypes?: AddressTypeValue[];
+  signingSessions?: SigningSessionDescriptorStore;
 }
 
 export interface ConnectOptions {
@@ -77,7 +79,11 @@ export class EmbeddedProvider {
     // Create chain instances
     const addressTypes = config.addressTypes || [AddressType.THRU];
     if (addressTypes.includes(AddressType.THRU)) {
-      this._thruChain = new EmbeddedThruChain(this.iframeManager, this);
+      this._thruChain = new EmbeddedThruChain(
+        this.iframeManager,
+        this,
+        config.signingSessions,
+      );
     }
   }
 

package/src/provider/IframeManager.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { IframeManager } from './IframeManager';
+
+describe('IframeManager', () => {
+  it('allows trusted production wallet origins', () => {
+    const thruBridge = new IframeManager('https://app.tid.sh/embedded');
+    const tidBridge = new IframeManager('https://wallet.tid.sh/embedded');
+
+    expect(thruBridge).toBeInstanceOf(IframeManager);
+    expect(tidBridge).toBeInstanceOf(IframeManager);
+  });
+
+  it('rejects untrusted production wallet origins', () => {
+    expect(
+      () => new IframeManager('https://evil.example.com/embedded')
+    ).toThrow(/Untrusted iframe origin/);
+  });
+});