@rhinestone/1auth 0.1.0 → 0.1.2

package/dist/{client-C1inywuT.d.ts → client-DyYGKWj3.d.ts}

@@ -8,13 +8,13 @@ interface ThemeConfig {
     accent?: string;
 }
 interface PasskeyProviderConfig {
-    /** Base URL of the auth API (Next.js server) */
-    providerUrl: string;
-    /** Client identifier for this application */
-    clientId: string;
+    /** Base URL of the auth API. Defaults to https://passkey.1auth.box */
+    providerUrl?: string;
+    /** Client identifier for this application (optional for development) */
+    clientId?: string;
     /** Optional redirect URL for redirect flow */
     redirectUrl?: string;
-    /** Optional URL of the dialog UI (Vite app). Defaults to providerUrl + /dialog */
+    /** Optional URL of the dialog UI. Defaults to providerUrl */
     dialogUrl?: string;
     /** Optional theme configuration for the dialog */
     theme?: ThemeConfig;
@@ -45,6 +45,22 @@ interface RegisterResult {
         message: string;
     };
 }
+/**
+ * Result of the connect modal (lightweight connection without passkey auth)
+ */
+interface ConnectResult {
+    success: boolean;
+    /** Username of the connected account */
+    username?: string;
+    /** Whether this was auto-connected (user had auto-connect enabled) */
+    autoConnected?: boolean;
+    /** Action to take when connection was not successful */
+    action?: "switch" | "cancel";
+    error?: {
+        code: string;
+        message: string;
+    };
+}
 /**
  * Options for the authenticate() method
  */
