@thru/wallet 0.2.22

package/src/native/react/android-webauthn.ts

@@ -0,0 +1,37 @@
+/* Thin TypeScript shim over the Android Expo Module that wires
+ * react-native-webview to androidx.webkit's
+ * `setWebAuthnSupport`. On non-Android platforms (iOS, web)
+ * this is a no-op - WKWebView gets WebAuthn for free once the host
+ * declares `WKAppBoundDomains` (handled by our Expo config plugin). */
+
+import { Platform } from 'react-native';
+import { requireOptionalNativeModule } from 'expo-modules-core';
+
+/* `requireOptionalNativeModule` returns null when the module isn't
+ * linked (e.g. Expo Go without the dev client, or non-Android). */
+interface ThruWebViewBridgeNativeModule {
+  enableWebAuthnSupport: (viewTag?: number | null) => Promise<boolean>;
+}
+
+const Native = requireOptionalNativeModule(
+  'ThruWebViewBridge'
+) as ThruWebViewBridgeNativeModule | null;
+
+/**
+ * Tell the mounted WebView to route WebAuthn calls through Credential
+ * Manager. Returns true if the call landed, false on
+ * platforms where it isn't needed or supported.
+ *
+ * Idempotent; safe to call on every WebView mount.
+ */
+export async function enableWebAuthnSupport(viewTag?: number | null): Promise<boolean> {
+  if (Platform.OS !== 'android') return false; /* iOS / web: no-op. */
+  if (!Native) return false; /* Module not linked (Expo Go fallback). */
+  try {
+    return await Native.enableWebAuthnSupport(viewTag);
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.warn('[@thru/wallet/native/react] enableWebAuthnSupport failed:', err);
+    return false;
+  }
+}

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

@@ -0,0 +1,35 @@
+import { useEffect, useRef } from 'react';
+import type { WalletAccount } from "../../../interfaces";
+import { useThru } from './useThru';
+
+export interface UseAccountsOptions {
+  /** Fired whenever the active account flips (initial pick or switch). */
+  onAccountSelect?: (account: WalletAccount) => void;
+}
+
+/**
+ * useAccounts - mirror of @thru/wallet/react's useAccounts. Subscribes to
+ * `selectedAccount` flips and invokes the consumer's callback on real
+ * changes (deduped against the previous address).
+ */
+export function useAccounts({ onAccountSelect }: UseAccountsOptions = {}) {
+  const { accounts, selectedAccount, isConnected, isConnecting } = useThru();
+  const lastSeen = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!selectedAccount) {
+      lastSeen.current = null;
+      return;
+    }
+    if (lastSeen.current === selectedAccount.address) return;
+    lastSeen.current = selectedAccount.address;
+    onAccountSelect?.(selectedAccount);
+  }, [selectedAccount, onAccountSelect]);
+
+  return {
+    accounts,
+    selectedAccount,
+    isConnected,
+    isConnecting,
+  };
+}

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

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { ThruContext, type ThruContextValue } from '../ThruContext';
+
+/** Returns the full ThruContextValue. Throws if used outside <ThruProvider>. */
+export function useThru(): ThruContextValue {
+  const ctx = useContext(ThruContext);
+  if (!ctx) {
+    throw new Error('useThru must be used inside <ThruProvider>');
+  }
+  return ctx;
+}

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

