@rhinestone/1auth 0.7.5 → 0.7.6

package/dist/index.d.ts

@@ -1,12 +1,13 @@
-import { O as OneAuthClient } from './client-C9mcj5jN.js';
+import { O as OneAuthClient } from './client-Dn6mL7BZ.js';
 import { Abi, Address, LocalAccount, WalletClient, Hash } from 'viem';
 import { Permission } from '@rhinestone/sdk';
 export { Permission } from '@rhinestone/sdk';
-import { h as IntentCall, i as SendIntentResult } from './types-CbhPRY5s.js';
-export { a7 as AssetBalance, a8 as AssetBalanceBucket, a9 as AssetsResponse, u as AuthFlow, A as AuthResult, v as AuthWithModalOptions, z as AuthenticateOptions, B as AuthenticateResult, R as BalanceRequirement, ap as BatchIntentItem, as as BatchIntentItemResult, ad as CheckConsentOptions, ae as CheckConsentResult, a0 as CloseOnStatus, y as ConnectResult, ac as ConsentData, ab as ConsentField, w as CreateAccountWithModalOptions, C as CreateCrossChainPermissionInput, r as CreateSigningRequestResponse, k as CrossChainPermit, l as CrossChainSettlementLayer, M as EIP712Domain, O as EIP712TypeField, N as EIP712Types, E as EmbedOptions, a2 as ExecuteIntentResponse, a6 as GetAssetsOptions, an as GrantPermissionContractMetadata, ah as GrantPermissionsOptions, ai as GrantPermissionsResult, a4 as IntentHistoryItem, a3 as IntentHistoryOptions, a5 as IntentHistoryResult, Z as IntentQuote, _ as IntentStatus, X as IntentTokenRequest, aj as ListSessionGrantsOptions, ak as ListSessionGrantsResult, L as LoginWithModalOptions, ax as OneAuthTelemetryAttributeValue, ay as OneAuthTelemetryAttributes, az as OneAuthTelemetryConfig, aA as OneAuthTelemetryEvent, aB as OneAuthTelemetryEventName, aC as OneAuthTelemetryFlow, aD as OneAuthTelemetryTraceContext, $ as OrchestratorStatus, t as PasskeyCredential, P as PasskeyProviderConfig, au as PrepareBatchIntentResponse, a1 as PrepareIntentResponse, at as PreparedBatchIntent, af as RequestConsentOptions, ag as RequestConsentResult, aq as SendBatchIntentOptions, ar as SendBatchIntentResult, Y as SendIntentOptions, am as SessionGrantChain, al as SessionGrantRecord, F as SignMessageOptions, G as SignMessageResult, J as SignTypedDataOptions, K as SignTypedDataResult, x as SignerType, p as SigningError, q as SigningErrorCode, m as SigningRequestOptions, s as SigningRequestStatus, n as SigningResult, D as SigningResultBase, o as SigningSuccess, ao as SmartSessionPolicy, av as SponsorshipCallbackConfig, S as SponsorshipConfig, aw as SponsorshipUrlConfig, aa as ThemeConfig, T as TransactionAction, V as TransactionDetails, Q as TransactionFees, U as UserPasskeysResponse, W as WebAuthnSignature, j as createCrossChainPermission } from './types-CbhPRY5s.js';
-export { O as OneAuthProvider, a as OneAuthProviderOptions, c as createOneAuthProvider } from './provider-CCyUBseo.js';
-import { P as PasskeyWalletClientConfig, S as SendCallsParams } from './verify-DPJR_foR.js';
-export { C as ChainFilterOptions, E as ETHEREUM_MESSAGE_PREFIX, p as TokenConfig, T as TransactionCall, e as encodeWebAuthnSignature, b as getAllSupportedChainsAndTokens, f as getChainById, i as getChainExplorerUrl, j as getChainRpcUrl, g as getSupportedChainIds, a as getSupportedChains, d as getSupportedTokenSymbols, c as getSupportedTokens, l as getTokenAddress, n as getTokenDecimals, m as getTokenSymbol, h as hashCalls, q as hashMessage, k as isTestnet, o as isTokenAddressSupported, r as resolveTokenAddress, v as verifyMessageHash } from './verify-DPJR_foR.js';
+import { P as PasskeyProviderConfig, C as CloseOnStatus, T as ThemeConfig, h as SignerType, i as IntentCall, j as SendIntentResult } from './types-Dzm5lZK-.js';
+export { a8 as AssetBalance, a9 as AssetBalanceBucket, aa as AssetsResponse, w as AuthFlow, A as AuthResult, x as AuthWithModalOptions, B as AuthenticateOptions, D as AuthenticateResult, X as BalanceRequirement, ap as BatchIntentItem, as as BatchIntentItemResult, ad as CheckConsentOptions, ae as CheckConsentResult, z as ConnectResult, ac as ConsentData, ab as ConsentField, y as CreateAccountWithModalOptions, l as CreateCrossChainPermissionInput, t as CreateSigningRequestResponse, m as CrossChainPermit, n as CrossChainSettlementLayer, N as EIP712Domain, Q as EIP712TypeField, O as EIP712Types, E as EmbedOptions, a3 as ExecuteIntentResponse, a7 as GetAssetsOptions, an as GrantPermissionContractMetadata, ah as GrantPermissionsOptions, ai as GrantPermissionsResult, a5 as IntentHistoryItem, a4 as IntentHistoryOptions, a6 as IntentHistoryResult, $ as IntentQuote, a0 as IntentStatus, Z as IntentTokenRequest, aj as ListSessionGrantsOptions, ak as ListSessionGrantsResult, L as LoginWithModalOptions, ax as OneAuthTelemetryAttributeValue, ay as OneAuthTelemetryAttributes, az as OneAuthTelemetryConfig, aA as OneAuthTelemetryEvent, aB as OneAuthTelemetryEventName, aC as OneAuthTelemetryFlow, aD as OneAuthTelemetryTraceContext, a1 as OrchestratorStatus, v as PasskeyCredential, au as PrepareBatchIntentResponse, a2 as PrepareIntentResponse, at as PreparedBatchIntent, af as RequestConsentOptions, ag as RequestConsentResult, aq as SendBatchIntentOptions, ar as SendBatchIntentResult, _ as SendIntentOptions, am as SessionGrantChain, al as SessionGrantRecord, G as SignMessageOptions, J as SignMessageResult, K as SignTypedDataOptions, M as SignTypedDataResult, r as SigningError, s as SigningErrorCode, o as SigningRequestOptions, u as SigningRequestStatus, p as SigningResult, F as SigningResultBase, q as SigningSuccess, ao as SmartSessionPolicy, av as SponsorshipCallbackConfig, S as SponsorshipConfig, aw as SponsorshipUrlConfig, R as TransactionAction, Y as TransactionDetails, V as TransactionFees, U as UserPasskeysResponse, W as WebAuthnSignature, k as createCrossChainPermission } from './types-Dzm5lZK-.js';
+import { O as OneAuthProvider } from './provider-BsVmPgkQ.js';
+export { a as OneAuthProviderOptions, c as createOneAuthProvider } from './provider-BsVmPgkQ.js';
+import { P as PasskeyWalletClientConfig, S as SendCallsParams } from './verify-9UgxLSdo.js';
+export { C as ChainFilterOptions, E as ETHEREUM_MESSAGE_PREFIX, p as TokenConfig, T as TransactionCall, e as encodeWebAuthnSignature, b as getAllSupportedChainsAndTokens, f as getChainById, i as getChainExplorerUrl, j as getChainRpcUrl, g as getSupportedChainIds, a as getSupportedChains, d as getSupportedTokenSymbols, c as getSupportedTokens, l as getTokenAddress, n as getTokenDecimals, m as getTokenSymbol, h as hashCalls, q as hashMessage, k as isTestnet, o as isTokenAddressSupported, r as resolveTokenAddress, v as verifyMessageHash } from './verify-9UgxLSdo.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 
@@ -67,6 +68,155 @@ interface DefinedPermissions<TAbi extends Abi = Abi> {
  */
 declare function definePermissions<const TAbi extends Abi>(config: DefinePermissionsConfig<TAbi>): DefinedPermissions<TAbi>;
 
+/**
+ * One-call connect entry point for 1auth.
+ *
+ * `createOneAuthConnection` is the ergonomic front door for integrators who
+ * want a single function that:
+ *   1. opens the 1auth dialog so the user picks **1auth passkey** *or* a
+ *      **traditional wallet** (WalletConnect / injected), and
+ *   2. hands back a ready-to-use EIP-1193 provider plus the connected
+ *      `{ address, signerType }`.
+ *
+ * When the user picks a traditional wallet (an EOA), the returned provider
+ * forwards `eth_sendTransaction` / `personal_sign` / `signTypedData` /
+ * `wallet_sendCalls` straight to that wallet's native RPC — **no Rhinestone
+ * intents**. When they pick a passkey, transactions route through 1auth intents
+ * exactly as before. The app writes one downstream code path either way.
+ *
+ * This is purely additive: `OneAuthClient.connect()` and
+ * `createOneAuthProvider()` are unchanged and remain the lower-level building
+ * blocks this factory composes.
+ *
+ * @module
+ */
+
+/**
+ * Provider-shaping options that apply on top of the passkey client config.
+ * Mirrors the relevant {@link createOneAuthProvider} options.
+ */
+interface OneAuthConnectionOptions {
+    /**
+     * Chain the returned provider reports via `eth_chainId` and uses as the
+     * default intent target. Defaults to `8453` (Base). Ignored for EOA sessions
+     * beyond the reported chain id — an EOA transacts on whatever chain its
+     * wallet is on.
+     */
+    defaultChainId?: number;
+    /**
+     * localStorage key the session is persisted under. Defaults to `"1auth-user"`.
+     * Override only to run multiple independent connections on one origin.
+     */
+    storageKey?: string;
+    /** Forwarded to the provider for passkey intent sends. */
+    closeOn?: CloseOnStatus;
+    waitForHash?: boolean;
+    hashTimeoutMs?: number;
+    hashIntervalMs?: number;
+    /**
+     * Opt in to offering a **traditional wallet as the account signer**. When
+     * `true`, the dialog's wallet path connects the chosen EOA as the signer (a
+     * `signerType: "eoa"` session whose transactions bypass Rhinestone intents).
+     *
+     * **Defaults to `false`** — by default the app gets 1auth smart accounts +
+     * intents, and the wallet path (if the user picks it) still bootstraps a
+     * passkey account. Passkey selection is unaffected either way. Can be
+     * overridden per call via {@link OneAuthConnectOptions.eoaConnect}.
+     */
+    eoaConnect?: boolean;
+}
+/** Full config form: constructs the client for you. Only `clientId` is practically required. */
+type OneAuthConnectionConfig = PasskeyProviderConfig & OneAuthConnectionOptions;
+/** Reuse form: bring your own configured {@link OneAuthClient}. */
+type OneAuthConnectionConfigWithClient = {
+    client: OneAuthClient;
+} & OneAuthConnectionOptions;
+/** Options accepted by {@link OneAuthConnection.connect}. */
+interface OneAuthConnectOptions {
+    theme?: ThemeConfig;
+    /** Applies only to the auth-modal fallback path (email/OAuth entry). */
+    oauthEnabled?: boolean;
+    /**
+     * Per-call override of {@link OneAuthConnectionOptions.eoaConnect}. Defaults
+     * to the connection's config value (which itself defaults to `false`).
+     */
+    eoaConnect?: boolean;
+}
+/**
+ * The resolved session. Discriminated on `signerType` so callers can branch on
+ * EOA vs passkey with full type safety.
+ */
+interface OneAuthSession {
+    /** `"eoa"` = traditional wallet (plain tx, no intents). `"passkey"` = 1auth smart account (intents). */
+    signerType: SignerType;
+    address: `0x${string}`;
+    /** The same {@link OneAuthProvider} instance exposed on the connection. */
+    provider: OneAuthProvider;
+    /** Chain id the provider reports (see {@link OneAuthConnectionOptions.defaultChainId}). */
+    chainId: number;
+    /** True when a returning user was reconnected with no visible UI. */
+    autoConnected: boolean;
+}
+/** Error thrown by {@link OneAuthConnection.connect} when the user cancels or auth fails. */
+interface OneAuthConnectError {
+    code: string;
+    message: string;
+}
+/** The handle returned by {@link createOneAuthConnection}. */
+interface OneAuthConnection {
+    /** The underlying client — escape hatch for `signMessage`, history, the account dialog, etc. */
+    client: OneAuthClient;
+    /** Ready-to-use EIP-1193 provider. Stable across reconnects. */
+    provider: OneAuthProvider;
+    /**
+     * Open the 1auth dialog so the user picks passkey OR a traditional wallet.
+     * Binds the resulting session to {@link OneAuthConnection.provider} before it
+     * resolves, so a send issued immediately after routes correctly.
+     *
+     * @throws {@link OneAuthConnectError} shape (`{ code, message }`) on cancel/failure.
+     */
+    connect: (options?: OneAuthConnectOptions) => Promise<OneAuthSession>;
+    /** Current session read from persisted state, or `null`. Never opens a dialog. */
+    getSession: () => OneAuthSession | null;
+    /** Clear the session and emit `accountsChanged([])` / `disconnect`. */
+    disconnect: () => Promise<void>;
+    /**
+     * Subscribe to session changes (connect/disconnect). Returns an unsubscribe
+     * function. Sugar over `provider.on("accountsChanged", …)`.
+     */
+    subscribe: (listener: (session: OneAuthSession | null) => void) => () => void;
+}
+/**
+ * Create a one-call 1auth connection.
+ *
+ * @example Zero-boilerplate
+ * ```typescript
+ * import { createOneAuthConnection } from "@rhinestone/1auth";
+ * import { createWalletClient, custom } from "viem";
+ * import { base } from "viem/chains";
+ *
+ * const conn = createOneAuthConnection({ clientId: "my-app" });
+ * const session = await conn.connect(); // user picks passkey OR wallet
+ *
+ * const walletClient = createWalletClient({
+ *   account: session.address,
+ *   chain: base,
+ *   transport: custom(session.provider),
+ * });
+ * // Same call for both signer types; EOA bypasses intents, passkey uses them.
+ * await walletClient.sendTransaction({ to: "0x…", value: 1n });
+ * ```
+ *
+ * @example Reuse an existing client
+ * ```typescript
+ * const client = new OneAuthClient({ clientId: "my-app", sponsorship });
+ * const conn = createOneAuthConnection({ client, defaultChainId: 8453 });
+ * const { address, signerType, provider } = await conn.connect();
+ * ```
+ */
+declare function createOneAuthConnection(config: OneAuthConnectionConfig): OneAuthConnection;
+declare function createOneAuthConnection(config: OneAuthConnectionConfigWithClient): OneAuthConnection;
+
 /**
  * viem LocalAccount adapter for 1auth passkey-controlled smart accounts.
  *
@@ -280,4 +430,4 @@ interface BatchQueueWidgetProps {
  */
 declare function BatchQueueWidget({ onSignAll }: BatchQueueWidgetProps): react_jsx_runtime.JSX.Element | null;
 
-export { type BatchQueueContextValue, type BatchQueueIdentity, BatchQueueProvider, type BatchQueueProviderProps, BatchQueueWidget, type BatchQueueWidgetProps, type BatchedCall, type DefinePermissionsConfig, type DefinedPermissions, IntentCall, OneAuthClient, type PasskeyAccount, type PasskeyWalletClient, PasskeyWalletClientConfig, SendCallsParams, SendIntentResult, createPasskeyAccount, createPasskeyWalletClient, definePermissions, getChainName, useBatchQueue };
+export { type BatchQueueContextValue, type BatchQueueIdentity, BatchQueueProvider, type BatchQueueProviderProps, BatchQueueWidget, type BatchQueueWidgetProps, type BatchedCall, CloseOnStatus, type DefinePermissionsConfig, type DefinedPermissions, IntentCall, OneAuthClient, type OneAuthConnectError, type OneAuthConnectOptions, type OneAuthConnection, type OneAuthConnectionConfig, type OneAuthConnectionConfigWithClient, type OneAuthConnectionOptions, OneAuthProvider, type OneAuthSession, type PasskeyAccount, PasskeyProviderConfig, type PasskeyWalletClient, PasskeyWalletClientConfig, SendCallsParams, SendIntentResult, SignerType, ThemeConfig, createOneAuthConnection, createPasskeyAccount, createPasskeyWalletClient, definePermissions, getChainName, useBatchQueue };

package/dist/index.js

@@ -35,6 +35,7 @@ __export(index_exports, {
   ETHEREUM_MESSAGE_PREFIX: () => ETHEREUM_MESSAGE_PREFIX,
   OneAuthClient: () => OneAuthClient,
   createCrossChainPermission: () => createCrossChainPermission,
+  createOneAuthConnection: () => createOneAuthConnection,
   createOneAuthProvider: () => createOneAuthProvider,
   createPasskeyAccount: () => createPasskeyAccount,
   createPasskeyWalletClient: () => createPasskeyWalletClient,
@@ -53,7 +54,7 @@ __export(index_exports, {
   getTokenDecimals: () => getTokenDecimals,
   getTokenSymbol: () => getTokenSymbol,
   hashCalls: () => hashCalls,
-  hashMessage: () => hashMessage2,
+  hashMessage: () => hashMessage,
   isTestnet: () => isTestnet,
   isTokenAddressSupported: () => isTokenAddressSupported,
   resolveTokenAddress: () => resolveTokenAddress,
@@ -1037,6 +1038,9 @@ var OneAuthClient = class {
     if (options?.oauthEnabled === false) {
       params.set("oauth", "0");
     }
+    if (options?.eoaConnect) {
+      params.set("eoaConnect", "1");
+    }
     if (options?.flow === "create-account") {
       params.set("switch", "1");
     }
@@ -1214,6 +1218,10 @@ var OneAuthClient = class {
           user: {
             address: authResult.user.address
           },
+          // Preserve the signer type from the auth modal — a wallet-picked
+          // (EOA) signup must not be silently normalized to "passkey", or the
+          // provider would route its transactions through intents.
+          signerType: authResult.signerType ?? "passkey",
           autoConnected: false
         };
       }
@@ -4876,6 +4884,7 @@ var OneAuthClient = class {
     iframe.setAttribute(
       "allow",
       [
+        "payment",
         `publickey-credentials-get ${hostUrl.origin}`,
         `publickey-credentials-create ${hostUrl.origin}`,
         "clipboard-write",
@@ -5150,6 +5159,10 @@ var OneAuthClient = class {
               user: {
                 address: data.data?.address
               },
+              // Carry the signer type through so the SDK/provider can route EOA
+              // sessions to the connected wallet (plain tx, no intents) instead
+              // of defaulting to passkey intents. Absent = legacy passkey.
+              signerType: data.data?.signerType ?? "passkey",
               autoConnected: data.data?.autoConnected
             });
           } else {
@@ -5593,12 +5606,14 @@ function createOneAuthProvider(options) {
   let chainId = options.chainId;
   const storageKey = options.storageKey || DEFAULT_STORAGE_KEY;
   const listeners = /* @__PURE__ */ new Map();
+  let sessionOverride;
   const emit = (event, ...args) => {
     const set = listeners.get(event);
     if (!set) return;
     for (const listener of set) listener(...args);
   };
   const getStoredUser = () => {
+    if (sessionOverride !== void 0) return sessionOverride;
     if (typeof window === "undefined") return null;
     try {
       const raw = localStorage.getItem(storageKey);
@@ -5638,10 +5653,28 @@ function createOneAuthProvider(options) {
     return [address];
   };
   const disconnect = async () => {
+    sessionOverride = void 0;
     clearStoredUser();
     emit("accountsChanged", []);
     emit("disconnect");
   };
+  const setSession = (session) => {
+    if (!session) {
+      sessionOverride = void 0;
+      clearStoredUser();
+      emit("accountsChanged", []);
+      emit("disconnect");
+      return;
+    }
+    sessionOverride = {
+      address: session.address,
+      signerType: session.signerType,
+      connectorId: session.connectorId
+    };
+    setStoredUser(sessionOverride);
+    emit("accountsChanged", [session.address]);
+    emit("connect", { chainId: (0, import_viem5.numberToHex)(chainId) });
+  };
   const ensureUser = async () => {
     const stored = getStoredUser();
     if (stored) return stored;
@@ -5851,10 +5884,49 @@ function createOneAuthProvider(options) {
     }
     return list;
   };
+  const eoaBatches = /* @__PURE__ */ new Map();
+  const sendCallsEoa = async (params, address) => {
+    const validated = injectEoaSigner("wallet_sendCalls", params, address);
+    const payload = Array.isArray(validated) ? validated[0] : {};
+    const calls = Array.isArray(payload.calls) ? payload.calls : [];
+    if (!calls.length) throw new Error("No calls provided");
+    const batchChainId = payload.chainId;
+    const hashes = [];
+    for (const raw of calls) {
+      const call = raw || {};
+      const tx = { from: address, to: call.to };
+      if (call.data !== void 0) tx.data = call.data;
+      if (call.value !== void 0) tx.value = call.value;
+      const callChain = call.chainId ?? batchChainId;
+      if (callChain !== void 0) tx.chainId = callChain;
+      const hash = await forwardToWallet("eth_sendTransaction", [tx], address);
+      hashes.push(String(hash));
+    }
+    const id = hashes[hashes.length - 1];
+    eoaBatches.set(id, hashes);
+    return id;
+  };
+  const getCallsStatusEoa = (callsId) => {
+    if (!callsId || typeof callsId !== "string") {
+      throw new Error("callsId is required");
+    }
+    const hashes = eoaBatches.get(callsId) ?? [callsId];
+    return {
+      status: "CONFIRMED",
+      receipts: hashes.map((transactionHash) => ({ transactionHash }))
+    };
+  };
   const request = async ({ method, params }) => {
     if (EOA_FORWARDED_METHODS.has(method)) {
       const user = await ensureUser();
       if (user.signerType === "eoa") {
+        if (method === "wallet_sendCalls") {
+          return sendCallsEoa(params, user.address);
+        }
+        if (method === "wallet_getCallsStatus") {
+          const list = Array.isArray(params) ? params : [];
+          return getCallsStatusEoa(list[0]);
+        }
         return forwardToWallet(
           method,
           injectEoaSigner(method, params, user.address),
@@ -6071,10 +6143,92 @@ function createOneAuthProvider(options) {
       set.delete(listener);
       if (set.size === 0) listeners.delete(event);
     },
-    disconnect
+    disconnect,
+    setSession
   };
 }
 
+// src/connection.ts
+var DEFAULT_CHAIN_ID = 8453;
+function readStoredSession(storageKey, provider, chainId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed?.address) return null;
+    return {
+      // Absent signerType = legacy passkey session (backwards compatible).
+      signerType: parsed.signerType === "eoa" ? "eoa" : "passkey",
+      address: parsed.address,
+      provider,
+      chainId,
+      autoConnected: false
+    };
+  } catch {
+    return null;
+  }
+}
+function createOneAuthConnection(config) {
+  const {
+    defaultChainId,
+    storageKey: storageKeyOption,
+    closeOn,
+    waitForHash,
+    hashTimeoutMs,
+    hashIntervalMs,
+    eoaConnect: eoaConnectConfig,
+    ...clientConfig
+  } = config;
+  const client = "client" in config && config.client ? config.client : new OneAuthClient(clientConfig);
+  const chainId = defaultChainId ?? DEFAULT_CHAIN_ID;
+  const storageKey = storageKeyOption ?? "1auth-user";
+  const provider = createOneAuthProvider({
+    client,
+    chainId,
+    storageKey,
+    closeOn,
+    waitForHash,
+    hashTimeoutMs,
+    hashIntervalMs
+  });
+  const getSession = () => readStoredSession(storageKey, provider, chainId);
+  const connect = async (options) => {
+    const eoaConnect = options?.eoaConnect ?? eoaConnectConfig ?? false;
+    const result = await client.connect({ ...options, eoaConnect });
+    if (!result.success || !result.user?.address) {
+      const error = result.error ?? {
+        code: "USER_CANCELLED",
+        message: "Connection was cancelled"
+      };
+      throw Object.assign(new Error(error.message), { code: error.code });
+    }
+    const signerType = result.signerType === "eoa" ? "eoa" : "passkey";
+    provider.setSession({ address: result.user.address, signerType });
+    return {
+      signerType,
+      address: result.user.address,
+      provider,
+      chainId,
+      autoConnected: result.autoConnected ?? false
+    };
+  };
+  const disconnect = async () => {
+    await provider.disconnect();
+  };
+  const subscribe = (listener) => {
+    const onAccountsChanged = (...args) => {
+      const accounts = args[0];
+      listener(
+        accounts && accounts.length > 0 ? getSession() : null
+      );
+    };
+    provider.on("accountsChanged", onAccountsChanged);
+    return () => provider.removeListener("accountsChanged", onAccountsChanged);
+  };
+  return { client, provider, connect, getSession, disconnect, subscribe };
+}
+
 // src/account.ts
 var import_viem6 = require("viem");
 var import_accounts = require("viem/accounts");
@@ -6152,6 +6306,10 @@ function createPasskeyAccount(client, params) {
 // src/walletClient/index.ts
 var import_viem7 = require("viem");
 var import_accounts2 = require("viem/accounts");
+function formatSignableMessage(message) {
+  if (typeof message === "string") return message;
+  return typeof message.raw === "string" ? message.raw : (0, import_viem7.toHex)(message.raw);
+}
 function createPasskeyWalletClient(config) {
   const identity = {
     accountAddress: config.accountAddress
@@ -6166,20 +6324,10 @@ function createPasskeyWalletClient(config) {
     sponsorship: config.sponsorship
   });
   const signMessageImpl = async (message) => {
-    const hash = (0, import_viem7.hashMessage)(message);
-    const result = await provider.signWithModal({
-      challenge: hash,
+    const result = await provider.signMessage({
       ...identity,
-      description: "Sign message",
-      transaction: {
-        actions: [
-          {
-            type: "custom",
-            label: "Sign Message",
-            sublabel: typeof message === "string" ? message.slice(0, 50) + (message.length > 50 ? "..." : "") : "Raw message"
-          }
-        ]
-      }
+      message: formatSignableMessage(message),
+      description: "Sign message"
     });
     if (!result.success) {
       throw new Error(result.error?.message || "Signing failed");
@@ -6768,14 +6916,14 @@ function BatchQueueWidget({ onSignAll }) {
 // src/verify.ts
 var import_viem8 = require("viem");
 var ETHEREUM_MESSAGE_PREFIX = "Ethereum Signed Message:\n";
-function hashMessage2(message) {
+function hashMessage(message) {
   const messageBytes = (0, import_viem8.toBytes)(message);
   const prefixed = ETHEREUM_MESSAGE_PREFIX + messageBytes.length.toString() + message;
   return (0, import_viem8.keccak256)((0, import_viem8.toBytes)(prefixed));
 }
 function verifyMessageHash(message, signedHash) {
   if (!signedHash) return false;
-  const expectedHash = hashMessage2(message);
+  const expectedHash = hashMessage(message);
   return expectedHash.toLowerCase() === signedHash.toLowerCase();
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -6785,6 +6933,7 @@ function verifyMessageHash(message, signedHash) {
   ETHEREUM_MESSAGE_PREFIX,
   OneAuthClient,
   createCrossChainPermission,
+  createOneAuthConnection,
   createOneAuthProvider,
   createPasskeyAccount,
   createPasskeyWalletClient,