@@ -77,7 +93,7 @@ interface AuthenticateResult {
     signature?: WebAuthnSignature;
     /**
      * The hash that was actually signed (so apps can verify server-side).
-     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + challenge)
+     * Computed as: keccak256("\x19Ethereum Signed Message:\n" + len + challenge) (EIP-191)
      */
     signedHash?: `0x${string}`;
     error?: {
@@ -112,8 +128,8 @@ interface SignMessageResult {
     /** The message that was signed */
     signedMessage?: string;
     /**
-     * The hash that was actually signed (with domain separator).
-     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + message)
+     * The hash that was actually signed (EIP-191 format).
+     * Computed as: keccak256("\x19Ethereum Signed Message:\n" + len + message)
      * Use hashMessage() from the SDK to verify this matches your original message.
      */
     signedHash?: `0x${string}`;
@@ -186,8 +202,14 @@ interface PasskeyCredentials {
 interface SigningSuccess {
     success: true;
     requestId?: string;
-    signature: WebAuthnSignature;
+    /** WebAuthn signature - present for message/typedData signing */
+    signature?: WebAuthnSignature;
+    /** Array of signatures for multi-origin cross-chain intents (one per source chain) */
+    originSignatures?: WebAuthnSignature[];
+    /** Credentials of the passkey used for signing - present for message/typedData signing */
     passkey?: PasskeyCredentials;
+    /** Intent ID - present for intent signing (after execute in dialog) */
+    intentId?: string;
 }
 type SigningErrorCode = "USER_REJECTED" | "EXPIRED" | "INVALID_REQUEST" | "NETWORK_ERROR" | "POPUP_BLOCKED" | "SIGNING_FAILED" | "UNKNOWN";
 interface EmbedOptions {
@@ -242,19 +264,21 @@ interface IntentCall {
 interface IntentTokenRequest {
     /** Token contract address */
     token: string;
-    /** Amount (as string for serialization) */
-    amount: string;
+    /** Amount in base units (use parseUnits for decimals) */
+    amount: bigint;
 }
 /**
- * A signed intent request from a merchant backend
- * This provides XSS protection by ensuring calls were constructed server-side
+ * A signed intent request from a backend.
+ * This provides XSS protection by ensuring calls were constructed server-side.
  */
-interface MerchantSignedIntent {
-    /** Merchant ID (from seed/registration) */
-    merchantId: string;
+interface DeveloperSignedIntent {
+    /** Developer ID (clientId). Mapped to merchantId for the API. */
+    developerId?: string;
+    /** Wire field used by the API (same value as developerId) */
+    merchantId?: string;
     /** Target chain ID */
     targetChain: number;
-    /** Calls to execute (signed by merchant) */
+    /** Calls to execute (signed by developer) */
     calls: IntentCall[];
     /** Username of the signer */
     username?: string;
@@ -271,6 +295,16 @@ interface MerchantSignedIntent {
     /** Optional token requests */
     tokenRequests?: IntentTokenRequest[];
 }
+/** @deprecated Use DeveloperSignedIntent instead */
+type MerchantSignedIntent = DeveloperSignedIntent;
+type IntentSigner = (params: {
+    username: string;
+    accountAddress?: string;
+    targetChain: number;
+    calls: IntentCall[];
+    tokenRequests?: IntentTokenRequest[];
+    sourceAssets?: string[];
+}) => Promise<DeveloperSignedIntent>;
 /**
  * Options for sendIntent
  */
@@ -289,13 +323,19 @@ interface SendIntentOptions {
      * Example: ['USDC'] or ['0x...'] to only use USDC as input.
      */
     sourceAssets?: string[];
+    /**
+     * Source chain ID for the assets.
+     * When specified with sourceAssets containing addresses, tells orchestrator
+     * which chain to look for those tokens on.
+     */
+    sourceChainId?: number;
     /** When to close the dialog and return success. Defaults to "preconfirmed" */
     closeOn?: CloseOnStatus;
     /**
-     * Pre-signed intent from merchant backend (XSS protected)
+     * Pre-signed intent from developer backend (XSS protected)
      * If provided, username/targetChain/calls/tokenRequests are ignored
      */
-    signedIntent?: MerchantSignedIntent;
+    signedIntent?: DeveloperSignedIntent;
     /**
      * Wait for a transaction hash before resolving.
      * Defaults to false to preserve existing behavior.
@@ -329,7 +369,7 @@ interface IntentQuote {
 /**
  * Status of an intent (local states)
  */
-type IntentStatus = "pending" | "quoted" | "signed" | "submitted" | "completed" | "failed" | "expired";
+type IntentStatus = "pending" | "quoted" | "signed" | "submitted" | "claimed" | "preconfirmed" | "filled" | "completed" | "failed" | "expired" | "unknown";
 /**
  * Orchestrator status (from Rhinestone)
  * These are the statuses we can receive when polling
@@ -367,13 +407,25 @@ interface SendIntentResult {
  * Prepare intent response from auth service
  */
 interface PrepareIntentResponse {
-    intentId: string;
     quote: IntentQuote;
     transaction: TransactionDetails;
     challenge: string;
     expiresAt: string;
     /** Account address for the sign dialog to detect self-transfer vs external send */
     accountAddress?: string;
+    /** Serialized PreparedTransactionData from orchestrator - needed for execute */
+    intentOp: string;
+    /** User ID for creating intent record on execute */
+    userId: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** JSON stringified calls */
+    calls: string;
+    /** Origin message hashes for multi-source cross-chain intents */
+    originMessages?: Array<{
+        chainId: number;
+        messageHash: string;
+    }>;
 }
 /**
  * Execute intent response from auth service
@@ -384,6 +436,8 @@ interface ExecuteIntentResponse {
     operationId?: string;
     status: IntentStatus;
     transactionHash?: string;
+    /** Transaction result data needed for waiting via POST /api/intent/wait */
+    transactionResult?: unknown;
     error?: {
         code: string;
         message: string;
@@ -397,8 +451,8 @@ interface SendSwapOptions {
     username: string;
     /** Target chain ID where swap executes */
     targetChain: number;
-    /** Token to swap from (address or supported symbol like 'ETH', 'USDC') */
-    fromToken: string;
+    /** Token to swap from (address or supported symbol like 'ETH', 'USDC'). Omit to let the orchestrator pick. */
+    fromToken?: string;
     /** Token to swap to (address or supported symbol) */
     toToken: string;
     /** Amount to swap in human-readable format (e.g., "0.1") */
@@ -410,6 +464,11 @@ interface SendSwapOptions {
      * This constrains which tokens the orchestrator can use as input.
      */
     sourceAssets?: string[];
+    /**
+     * Source chain ID for the assets. When specified, the orchestrator will only
+     * look for source assets on this specific chain.
+     */
+    sourceChainId?: number;
     /** When to close the dialog. Defaults to "preconfirmed" */
     closeOn?: CloseOnStatus;
     /** Wait for a transaction hash before resolving. */
@@ -423,8 +482,8 @@ interface SendSwapOptions {
  * Quote information from DEX aggregator
  */
 interface SwapQuote {
-    /** Token being sold */
-    fromToken: string;
+    /** Token being sold (undefined when orchestrator picks) */
+    fromToken?: string;
     /** Token being bought */
     toToken: string;
     /** Amount of fromToken being sold */
@@ -509,8 +568,149 @@ interface SignTypedDataResult {
         message: string;
     };
 }
+/**
+ * Options for querying intent history
+ */
+interface IntentHistoryOptions {
+    /** Maximum number of intents to return (default: 50, max: 100) */
+    limit?: number;
+    /** Number of intents to skip for pagination */
+    offset?: number;
+    /** Filter by intent status */
+    status?: IntentStatus;
+    /** Filter by creation date (ISO string) - intents created on or after this date */
+    from?: string;
+    /** Filter by creation date (ISO string) - intents created on or before this date */
+    to?: string;
+}
+/**
+ * Single intent item in history response
+ */
+interface IntentHistoryItem {
+    /** Intent identifier (orchestrator's ID, used as primary key) */
+    intentId: string;
+    /** Current status of the intent */
+    status: IntentStatus;
+    /** Transaction hash (if completed) */
+    transactionHash?: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** Calls that were executed */
+    calls: IntentCall[];
+    /** When the intent was created (ISO string) */
+    createdAt: string;
+    /** When the intent was last updated (ISO string) */
+    updatedAt: string;
+}
+/**
+ * Result of getIntentHistory
+ */
+interface IntentHistoryResult {
+    /** List of intents */
+    intents: IntentHistoryItem[];
+    /** Total count of matching intents */
+    total: number;
+    /** Whether there are more intents beyond this page */
+    hasMore: boolean;
+}
+/**
+ * A single intent within a batch
+ */
+interface BatchIntentItem {
+    /** Target chain ID */
+    targetChain: number;
+    /** Calls to execute on the target chain */
+    calls: IntentCall[];
+    /** Optional token requests */
+    tokenRequests?: IntentTokenRequest[];
+    /** Constrain which tokens can be used as input */
+    sourceAssets?: string[];
+    /** Source chain ID for the assets */
+    sourceChainId?: number;
+}
+/**
+ * Options for sendBatchIntent
+ */
+interface SendBatchIntentOptions {
+    /** Username of the signer */
+    username: string;
+    /** Array of intents to execute as a batch */
+    intents: BatchIntentItem[];
+    /** When to close the dialog for each intent. Defaults to "preconfirmed" */
+    closeOn?: CloseOnStatus;
+}
+/**
+ * Result for a single intent within a batch
+ */
+interface BatchIntentItemResult {
+    /** Index in the original batch */
+    index: number;
+    /** Whether this intent succeeded */
+    success: boolean;
+    /** Intent ID from orchestrator */
+    intentId: string;
+    /** Current status */
+    status: IntentStatus;
+    /** Error details if failed */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Result of sendBatchIntent
+ */
+interface SendBatchIntentResult {
+    /** Whether ALL intents succeeded */
+    success: boolean;
+    /** Per-intent results */
+    results: BatchIntentItemResult[];
+    /** Count of successful intents */
+    successCount: number;
+    /** Count of failed intents */
+    failureCount: number;
+}
+/**
+ * Prepared intent data within a batch response
+ */
+interface PreparedBatchIntent {
+    /** Index in the original batch */
+    index: number;
+    /** Quote from orchestrator */
+    quote: IntentQuote;
+    /** Decoded transaction details for UI */
+    transaction: TransactionDetails;
+    /** Serialized PreparedTransactionData from orchestrator */
+    intentOp: string;
+    /** Expiry for this specific intent */
+    expiresAt: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** JSON stringified calls */
+    calls: string;
+    /** Origin message hashes for this intent */
+    originMessages: Array<{
+        chainId: number;
+        messageHash: string;
+    }>;
+}
+/**
+ * Prepare batch intent response from auth service
+ */
+interface PrepareBatchIntentResponse {
+    /** Per-intent prepared data */
+    intents: PreparedBatchIntent[];
+    /** Shared challenge (merkle root of ALL origin hashes across ALL intents) */
+    challenge: string;
+    /** User ID */
+    userId: string;
+    /** Account address */
+    accountAddress?: string;
+    /** Global expiry (earliest of all intent expiries) */
+    expiresAt: string;
+}
 
-declare class PasskeyProviderClient {
+declare class OneAuthClient {
     private config;
     private theme;
     constructor(config: PasskeyProviderConfig);
@@ -539,18 +739,41 @@ declare class PasskeyProviderClient {
     /**
      * Get the configured client ID
      */
-    getClientId(): string;
+    getClientId(): string | undefined;
     private waitForTransactionHash;
     /**
-     * Show Porto-style "Get started" auth dialog (combines sign in + sign up)
-     * This is the recommended method for authentication - shows a modal overlay
-     * with both sign in and create account options.
+     * Open the auth dialog (sign in + sign up).
      */
     authWithModal(options?: {
         username?: string;
         theme?: ThemeConfig;
         oauthEnabled?: boolean;
     }): Promise<LoginResult | RegisterResult>;
+    /**
+     * Open the connect dialog (lightweight connection without passkey auth).
+     *
+     * This method shows a simple connection confirmation dialog that doesn't
+     * require a passkey signature. Users can optionally enable "auto-connect"
+     * to skip this dialog in the future.
+     *
+     * If the user has never connected before, this will return action: "switch"
+     * to indicate that the full auth modal should be opened instead.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.connectWithModal();
+     *
+     * if (result.success) {
+     *   console.log('Connected as:', result.username);
+     * } else if (result.action === 'switch') {
+     *   // User needs to sign in first
+     *   const authResult = await client.authWithModal();
+     * }
+     * ```
+     */
+    connectWithModal(options?: {
+        theme?: ThemeConfig;
+    }): Promise<ConnectResult>;
     /**
      * Authenticate a user with an optional challenge to sign.
      *
@@ -587,7 +810,7 @@ declare class PasskeyProviderClient {
         theme?: ThemeConfig;
     }): Promise<AuthenticateResult>;
     /**
-     * Show signing in a modal overlay (Porto-style iframe dialog)
+     * Show signing in a modal overlay (iframe dialog)
      */
     signWithModal(options: SigningRequestOptions & {
         theme?: ThemeConfig;
@@ -622,6 +845,34 @@ declare class PasskeyProviderClient {
      * ```
      */
     sendIntent(options: SendIntentOptions): Promise<SendIntentResult>;
+    /**
+     * Send a batch of intents for multi-chain execution with a single passkey tap.
+     *
+     * This method prepares multiple intents, shows a paginated review,
+     * and signs all intents with a single passkey tap via a shared merkle tree.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendBatchIntent({
+     *   username: 'alice',
+     *   intents: [
+     *     {
+     *       targetChain: 8453, // Base
+     *       calls: [{ to: '0x...', data: '0x...', label: 'Swap on Base' }],
+     *     },
+     *     {
+     *       targetChain: 42161, // Arbitrum
+     *       calls: [{ to: '0x...', data: '0x...', label: 'Mint on Arbitrum' }],
+     *     },
+     *   ],
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`${result.successCount} intents submitted`);
+     * }
+     * ```
+     */
+    sendBatchIntent(options: SendBatchIntentOptions): Promise<SendBatchIntentResult>;
     /**
      * Send transaction status to the dialog iframe
      */
@@ -634,6 +885,11 @@ declare class PasskeyProviderClient {
      * Wait for signing result (simplified - no requestId matching)
      */
     private waitForSigningResponse;
+    /**
+     * Wait for signing result with auto-refresh support
+     * This method handles both signing results and quote refresh requests from the dialog
+     */
+    private waitForSigningWithRefresh;
     /**
      * Wait for the dialog to be closed
      */
@@ -645,6 +901,26 @@ declare class PasskeyProviderClient {
      * that hasn't completed yet.
      */
     getIntentStatus(intentId: string): Promise<SendIntentResult>;
+    /**
+     * Get the history of intents for the authenticated user.
+     *
+     * Requires an active session (user must be logged in).
+     *
+     * @example
+     * ```typescript
+     * // Get recent intents
+     * const history = await client.getIntentHistory({ limit: 10 });
+     *
+     * // Filter by status
+     * const pending = await client.getIntentHistory({ status: 'pending' });
+     *
+     * // Filter by date range
+     * const lastWeek = await client.getIntentHistory({
+     *   from: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+     * });
+     * ```
+     */
+    getIntentHistory(options?: IntentHistoryOptions): Promise<IntentHistoryResult>;
     /**
      * Send a swap intent through the Rhinestone orchestrator
      *
@@ -764,14 +1040,26 @@ declare class PasskeyProviderClient {
     private createSigningRequest;
     private openPopup;
     /**
-     * Create a modal dialog with an iframe inside (Porto-style overlay)
+     * Wait for the dialog iframe to signal ready, then send init data.
+     * Also handles early close (X button, escape, backdrop) during the ready phase.
+     * Returns true if dialog is ready, false if it was closed before becoming ready.
+     */
+    private waitForDialogReady;
+    /**
+     * Create a modal dialog with an iframe inside.
      */
     private createModalDialog;
     private waitForModalAuthResponse;
+    /**
+     * Open a popup for auth and wait for the result.
+     * Used when iframe mode fails (e.g., due to password manager interference).
+     */
+    private waitForPopupAuthResponse;
     private waitForAuthenticateResponse;
+    private waitForConnectResponse;
     private waitForModalSigningResponse;
     private waitForPopupResponse;
     private fetchSigningResult;
 }
 
-export { type AuthenticateOptions as A, type BalanceRequirement as B, type CreateSigningRequestResponse as C, type ExecuteIntentResponse as D, type EmbedOptions as E, type SendSwapOptions as F, type SendSwapResult as G, type SwapQuote as H, type IntentCall as I, type ThemeConfig as J, type LoginOptions as L, type MerchantSignedIntent as M, type OrchestratorStatus as O, PasskeyProviderClient as P, type RegisterOptions as R, type SendIntentResult as S, type TransactionAction as T, type UserPasskeysResponse as U, type WebAuthnSignature as W, type PasskeyProviderConfig as a, type SigningRequestOptions as b, type SigningResult as c, type SigningSuccess as d, type SigningError as e, type SigningErrorCode as f, type SigningRequestStatus as g, type PasskeyCredential as h, type RegisterResult as i, type LoginResult as j, type AuthenticateResult as k, type SignMessageOptions as l, type SignMessageResult as m, type SignTypedDataOptions as n, type SignTypedDataResult as o, type EIP712Domain as p, type EIP712Types as q, type EIP712TypeField as r, type TransactionFees as s, type TransactionDetails as t, type IntentTokenRequest as u, type SendIntentOptions as v, type IntentQuote as w, type IntentStatus as x, type CloseOnStatus as y, type PrepareIntentResponse as z };
+export { type TransactionAction as $, type AuthenticateOptions as A, type BalanceRequirement as B, type CloseOnStatus as C, type DeveloperSignedIntent as D, type EIP712Domain as E, type SendSwapOptions as F, type SendSwapResult as G, type SignMessageOptions as H, type IntentSigner as I, type SignMessageResult as J, type SignTypedDataOptions as K, type LoginOptions as L, type MerchantSignedIntent as M, type SignTypedDataResult as N, OneAuthClient as O, type PasskeyCredential as P, type SigningError as Q, type RegisterOptions as R, type SendIntentResult as S, type SigningErrorCode as T, type SigningRequestOptions as U, type SigningRequestStatus as V, type WebAuthnSignature as W, type SigningResult as X, type SigningSuccess as Y, type SwapQuote as Z, type ThemeConfig as _, type IntentCall as a, type TransactionDetails as a0, type TransactionFees as a1, type UserPasskeysResponse as a2, type AuthenticateResult as b, type BatchIntentItem as c, type BatchIntentItemResult as d, type ConnectResult as e, type CreateSigningRequestResponse as f, type EIP712TypeField as g, type EIP712Types as h, type EmbedOptions as i, type ExecuteIntentResponse as j, type IntentHistoryItem as k, type IntentHistoryOptions as l, type IntentHistoryResult as m, type IntentQuote as n, type IntentStatus as o, type IntentTokenRequest as p, type LoginResult as q, type OrchestratorStatus as r, type PasskeyProviderConfig as s, type PrepareBatchIntentResponse as t, type PrepareIntentResponse as u, type PreparedBatchIntent as v, type RegisterResult as w, type SendBatchIntentOptions as x, type SendBatchIntentResult as y, type SendIntentOptions as z };

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { P as PasskeyProviderClient, W as WebAuthnSignature, I as IntentCall, S as SendIntentResult } from './client-C1inywuT.mjs';
-export { A as AuthenticateOptions, k as AuthenticateResult, B as BalanceRequirement, y as CloseOnStatus, C as CreateSigningRequestResponse, p as EIP712Domain, r as EIP712TypeField, q as EIP712Types, E as EmbedOptions, D as ExecuteIntentResponse, w as IntentQuote, x as IntentStatus, u as IntentTokenRequest, L as LoginOptions, j as LoginResult, M as MerchantSignedIntent, O as OrchestratorStatus, h as PasskeyCredential, a as PasskeyProviderConfig, z as PrepareIntentResponse, R as RegisterOptions, i as RegisterResult, v as SendIntentOptions, F as SendSwapOptions, G as SendSwapResult, l as SignMessageOptions, m as SignMessageResult, n as SignTypedDataOptions, o as SignTypedDataResult, e as SigningError, f as SigningErrorCode, b as SigningRequestOptions, g as SigningRequestStatus, c as SigningResult, d as SigningSuccess, H as SwapQuote, J as ThemeConfig, T as TransactionAction, t as TransactionDetails, s as TransactionFees, U as UserPasskeysResponse } from './client-C1inywuT.mjs';
-export { P as PasskeyProvider, a as PasskeyProviderOptions, c as createPasskeyProvider } from './provider-Dgh51NRc.mjs';
-import { Address, LocalAccount, Chain, Transport, Hex, WalletClient, Hash } from 'viem';
+import { O as OneAuthClient, I as IntentSigner, W as WebAuthnSignature, a as IntentCall, S as SendIntentResult } from './client-DyYGKWj3.mjs';
+export { A as AuthenticateOptions, b as AuthenticateResult, B as BalanceRequirement, c as BatchIntentItem, d as BatchIntentItemResult, C as CloseOnStatus, e as ConnectResult, f as CreateSigningRequestResponse, D as DeveloperSignedIntent, E as EIP712Domain, g as EIP712TypeField, h as EIP712Types, i as EmbedOptions, j as ExecuteIntentResponse, k as IntentHistoryItem, l as IntentHistoryOptions, m as IntentHistoryResult, n as IntentQuote, o as IntentStatus, p as IntentTokenRequest, L as LoginOptions, q as LoginResult, M as MerchantSignedIntent, r as OrchestratorStatus, P as PasskeyCredential, s as PasskeyProviderConfig, t as PrepareBatchIntentResponse, u as PrepareIntentResponse, v as PreparedBatchIntent, R as RegisterOptions, w as RegisterResult, x as SendBatchIntentOptions, y as SendBatchIntentResult, z as SendIntentOptions, F as SendSwapOptions, G as SendSwapResult, H as SignMessageOptions, J as SignMessageResult, K as SignTypedDataOptions, N as SignTypedDataResult, Q as SigningError, T as SigningErrorCode, U as SigningRequestOptions, V as SigningRequestStatus, X as SigningResult, Y as SigningSuccess, Z as SwapQuote, _ as ThemeConfig, $ as TransactionAction, a0 as TransactionDetails, a1 as TransactionFees, a2 as UserPasskeysResponse } from './client-DyYGKWj3.mjs';
+export { O as OneAuthProvider, a as OneAuthProviderOptions, P as PasskeyProvider, b as PasskeyProviderOptions, c as createOneAuthProvider, d as createPasskeyProvider } from './provider-Ctr7HQHR.mjs';
+import { LocalAccount, Address, Hex, Chain, Transport, WalletClient, Hash } from 'viem';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 export { getTokenAddress, getTokenDecimals } from '@rhinestone/sdk';
@@ -9,7 +9,7 @@ export { getTokenAddress, getTokenDecimals } from '@rhinestone/sdk';
 type PasskeyAccount = LocalAccount<"1auth"> & {
     username: string;
 };
-declare function createPasskeyAccount(client: PasskeyProviderClient, params: {
+declare function createPasskeyAccount(client: OneAuthClient, params: {
     address: Address;
     username: string;
 }): PasskeyAccount;
@@ -22,12 +22,14 @@ interface PasskeyWalletClientConfig {
     accountAddress: Address;
     /** Username for the passkey provider */
     username: string;
-    /** Base URL of the auth API */
-    providerUrl: string;
+    /** Base URL of the auth API (defaults to https://passkey.1auth.box) */
+    providerUrl?: string;
     /** Client identifier for this application */
     clientId: string;
     /** Optional URL of the dialog UI */
     dialogUrl?: string;
+    /** Optional signer for developer-protected intents */
+    signIntent?: IntentSigner;
     /** Chain configuration */
     chain: Chain;
     /** Transport (e.g., http(), webSocket()) */
@@ -60,6 +62,13 @@ interface TransactionCall {
 interface SendCallsParams {
     /** Array of calls to execute */
     calls: TransactionCall[];
+    /** Optional chain id override */
+    chainId?: number;
+    /** Optional token requests for orchestrator output (what tokens/amounts to deliver) */
+    tokenRequests?: {
+        token: string;
+        amount: bigint;
+    }[];
 }
 
 /**
@@ -99,7 +108,7 @@ type PasskeyWalletClient = WalletClient & {
  * const walletClient = createPasskeyWalletClient({
  *   accountAddress: '0x...',
  *   username: 'alice',
- *   providerUrl: 'https://auth.example.com',
+ *   providerUrl: 'https://passkey.1auth.box',
  *   clientId: 'my-dapp',
  *   chain: baseSepolia,
  *   transport: http(),
@@ -170,8 +179,8 @@ interface BatchQueueContextValue {
  */
 declare function useBatchQueue(): BatchQueueContextValue;
 interface BatchQueueProviderProps {
-    /** The PasskeyProviderClient instance */
-    client: PasskeyProviderClient;
+    /** The OneAuthClient instance */
+    client: OneAuthClient;
     /** Optional username for localStorage persistence key */
     username?: string;
     /** Children to render */
@@ -219,18 +228,22 @@ declare function getTokenSymbol(tokenAddress: Address, chainId: number): string;
 declare function isTokenAddressSupported(tokenAddress: Address, chainId: number): boolean;
 
 /**
- * The domain separator prefix used for passkey message signing.
- * This ensures message signatures cannot be replayed for transaction signing.
+ * The EIP-191 prefix used for personal message signing.
+ * This is the standard Ethereum message prefix for `personal_sign`.
  */
-declare const PASSKEY_MESSAGE_PREFIX = "\u0019Passkey Signed Message:\n";
+declare const ETHEREUM_MESSAGE_PREFIX = "\u0019Ethereum Signed Message:\n";
 /**
- * Hash a message with the passkey domain separator.
+ * @deprecated Use ETHEREUM_MESSAGE_PREFIX instead. Kept for backwards compatibility.
+ */
+declare const PASSKEY_MESSAGE_PREFIX = "\u0019Ethereum Signed Message:\n";
+/**
+ * Hash a message with the EIP-191 Ethereum prefix.
  *
  * This is the same hashing function used by the passkey sign dialog.
  * Use this to verify that the `signedHash` returned from `signMessage()`
  * matches your original message.
  *
- * Format: keccak256("\x19Passkey Signed Message:\n" + len + message)
+ * Format: keccak256("\x19Ethereum Signed Message:\n" + len + message)
  *
  * @example
  * ```typescript
@@ -264,4 +277,4 @@ declare function hashMessage(message: string): `0x${string}`;
  */
 declare function verifyMessageHash(message: string, signedHash: string | undefined): boolean;
 
-export { type BatchQueueContextValue, BatchQueueProvider, type BatchQueueProviderProps, BatchQueueWidget, type BatchQueueWidgetProps, type BatchedCall, type ChainFilterOptions, IntentCall, PASSKEY_MESSAGE_PREFIX, type PasskeyAccount, PasskeyProviderClient, type PasskeyWalletClient, type PasskeyWalletClientConfig, type SendCallsParams, SendIntentResult, type TokenConfig, type TransactionCall, WebAuthnSignature, createPasskeyAccount, createPasskeyWalletClient, encodeWebAuthnSignature, getAllSupportedChainsAndTokens, getChainById, getChainExplorerUrl, getChainName, getChainRpcUrl, getSupportedChainIds, getSupportedChains, getSupportedTokenSymbols, getSupportedTokens, getTokenSymbol, hashCalls, hashMessage, isTestnet, isTokenAddressSupported, resolveTokenAddress, useBatchQueue, verifyMessageHash };
+export { type BatchQueueContextValue, BatchQueueProvider, type BatchQueueProviderProps, BatchQueueWidget, type BatchQueueWidgetProps, type BatchedCall, type ChainFilterOptions, ETHEREUM_MESSAGE_PREFIX, IntentCall, IntentSigner, OneAuthClient, PASSKEY_MESSAGE_PREFIX, type PasskeyAccount, OneAuthClient as PasskeyProviderClient, type PasskeyWalletClient, type PasskeyWalletClientConfig, type SendCallsParams, SendIntentResult, type TokenConfig, type TransactionCall, WebAuthnSignature, createPasskeyAccount, createPasskeyWalletClient, encodeWebAuthnSignature, getAllSupportedChainsAndTokens, getChainById, getChainExplorerUrl, getChainName, getChainRpcUrl, getSupportedChainIds, getSupportedChains, getSupportedTokenSymbols, getSupportedTokens, getTokenSymbol, hashCalls, hashMessage, isTestnet, isTokenAddressSupported, resolveTokenAddress, useBatchQueue, verifyMessageHash };