@@ -0,0 +1,71 @@
+import { useCallback, useEffect, useRef } from 'react';
+import type { ConnectResult, IThruChain } from "../../../interfaces";
+import type { ConnectOptions, SignInOptions } from "../../NativeSDK";
+import { useThru } from './useThru';
+import { waitForWallet } from './waitForWallet';
+
+/**
+ * useWallet - mirror of @thru/wallet/react's useWallet. The `wallet` field
+ * exposes the chain interface (`provider.thru`); `connect` /
+ * `disconnect` proxy through the SDK.
+ */
+export function useWallet() {
+  const {
+    wallet,
+    isConnected,
+    isConnecting,
+    accounts,
+    selectedAccount,
+    selectAccount,
+    manageAccounts,
+    walletAvailability,
+  } = useThru();
+  const walletRef = useRef(wallet);
+
+  useEffect(() => {
+    walletRef.current = wallet;
+  }, [wallet]);
+
+  const connect = useCallback(async (options?: ConnectOptions): Promise<ConnectResult> => {
+    const ready =
+      walletRef.current ?? (await waitForWallet(() => walletRef.current));
+    return ready.connect(options);
+  }, []);
+
+  const signIn = useCallback(async (options: SignInOptions): Promise<ConnectResult> => {
+    const ready =
+      walletRef.current ?? (await waitForWallet(() => walletRef.current));
+    return ready.signIn(options);
+  }, []);
+
+  const disconnect = useCallback(async (): Promise<void> => {
+    const ready =
+      walletRef.current ?? (await waitForWallet(() => walletRef.current));
+    await ready.disconnect();
+  }, []);
+
+  const refreshWalletAvailability = useCallback(async (options?: ConnectOptions) => {
+    const ready =
+      walletRef.current ?? (await waitForWallet(() => walletRef.current));
+    return ready.refreshWalletAvailability(options);
+  }, []);
+
+  return {
+    /** Chain interface (`provider.thru`); undefined until connected. */
+    wallet: wallet?.thru as IThruChain | undefined,
+    accounts,
+    connect,
+    signIn,
+    disconnect,
+    isConnected: isConnected && !!wallet,
+    isConnecting,
+    selectedAccount,
+    selectAccount,
+    manageAccounts,
+    walletAvailability,
+    hasPasskey: walletAvailability.hasPasskey,
+    hasWalletAccount: walletAvailability.hasWalletAccount,
+    isWalletAvailabilityLoading: walletAvailability.status === 'checking',
+    refreshWalletAvailability,
+  };
+}

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

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from 'react';
+import type { ConnectOptions } from "../../NativeSDK";
+import { useThru } from './useThru';
+import { waitForWallet } from './waitForWallet';
+
+export function useWalletAvailability() {
+  const { wallet, walletAvailability } = useThru();
+  const walletRef = useRef(wallet);
+
+  useEffect(() => {
+    walletRef.current = wallet;
+  }, [wallet]);
+
+  const refreshWalletAvailability = async (options?: ConnectOptions) => {
+    const ready =
+      walletRef.current ?? (await waitForWallet(() => walletRef.current));
+    return ready.refreshWalletAvailability(options);
+  };
+
+  return {
+    walletAvailability,
+    refreshWalletAvailability,
+    hasPasskey: walletAvailability.hasPasskey,
+    hasWalletAccount: walletAvailability.hasWalletAccount,
+    isAuthorized: walletAvailability.isAuthorized,
+    isWalletAvailabilityLoading: walletAvailability.status === 'checking',
+    accounts: walletAvailability.accounts,
+    selectedAccount: walletAvailability.selectedAccount,
+    error: walletAvailability.error,
+  };
+}

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

@@ -0,0 +1,21 @@
+import type { NativeSDK } from "../../NativeSDK";
+
+/** Spin until the SDK exists or `timeout` ms passes. */
+export function waitForWallet(
+  getWallet: () => NativeSDK | null,
+  timeout = 5000,
+  interval = 100
+): Promise<NativeSDK> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      const sdk = getWallet();
+      if (sdk) return resolve(sdk);
+      if (Date.now() - start > timeout) {
+        return reject(new Error('NativeSDK not initialized in time'));
+      }
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}

package/src/native/react/index.ts

@@ -0,0 +1,29 @@
+export { ThruProvider } from './ThruProvider';
+export type { ThruProviderProps } from './ThruProvider';
+export { ThruContext } from './ThruContext';
+export type { ThruContextValue } from './ThruContext';
+
+export { ThruWalletSheet } from './ThruWalletSheet';
+export type {
+  ThruWalletSheetProps,
+  ThruWalletSheetHandle,
+} from './ThruWalletSheet';
+
+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,
+} from "../../interfaces";
+
+export type {
+  IosWebViewMode,
+  NativeSDKStorage,
+  WalletAvailability,
+} from "../NativeSDK";
+export type { ManageAccountsResult } from "../../protocol";

package/src/protocol/index.ts

@@ -0,0 +1,2 @@
+export * from './postMessage';
+export * from './walletState';

package/src/protocol/postMessage.ts

@@ -0,0 +1,283 @@
+import type {
+  AppMetadata,
+  ConnectResult,
+  ThruSigningContext,
+  WalletAccount,
+} from "../interfaces";
+
+export const POST_MESSAGE_REQUEST_TYPES = {
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  SIGN_MESSAGE: "signMessage",
+  SIGN_TRANSACTION: "signTransaction",
+  GET_ACCOUNTS: "getAccounts",
+  GET_CONNECTION_STATE: "getConnectionState",
+  GET_SIGNING_CONTEXT: "getSigningContext",
+  SELECT_ACCOUNT: "selectAccount",
+  MANAGE_ACCOUNTS: "manageAccounts",
+} as const;
+
+export type RequestType =
+  (typeof POST_MESSAGE_REQUEST_TYPES)[keyof typeof POST_MESSAGE_REQUEST_TYPES];
+
+export const EMBEDDED_PROVIDER_EVENTS = {
+  CONNECT_START: "connect_start",
+  CONNECT: "connect",
+  DISCONNECT: "disconnect",
+  CONNECT_ERROR: "connect_error",
+  ERROR: "error",
+  LOCK: "lock",
+  UI_SHOW: "ui_show",
+  ACCOUNT_CHANGED: "account_changed",
+} as const;
+
+export type EmbeddedProviderEvent =
+  (typeof EMBEDDED_PROVIDER_EVENTS)[keyof typeof EMBEDDED_PROVIDER_EVENTS];
+
+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";
+
+const REQUEST_ID_PREFIX = "req";
+
+export const createRequestId = (prefix: string = REQUEST_ID_PREFIX): string => {
+  const random = Math.random().toString(36).slice(2, 11);
+  return `${prefix}_${Date.now()}_${random}`;
+};
+
+interface BaseRequest {
+  id: string;
+  origin: string;
+}
+
+export interface ConnectRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.CONNECT;
+  payload: ConnectRequestPayload;
+}
+
+export interface DisconnectRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.DISCONNECT;
+  payload?: undefined;
+}
+
+export interface SignMessageRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_MESSAGE;
+  payload: SignMessagePayload;
+}
+
+export interface SignTransactionRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.SIGN_TRANSACTION;
+  payload: SignTransactionPayload;
+}
+
+export interface GetAccountsRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.GET_ACCOUNTS;
+  payload?: undefined;
+}
+
+export interface GetConnectionStateRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.GET_CONNECTION_STATE;
+  payload: ConnectRequestPayload;
+}
+
+export interface GetSigningContextRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.GET_SIGNING_CONTEXT;
+  payload?: undefined;
+}
+
+export interface SelectAccountRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.SELECT_ACCOUNT;
+  payload: SelectAccountPayload;
+}
+
+export interface ManageAccountsRequestMessage extends BaseRequest {
+  type: typeof POST_MESSAGE_REQUEST_TYPES.MANAGE_ACCOUNTS;
+  payload?: undefined;
+}
+
+export type PostMessageRequest =
+  | ConnectRequestMessage
+  | DisconnectRequestMessage
+  | SignMessageRequestMessage
+  | SignTransactionRequestMessage
+  | GetAccountsRequestMessage
+  | GetConnectionStateRequestMessage
+  | GetSigningContextRequestMessage
+  | SelectAccountRequestMessage
+  | ManageAccountsRequestMessage;
+
+export interface DisconnectResult {
+  // Empty object keeps compatibility with existing consumers expecting a success payload
+}
+
+export interface GetAccountsResult {
+  accounts: WalletAccount[];
+}
+
+export interface GetConnectionStateResult {
+  isAuthorized: boolean;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  hasPasskey: boolean;
+  hasWalletAccount: boolean;
+  accounts: WalletAccount[];
+  selectedAccount: WalletAccount | null;
+  metadata: AppMetadata | null;
+}
+
+export interface SelectAccountPayload {
+  publicKey: string;
+}
+
+export interface SelectAccountResult {
+  account: WalletAccount;
+}
+
+export 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;
+};
+
+export type PostMessageResponse<TType extends RequestType = RequestType> =
+  | SuccessResponse<TType>
+  | ErrorResponse;
+
+export type SuccessfulPostMessageResponse<
+  TType extends RequestType = RequestType,
+> = Extract<PostMessageResponse<TType>, { success: true }>;
+
+export type InferPostMessageResponse<TRequest extends PostMessageRequest> =
+  PostMessageResponse<TRequest["type"]>;
+
+export type InferSuccessfulPostMessageResponse<
+  TRequest extends PostMessageRequest,
+> = SuccessfulPostMessageResponse<TRequest["type"]>;
+
+export interface PostMessageEvent<
+  TEvent extends EmbeddedProviderEvent = EmbeddedProviderEvent,
+  TData = any,
+> {
+  type: typeof POST_MESSAGE_EVENT_TYPE;
+  event: TEvent;
+  data?: TData;
+}
+
+export const ErrorCode = {
+  USER_REJECTED: "USER_REJECTED",
+  WALLET_LOCKED: "WALLET_LOCKED",
+  INVALID_PASSWORD: "INVALID_PASSWORD",
+  ALREADY_CONNECTED: "ALREADY_CONNECTED",
+  ACCOUNT_NOT_FOUND: "ACCOUNT_NOT_FOUND",
+  ACCOUNT_CHANGED: "ACCOUNT_CHANGED",
+  INVALID_TRANSACTION: "INVALID_TRANSACTION",
+  TRANSACTION_FAILED: "TRANSACTION_FAILED",
+  INSUFFICIENT_FUNDS: "INSUFFICIENT_FUNDS",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT: "TIMEOUT",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+} as const;
+
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+export type ConnectMetadataInput = Partial<AppMetadata>;
+
+export type ConnectIntent = "default" | "switch-account";
+
+export interface ConnectRequestPayload {
+  metadata?: ConnectMetadataInput;
+  preferredAccountAddress?: string;
+  intent?: ConnectIntent;
+}
+
+export type { AppMetadata, ConnectResult };
+
+export interface SignMessagePayload {
+  message: string | number[];
+  accountIndex?: number;
+}
+
+export 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.
+ */
+export interface SignTransactionPayload {
+  walletAddress?: string;
+  programAddress: string;
+  instructionData: string;
+  readWriteAddresses?: string[];
+  readOnlyAddresses?: string[];
+  review?: TransactionReviewPayload;
+}
+
+export interface SignTransactionResult {
+  signedTransaction: string;
+}
+
+export interface TransactionReviewSimulation {
+  before?: string;
+  after?: string;
+}
+
+export interface TransactionReviewAbiReflection {
+  label?: string;
+  kind?: string | null;
+  typeName?: string;
+  value?: unknown;
+  rawHex?: string;
+  source?: string;
+  error?: string;
+}
+
+export interface TransactionReviewPayload {
+  appName?: string;
+  programAddress?: string;
+  abiName?: string;
+  instruction?: string;
+  simulation?: TransactionReviewSimulation;
+  abiReflection?: TransactionReviewAbiReflection;
+}
+
+export interface GetSigningContextResult {
+  signingContext: ThruSigningContext;
+}

package/src/protocol/walletState.ts

@@ -0,0 +1,12 @@
+import { normalizeWalletAccountResult } from "../interfaces";
+import type { GetConnectionStateResult } from "./postMessage";
+
+export function normalizeConnectionStateResult(
+  result: GetConnectionStateResult,
+): GetConnectionStateResult {
+  if (!result.isAuthorized || !result.hasPasskey) {
+    return { ...result, accounts: [], selectedAccount: null };
+  }
+
+  return normalizeWalletAccountResult(result);
+}