@rhinestone/1auth 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import {
   buildTransactionReview,
+  createOneAuthProvider,
   createPasskeyProvider,
   encodeWebAuthnSignature,
   getAllSupportedChainsAndTokens,
@@ -18,7 +19,7 @@ import {
   isTestnet,
   isTokenAddressSupported,
   resolveTokenAddress
-} from "./chunk-UXYKIMGZ.mjs";
+} from "./chunk-TACK3LJN.mjs";
 
 // src/client.ts
 import { parseUnits, hashTypedData } from "viem";
@@ -27,10 +28,13 @@ var POPUP_HEIGHT = 600;
 var DEFAULT_EMBED_WIDTH = "400px";
 var DEFAULT_EMBED_HEIGHT = "500px";
 var MODAL_WIDTH = 360;
-var PasskeyProviderClient = class {
+var DEFAULT_PROVIDER_URL = "https://passkey.1auth.box";
+var OneAuthClient = class {
   constructor(config) {
-    this.config = config;
-    this.theme = config.theme || {};
+    const providerUrl = config.providerUrl || DEFAULT_PROVIDER_URL;
+    const dialogUrl = config.dialogUrl || providerUrl;
+    this.config = { ...config, providerUrl, dialogUrl };
+    this.theme = this.config.theme || {};
   }
   /**
    * Update the theme configuration at runtime
@@ -92,9 +96,7 @@ var PasskeyProviderClient = class {
         const response = await fetch(
           `${this.config.providerUrl}/api/intent/status/${intentId}`,
           {
-            headers: {
-              "x-client-id": this.config.clientId
-            }
+            headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {}
           }
         );
         if (response.ok) {
@@ -113,16 +115,16 @@ var PasskeyProviderClient = class {
     return void 0;
   }
   /**
-   * 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).
    */
   async authWithModal(options) {
     const dialogUrl = this.getDialogUrl();
     const params = new URLSearchParams({
-      clientId: this.config.clientId,
       mode: "iframe"
     });
+    if (this.config.clientId) {
+      params.set("clientId", this.config.clientId);
+    }
     if (options?.username) {
       params.set("username", options.username);
     }
@@ -138,6 +140,55 @@ var PasskeyProviderClient = class {
     const { dialog, iframe, cleanup } = this.createModalDialog(url);
     return this.waitForModalAuthResponse(dialog, iframe, cleanup);
   }
+  /**
+   * 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();
+   * }
+   * ```
+   */
+  async connectWithModal(options) {
+    const dialogUrl = this.getDialogUrl();
+    const params = new URLSearchParams({
+      mode: "iframe"
+    });
+    if (this.config.clientId) {
+      params.set("clientId", this.config.clientId);
+    }
+    const themeParams = this.getThemeParams(options?.theme);
+    if (themeParams) {
+      const themeParsed = new URLSearchParams(themeParams);
+      themeParsed.forEach((value, key) => params.set(key, value));
+    }
+    const url = `${dialogUrl}/dialog/connect?${params.toString()}`;
+    const { dialog, iframe, cleanup } = this.createModalDialog(url);
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe"
+    });
+    if (!ready) {
+      return {
+        success: false,
+        action: "cancel",
+        error: { code: "USER_CANCELLED", message: "Connection was cancelled" }
+      };
+    }
+    return this.waitForConnectResponse(dialog, iframe, cleanup);
+  }
   /**
    * Authenticate a user with an optional challenge to sign.
    *
@@ -173,9 +224,11 @@ var PasskeyProviderClient = class {
   async authenticate(options) {
     const dialogUrl = this.getDialogUrl();
     const params = new URLSearchParams({
-      clientId: this.config.clientId,
       mode: "iframe"
     });
+    if (this.config.clientId) {
+      params.set("clientId", this.config.clientId);
+    }
     if (options?.challenge) {
       params.set("challenge", options.challenge);
     }
@@ -189,28 +242,30 @@ var PasskeyProviderClient = class {
     return this.waitForAuthenticateResponse(dialog, iframe, cleanup);
   }
   /**
-   * Show signing in a modal overlay (Porto-style iframe dialog)
+   * Show signing in a modal overlay (iframe dialog)
    */
   async signWithModal(options) {
     const dialogUrl = this.getDialogUrl();
     const themeParams = this.getThemeParams(options?.theme);
     const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe${themeParams ? `&${themeParams}` : ""}`;
     const { dialog, iframe, cleanup } = this.createModalDialog(signingUrl);
-    const dialogOrigin = this.getDialogOrigin();
-    await new Promise((resolve) => {
-      iframe.onload = () => {
-        iframe.contentWindow?.postMessage({
-          type: "PASSKEY_INIT",
-          mode: "iframe",
-          challenge: options.challenge,
-          username: options.username,
-          description: options.description,
-          transaction: options.transaction,
-          metadata: options.metadata
-        }, dialogOrigin);
-        resolve();
-      };
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe",
+      challenge: options.challenge,
+      username: options.username,
+      description: options.description,
+      transaction: options.transaction,
+      metadata: options.metadata
     });
+    if (!ready) {
+      return {
+        success: false,
+        error: {
+          code: "USER_REJECTED",
+          message: "User closed the dialog"
+        }
+      };
+    }
     return this.waitForSigningResponse(dialog, iframe, cleanup);
   }
   /**
@@ -243,10 +298,24 @@ var PasskeyProviderClient = class {
    * ```
    */
   async sendIntent(options) {
-    const signedIntent = options.signedIntent;
+    const signedIntent = options.signedIntent ? {
+      ...options.signedIntent,
+      merchantId: options.signedIntent.merchantId || options.signedIntent.developerId
+    } : void 0;
     const username = signedIntent?.username || options.username;
     const targetChain = signedIntent?.targetChain || options.targetChain;
     const calls = signedIntent?.calls || options.calls;
+    if (signedIntent && !signedIntent.merchantId) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "INVALID_OPTIONS",
+          message: "Signed intent requires developerId (clientId)"
+        }
+      };
+    }
     if (!username && !signedIntent?.accountAddress) {
       return {
         success: false,
@@ -269,16 +338,21 @@ var PasskeyProviderClient = class {
         }
       };
     }
+    const serializedTokenRequests = options.tokenRequests?.map((r) => ({
+      token: r.token,
+      amount: r.amount.toString()
+    }));
     let prepareResponse;
+    const requestBody = signedIntent || {
+      username: options.username,
+      targetChain: options.targetChain,
+      calls: options.calls,
+      tokenRequests: serializedTokenRequests,
+      sourceAssets: options.sourceAssets,
+      sourceChainId: options.sourceChainId,
+      ...this.config.clientId && { clientId: this.config.clientId }
+    };
     try {
-      const requestBody = signedIntent || {
-        username: options.username,
-        targetChain: options.targetChain,
-        calls: options.calls,
-        tokenRequests: options.tokenRequests,
-        sourceAssets: options.sourceAssets,
-        clientId: this.config.clientId
-      };
       const response = await fetch(`${this.config.providerUrl}/api/intent/prepare`, {
         method: "POST",
         headers: {
@@ -315,112 +389,190 @@ var PasskeyProviderClient = class {
       };
     }
     const dialogUrl = this.getDialogUrl();
-    const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe`;
+    const themeParams = this.getThemeParams();
+    const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe${themeParams ? `&${themeParams}` : ""}`;
     const { dialog, iframe, cleanup } = this.createModalDialog(signingUrl);
     const dialogOrigin = this.getDialogOrigin();
-    await new Promise((resolve) => {
-      const handleReady = (event) => {
-        if (event.origin !== dialogOrigin) return;
-        if (event.data?.type === "PASSKEY_READY") {
-          window.removeEventListener("message", handleReady);
-          iframe.contentWindow?.postMessage({
-            type: "PASSKEY_INIT",
-            mode: "iframe",
-            calls,
-            chainId: targetChain,
-            transaction: prepareResponse.transaction,
-            challenge: prepareResponse.challenge,
-            username,
-            accountAddress: prepareResponse.accountAddress,
-            intentId: prepareResponse.intentId
-          }, dialogOrigin);
-          resolve();
-        }
-      };
-      window.addEventListener("message", handleReady);
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe",
+      calls,
+      chainId: targetChain,
+      transaction: prepareResponse.transaction,
+      challenge: prepareResponse.challenge,
+      username,
+      accountAddress: prepareResponse.accountAddress,
+      originMessages: prepareResponse.originMessages,
+      tokenRequests: serializedTokenRequests,
+      expiresAt: prepareResponse.expiresAt,
+      userId: prepareResponse.userId,
+      intentOp: prepareResponse.intentOp
     });
-    const signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
+    if (!ready) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: { code: "USER_CANCELLED", message: "User closed the dialog" }
+      };
+    }
+    const signingResult = await this.waitForSigningWithRefresh(
+      dialog,
+      iframe,
+      cleanup,
+      dialogOrigin,
+      // Refresh callback - called when dialog requests a quote refresh
+      async () => {
+        console.log("[SDK] Dialog requested quote refresh, re-preparing intent");
+        try {
+          const refreshResponse = await fetch(`${this.config.providerUrl}/api/intent/prepare`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(requestBody),
+            credentials: "include"
+          });
+          if (!refreshResponse.ok) {
+            console.error("[SDK] Quote refresh failed:", await refreshResponse.text());
+            return null;
+          }
+          const refreshedData = await refreshResponse.json();
+          prepareResponse = refreshedData;
+          return {
+            intentOp: refreshedData.intentOp,
+            expiresAt: refreshedData.expiresAt,
+            challenge: refreshedData.challenge,
+            originMessages: refreshedData.originMessages,
+            transaction: refreshedData.transaction
+          };
+        } catch (error) {
+          console.error("[SDK] Quote refresh error:", error);
+          return null;
+        }
+      }
+    );
     if (!signingResult.success) {
       return {
         success: false,
-        intentId: prepareResponse.intentId,
+        intentId: "",
+        // No intentId yet - signing was cancelled before execute
         status: "failed",
         error: signingResult.error
       };
     }
+    const dialogExecutedIntent = "intentId" in signingResult && signingResult.intentId;
     let executeResponse;
-    try {
-      const response = await fetch(`${this.config.providerUrl}/api/intent/execute`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          intentId: prepareResponse.intentId,
-          signature: signingResult.signature,
-          passkey: signingResult.passkey
-          // Include passkey info for signature encoding
-        })
-      });
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
+    if (dialogExecutedIntent) {
+      executeResponse = {
+        success: true,
+        intentId: signingResult.intentId,
+        status: "pending"
+      };
+    } else {
+      try {
+        const response = await fetch(`${this.config.providerUrl}/api/intent/execute`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            // Data from prepare response (no intentId yet - created on execute)
+            intentOp: prepareResponse.intentOp,
+            userId: prepareResponse.userId,
+            targetChain: prepareResponse.targetChain,
+            calls: prepareResponse.calls,
+            expiresAt: prepareResponse.expiresAt,
+            // Signature from dialog
+            signature: signingResult.signature,
+            passkey: signingResult.passkey
+            // Include passkey info for signature encoding
+          })
+        });
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          this.sendTransactionStatus(iframe, "failed");
+          await this.waitForDialogClose(dialog, cleanup);
+          return {
+            success: false,
+            intentId: "",
+            // No intentId - execute failed before creation
+            status: "failed",
+            error: {
+              code: "EXECUTE_FAILED",
+              message: errorData.error || "Failed to execute intent"
+            }
+          };
+        }
+        executeResponse = await response.json();
+      } catch (error) {
         this.sendTransactionStatus(iframe, "failed");
         await this.waitForDialogClose(dialog, cleanup);
         return {
           success: false,
-          intentId: prepareResponse.intentId,
+          intentId: "",
+          // No intentId - network error before creation
           status: "failed",
           error: {
-            code: "EXECUTE_FAILED",
-            message: errorData.error || "Failed to execute intent"
+            code: "NETWORK_ERROR",
+            message: error instanceof Error ? error.message : "Network error"
           }
         };
       }
-      executeResponse = await response.json();
-    } catch (error) {
-      this.sendTransactionStatus(iframe, "failed");
-      await this.waitForDialogClose(dialog, cleanup);
-      return {
-        success: false,
-        intentId: prepareResponse.intentId,
-        status: "failed",
-        error: {
-          code: "NETWORK_ERROR",
-          message: error instanceof Error ? error.message : "Network error"
-        }
-      };
     }
-    const closeOn = options.closeOn || "preconfirmed";
-    const acceptPreconfirmations = closeOn !== "completed";
     let finalStatus = executeResponse.status;
     let finalTxHash = executeResponse.transactionHash;
     if (finalStatus === "pending") {
-      this.sendTransactionStatus(iframe, "processing");
-      try {
-        const waitResponse = await fetch(
-          `${this.config.providerUrl}/api/intent/wait/${prepareResponse.intentId}?preconfirm=${acceptPreconfirmations}`,
-          {
-            headers: {
-              "x-client-id": this.config.clientId
+      this.sendTransactionStatus(iframe, "pending");
+      const maxAttempts = 120;
+      const pollIntervalMs = 1500;
+      let lastStatus = "pending";
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          const statusResponse = await fetch(
+            `${this.config.providerUrl}/api/intent/status/${executeResponse.intentId}`,
+            {
+              method: "GET",
+              headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {}
+            }
+          );
+          if (statusResponse.ok) {
+            const statusResult = await statusResponse.json();
+            finalStatus = statusResult.status;
+            finalTxHash = statusResult.transactionHash;
+            if (finalStatus !== lastStatus) {
+              this.sendTransactionStatus(iframe, finalStatus, finalTxHash);
+              lastStatus = finalStatus;
+            }
+            const closeOn2 = options.closeOn || "preconfirmed";
+            const successStatuses2 = {
+              claimed: ["claimed", "preconfirmed", "filled", "completed"],
+              preconfirmed: ["preconfirmed", "filled", "completed"],
+              filled: ["filled", "completed"],
+              completed: ["completed"]
+            };
+            const isTerminal = finalStatus === "failed" || finalStatus === "expired";
+            const isSuccess = successStatuses2[closeOn2]?.includes(finalStatus) ?? false;
+            if (isTerminal || isSuccess) {
+              break;
             }
           }
-        );
-        if (waitResponse.ok) {
-          const waitResult = await waitResponse.json();
-          finalStatus = waitResult.status === "preconfirmed" || waitResult.status === "completed" ? "completed" : waitResult.status;
-          finalTxHash = waitResult.transactionHash;
-        } else {
-          console.error("Wait endpoint failed:", await waitResponse.text());
+        } catch (pollError) {
+          console.error("Failed to poll intent status:", pollError);
         }
-      } catch (waitError) {
-        console.error("Failed to wait for intent:", waitError);
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
       }
     }
-    const displayStatus = finalStatus === "completed" ? "confirmed" : finalStatus;
+    const closeOn = options.closeOn || "preconfirmed";
+    const successStatuses = {
+      claimed: ["claimed", "preconfirmed", "filled", "completed"],
+      preconfirmed: ["preconfirmed", "filled", "completed"],
+      filled: ["filled", "completed"],
+      completed: ["completed"]
+    };
+    const isSuccessStatus = successStatuses[closeOn]?.includes(finalStatus) ?? false;
+    const displayStatus = isSuccessStatus ? "confirmed" : finalStatus;
     this.sendTransactionStatus(iframe, displayStatus, finalTxHash);
     await this.waitForDialogClose(dialog, cleanup);
     if (options.waitForHash && !finalTxHash) {
-      const hash = await this.waitForTransactionHash(prepareResponse.intentId, {
+      const hash = await this.waitForTransactionHash(executeResponse.intentId, {
         timeoutMs: options.hashTimeoutMs,
         intervalMs: options.hashIntervalMs
       });
@@ -431,7 +583,7 @@ var PasskeyProviderClient = class {
         finalStatus = "failed";
         return {
           success: false,
-          intentId: prepareResponse.intentId,
+          intentId: executeResponse.intentId,
           status: finalStatus,
           transactionHash: finalTxHash,
           operationId: executeResponse.operationId,
@@ -443,14 +595,204 @@ var PasskeyProviderClient = class {
       }
     }
     return {
-      success: finalStatus === "completed",
-      intentId: prepareResponse.intentId,
+      success: isSuccessStatus,
+      intentId: executeResponse.intentId,
       status: finalStatus,
       transactionHash: finalTxHash,
       operationId: executeResponse.operationId,
       error: executeResponse.error
     };
   }
+  /**
+   * 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`);
+   * }
+   * ```
+   */
+  async sendBatchIntent(options) {
+    if (!options.username) {
+      return {
+        success: false,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+    }
+    if (!options.intents?.length) {
+      return {
+        success: false,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+    }
+    const serializedIntents = options.intents.map((intent) => ({
+      targetChain: intent.targetChain,
+      calls: intent.calls,
+      tokenRequests: intent.tokenRequests?.map((r) => ({
+        token: r.token,
+        amount: r.amount.toString()
+      })),
+      sourceAssets: intent.sourceAssets,
+      sourceChainId: intent.sourceChainId
+    }));
+    const requestBody = {
+      username: options.username,
+      intents: serializedIntents,
+      ...this.config.clientId && { clientId: this.config.clientId }
+    };
+    let prepareResponse;
+    try {
+      const response = await fetch(`${this.config.providerUrl}/api/intent/batch-prepare`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errorMessage = errorData.error || "Failed to prepare batch intent";
+        if (errorMessage.includes("User not found")) {
+          localStorage.removeItem("1auth-user");
+        }
+        return {
+          success: false,
+          results: [],
+          successCount: 0,
+          failureCount: 0
+        };
+      }
+      prepareResponse = await response.json();
+    } catch {
+      return {
+        success: false,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+    }
+    const dialogUrl = this.getDialogUrl();
+    const themeParams = this.getThemeParams();
+    const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe${themeParams ? `&${themeParams}` : ""}`;
+    const { dialog, iframe, cleanup } = this.createModalDialog(signingUrl);
+    const dialogOrigin = this.getDialogOrigin();
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe",
+      batchMode: true,
+      batchIntents: prepareResponse.intents,
+      challenge: prepareResponse.challenge,
+      username: options.username,
+      accountAddress: prepareResponse.accountAddress,
+      userId: prepareResponse.userId,
+      expiresAt: prepareResponse.expiresAt
+    });
+    if (!ready) {
+      return {
+        success: false,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+    }
+    const batchResult = await new Promise((resolve) => {
+      const handleMessage = async (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const message = event.data;
+        if (message?.type === "PASSKEY_REFRESH_QUOTE") {
+          console.log("[SDK] Batch dialog requested quote refresh, re-preparing all intents");
+          try {
+            const refreshResponse = await fetch(`${this.config.providerUrl}/api/intent/batch-prepare`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(requestBody)
+            });
+            if (refreshResponse.ok) {
+              const refreshed = await refreshResponse.json();
+              prepareResponse = refreshed;
+              iframe.contentWindow?.postMessage({
+                type: "PASSKEY_REFRESH_COMPLETE",
+                batchIntents: refreshed.intents,
+                challenge: refreshed.challenge,
+                expiresAt: refreshed.expiresAt
+              }, dialogOrigin);
+            } else {
+              iframe.contentWindow?.postMessage({
+                type: "PASSKEY_REFRESH_ERROR",
+                error: "Failed to refresh batch quotes"
+              }, dialogOrigin);
+            }
+          } catch {
+            iframe.contentWindow?.postMessage({
+              type: "PASSKEY_REFRESH_ERROR",
+              error: "Failed to refresh batch quotes"
+            }, dialogOrigin);
+          }
+          return;
+        }
+        if (message?.type === "PASSKEY_SIGNING_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          if (message.success && message.data?.batchResults) {
+            const rawResults = message.data.batchResults;
+            const results = rawResults.map((r) => ({
+              index: r.index,
+              success: r.success ?? r.status !== "FAILED",
+              intentId: r.intentId || r.operationId || "",
+              status: r.status === "FAILED" ? "failed" : "pending",
+              error: r.error ? { code: "EXECUTE_FAILED", message: r.error } : void 0
+            }));
+            const successCount = results.filter((r) => r.success).length;
+            await this.waitForDialogClose(dialog, cleanup);
+            resolve({
+              success: successCount === results.length,
+              results,
+              successCount,
+              failureCount: results.length - successCount
+            });
+          } else {
+            cleanup();
+            resolve({
+              success: false,
+              results: [],
+              successCount: 0,
+              failureCount: 0
+            });
+          }
+        }
+        if (message?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve({
+            success: false,
+            results: [],
+            successCount: 0,
+            failureCount: 0
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+    return batchResult;
+  }
   /**
    * Send transaction status to the dialog iframe
    */
@@ -527,7 +869,77 @@ var PasskeyProviderClient = class {
         const payload = message?.data;
         if (message?.type === "PASSKEY_SIGNING_RESULT") {
           window.removeEventListener("message", handleMessage);
-          if (message.success && payload?.signature) {
+          if (message.success && payload?.intentId) {
+            resolve({
+              success: true,
+              intentId: payload.intentId
+            });
+          } else if (message.success && payload?.signature) {
+            resolve({
+              success: true,
+              signature: payload.signature,
+              passkey: payload.passkey,
+              signedHash: payload.signedHash
+            });
+          } else {
+            resolve({
+              success: false,
+              error: message.error || {
+                code: "SIGNING_FAILED",
+                message: "Signing failed"
+              }
+            });
+          }
+        } else if (message?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve({
+            success: false,
+            error: {
+              code: "USER_REJECTED",
+              message: "User closed the dialog"
+            }
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
+  /**
+   * Wait for signing result with auto-refresh support
+   * This method handles both signing results and quote refresh requests from the dialog
+   */
+  waitForSigningWithRefresh(dialog, iframe, cleanup, dialogOrigin, onRefresh) {
+    console.log("[SDK] waitForSigningWithRefresh, expecting origin:", dialogOrigin);
+    return new Promise((resolve) => {
+      const handleMessage = async (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const message = event.data;
+        if (message?.type === "PASSKEY_REFRESH_QUOTE") {
+          console.log("[SDK] Received quote refresh request from dialog");
+          const refreshedData = await onRefresh();
+          if (refreshedData) {
+            iframe.contentWindow?.postMessage({
+              type: "PASSKEY_REFRESH_COMPLETE",
+              ...refreshedData
+            }, dialogOrigin);
+          } else {
+            iframe.contentWindow?.postMessage({
+              type: "PASSKEY_REFRESH_ERROR",
+              error: "Failed to refresh quote"
+            }, dialogOrigin);
+          }
+          return;
+        }
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          if (message.success && payload?.intentId) {
+            resolve({
+              success: true,
+              intentId: payload.intentId
+            });
+          } else if (message.success && payload?.signature) {
             resolve({
               success: true,
               signature: payload.signature,
@@ -593,9 +1005,7 @@ var PasskeyProviderClient = class {
       const response = await fetch(
         `${this.config.providerUrl}/api/intent/status/${intentId}`,
         {
-          headers: {
-            "x-client-id": this.config.clientId
-          }
+          headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {}
         }
       );
       if (!response.ok) {
@@ -630,6 +1040,43 @@ var PasskeyProviderClient = class {
       };
     }
   }
+  /**
+   * 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(),
+   * });
+   * ```
+   */
+  async getIntentHistory(options) {
+    const queryParams = new URLSearchParams();
+    if (options?.limit) queryParams.set("limit", String(options.limit));
+    if (options?.offset) queryParams.set("offset", String(options.offset));
+    if (options?.status) queryParams.set("status", options.status);
+    if (options?.from) queryParams.set("from", options.from);
+    if (options?.to) queryParams.set("to", options.to);
+    const url = `${this.config.providerUrl}/api/intent/history${queryParams.toString() ? `?${queryParams}` : ""}`;
+    const response = await fetch(url, {
+      headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {},
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || "Failed to get intent history");
+    }
+    return response.json();
+  }
   /**
    * Send a swap intent through the Rhinestone orchestrator
    *
@@ -692,17 +1139,21 @@ var PasskeyProviderClient = class {
         };
       }
     };
-    const fromTokenResult = resolveToken(options.fromToken, "fromToken");
-    if (!fromTokenResult.address) {
-      return {
-        success: false,
-        intentId: "",
-        status: "failed",
-        error: {
-          code: "INVALID_TOKEN",
-          message: fromTokenResult.error || `Unknown fromToken: ${options.fromToken}`
-        }
-      };
+    let fromTokenAddress;
+    if (options.fromToken) {
+      const fromTokenResult = resolveToken(options.fromToken, "fromToken");
+      if (!fromTokenResult.address) {
+        return {
+          success: false,
+          intentId: "",
+          status: "failed",
+          error: {
+            code: "INVALID_TOKEN",
+            message: fromTokenResult.error || `Unknown fromToken: ${options.fromToken}`
+          }
+        };
+      }
+      fromTokenAddress = fromTokenResult.address;
     }
     const toTokenResult = resolveToken(options.toToken, "toToken");
     if (!toTokenResult.address) {
@@ -716,18 +1167,17 @@ var PasskeyProviderClient = class {
         }
       };
     }
-    const fromTokenAddress = fromTokenResult.address;
     const toTokenAddress = toTokenResult.address;
     console.log("[SDK sendSwap] Token resolution:", {
-      fromToken: options.fromToken,
-      fromTokenAddress,
+      fromToken: options.fromToken ?? "Any",
+      fromTokenAddress: fromTokenAddress ?? "orchestrator picks",
       toToken: options.toToken,
       toTokenAddress,
       targetChain: options.targetChain
     });
     const formatTokenLabel = (token, fallback) => {
       if (!token.startsWith("0x")) {
-        return token.toUpperCase();
+        return token;
       }
       try {
         return getTokenSymbol(token, options.targetChain);
@@ -735,15 +1185,11 @@ var PasskeyProviderClient = class {
         return fallback;
       }
     };
-    const fromSymbol = formatTokenLabel(
-      options.fromToken,
-      `${options.fromToken.slice(0, 6)}...${options.fromToken.slice(-4)}`
-    );
     const toSymbol = formatTokenLabel(
       options.toToken,
       `${options.toToken.slice(0, 6)}...${options.toToken.slice(-4)}`
     );
-    const isFromNativeEth = fromTokenAddress === "0x0000000000000000000000000000000000000000";
+    const isFromNativeEth = fromTokenAddress ? fromTokenAddress === "0x0000000000000000000000000000000000000000" : false;
     const isToNativeEth = toTokenAddress === "0x0000000000000000000000000000000000000000";
     const KNOWN_DECIMALS = {
       ETH: 18,
@@ -753,31 +1199,33 @@ var PasskeyProviderClient = class {
       USDT0: 6
     };
     const getDecimals = (symbol, chainId) => {
-      const upperSymbol = symbol.toUpperCase();
       try {
-        const decimals = getTokenDecimals(upperSymbol, chainId);
-        console.log(`[SDK] getTokenDecimals(${upperSymbol}, ${chainId}) = ${decimals}`);
+        const match = getSupportedTokens(chainId).find(
+          (t) => t.symbol.toUpperCase() === symbol.toUpperCase()
+        );
+        if (match) {
+          console.log(`[SDK] getTokenDecimals(${match.symbol}, ${chainId}) = ${match.decimals}`);
+          return match.decimals;
+        }
+        const decimals = getTokenDecimals(symbol, chainId);
+        console.log(`[SDK] getTokenDecimals(${symbol}, ${chainId}) = ${decimals}`);
         return decimals;
       } catch (e) {
-        console.warn(`[SDK] getTokenDecimals failed for ${upperSymbol}, using fallback`, e);
+        const upperSymbol = symbol.toUpperCase();
+        console.warn(`[SDK] getTokenDecimals failed for ${symbol}, using fallback`, e);
         return KNOWN_DECIMALS[upperSymbol] ?? 18;
       }
     };
-    const fromDecimals = getDecimals(options.fromToken, options.targetChain);
     const toDecimals = getDecimals(options.toToken, options.targetChain);
-    const isBridge = options.fromToken.toUpperCase() === options.toToken.toUpperCase();
-    let tokenRequests;
-    if (!isToNativeEth) {
-      tokenRequests = [{
-        token: toTokenAddress,
-        amount: parseUnits(options.amount, toDecimals).toString()
-      }];
-    }
+    const isBridge = options.fromToken ? options.fromToken.toUpperCase() === options.toToken.toUpperCase() : false;
+    const tokenRequests = [{
+      token: toTokenAddress,
+      amount: parseUnits(options.amount, toDecimals)
+    }];
     console.log("[SDK sendSwap] Building intent:", {
       isBridge,
       isFromNativeEth,
       isToNativeEth,
-      fromDecimals,
       toDecimals,
       tokenRequests
     });
@@ -788,15 +1236,20 @@ var PasskeyProviderClient = class {
         {
           // Minimal call - just signals to orchestrator we want the tokenRequests delivered
           to: toTokenAddress,
-          value: "0"
+          value: "0",
+          // SDK provides labels so dialog shows "Buy ETH" not "Send ETH / To: 0x000..."
+          label: `Buy ${toSymbol}`,
+          sublabel: `${options.amount} ${toSymbol}`
         }
       ],
       // Request specific output tokens - this is what actually matters for swaps
       tokenRequests,
       // Constrain orchestrator to use only the fromToken as input
       // This ensures the swap uses the correct source token
-      // Pass the symbol (not address) so orchestrator can resolve per-chain
-      sourceAssets: options.sourceAssets || [options.fromToken.toUpperCase()],
+      // Use canonical symbol casing from registry (e.g. "MockUSD" not "MOCKUSD")
+      sourceAssets: options.sourceAssets || (options.fromToken ? [options.fromToken] : void 0),
+      // Pass source chain ID so orchestrator knows which chain to look for tokens on
+      sourceChainId: options.sourceChainId,
       closeOn: options.closeOn || "preconfirmed",
       waitForHash: options.waitForHash,
       hashTimeoutMs: options.hashTimeoutMs,
@@ -805,7 +1258,7 @@ var PasskeyProviderClient = class {
     return {
       ...result,
       quote: result.success ? {
-        fromToken: fromTokenAddress,
+        fromToken: fromTokenAddress ?? options.fromToken,
         toToken: toTokenAddress,
         amountIn: options.amount,
         amountOut: "",
@@ -847,26 +1300,23 @@ var PasskeyProviderClient = class {
     const themeParams = this.getThemeParams(options?.theme);
     const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe${themeParams ? `&${themeParams}` : ""}`;
     const { dialog, iframe, cleanup } = this.createModalDialog(signingUrl);
-    const dialogOrigin = this.getDialogOrigin();
-    await new Promise((resolve) => {
-      const handleReady = (event) => {
-        if (event.origin !== dialogOrigin) return;
-        if (event.data?.type === "PASSKEY_READY") {
-          window.removeEventListener("message", handleReady);
-          iframe.contentWindow?.postMessage({
-            type: "PASSKEY_INIT",
-            mode: "iframe",
-            message: options.message,
-            challenge: options.challenge || options.message,
-            username: options.username,
-            description: options.description,
-            metadata: options.metadata
-          }, dialogOrigin);
-          resolve();
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe",
+      message: options.message,
+      challenge: options.challenge || options.message,
+      username: options.username,
+      description: options.description,
+      metadata: options.metadata
+    });
+    if (!ready) {
+      return {
+        success: false,
+        error: {
+          code: "USER_REJECTED",
+          message: "User closed the dialog"
         }
       };
-      window.addEventListener("message", handleReady);
-    });
+    }
     const signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
     cleanup();
     if (signingResult.success) {
@@ -935,31 +1385,28 @@ var PasskeyProviderClient = class {
     const themeParams = this.getThemeParams(options?.theme);
     const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe${themeParams ? `&${themeParams}` : ""}`;
     const { dialog, iframe, cleanup } = this.createModalDialog(signingUrl);
-    const dialogOrigin = this.getDialogOrigin();
-    await new Promise((resolve) => {
-      const handleReady = (event) => {
-        if (event.origin !== dialogOrigin) return;
-        if (event.data?.type === "PASSKEY_READY") {
-          window.removeEventListener("message", handleReady);
-          iframe.contentWindow?.postMessage({
-            type: "PASSKEY_INIT",
-            mode: "iframe",
-            signingMode: "typedData",
-            typedData: {
-              domain: options.domain,
-              types: options.types,
-              primaryType: options.primaryType,
-              message: options.message
-            },
-            challenge: signedHash,
-            username: options.username,
-            description: options.description
-          }, dialogOrigin);
-          resolve();
+    const ready = await this.waitForDialogReady(dialog, iframe, cleanup, {
+      mode: "iframe",
+      signingMode: "typedData",
+      typedData: {
+        domain: options.domain,
+        types: options.types,
+        primaryType: options.primaryType,
+        message: options.message
+      },
+      challenge: signedHash,
+      username: options.username,
+      description: options.description
+    });
+    if (!ready) {
+      return {
+        success: false,
+        error: {
+          code: "USER_REJECTED",
+          message: "User closed the dialog"
         }
       };
-      window.addEventListener("message", handleReady);
-    });
+    }
     const signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
     cleanup();
     if (signingResult.success) {
@@ -1113,9 +1560,7 @@ var PasskeyProviderClient = class {
     const response = await fetch(
       `${this.config.providerUrl}/api/users/${encodeURIComponent(username)}/passkeys`,
       {
-        headers: {
-          "x-client-id": this.config.clientId
-        }
+        headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {}
       }
     );
     if (!response.ok) {
@@ -1134,7 +1579,7 @@ var PasskeyProviderClient = class {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          clientId: this.config.clientId,
+          ...this.config.clientId && { clientId: this.config.clientId },
           username: options.username,
           challenge: options.challenge,
           description: options.description,
@@ -1161,7 +1606,45 @@ var PasskeyProviderClient = class {
     );
   }
   /**
-   * 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.
+   */
+  waitForDialogReady(dialog, iframe, cleanup, initMessage) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      let settled = false;
+      const teardown = () => {
+        if (settled) return;
+        settled = true;
+        window.removeEventListener("message", handleMessage);
+        dialog.removeEventListener("close", handleClose);
+      };
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        if (event.data?.type === "PASSKEY_READY") {
+          teardown();
+          iframe.contentWindow?.postMessage({
+            type: "PASSKEY_INIT",
+            ...initMessage
+          }, dialogOrigin);
+          resolve(true);
+        } else if (event.data?.type === "PASSKEY_CLOSE") {
+          teardown();
+          cleanup();
+          resolve(false);
+        }
+      };
+      const handleClose = () => {
+        teardown();
+        resolve(false);
+      };
+      window.addEventListener("message", handleMessage);
+      dialog.addEventListener("close", handleClose);
+    });
+  }
+  /**
+   * Create a modal dialog with an iframe inside.
    */
   createModalDialog(url) {
     const dialogUrl = this.getDialogUrl();
@@ -1304,12 +1787,24 @@ var PasskeyProviderClient = class {
     };
     return { dialog, iframe, cleanup };
   }
-  waitForModalAuthResponse(_dialog, _iframe, cleanup) {
+  waitForModalAuthResponse(_dialog, iframe, cleanup) {
     const dialogOrigin = this.getDialogOrigin();
     return new Promise((resolve) => {
+      let dialogReady = false;
       const handleMessage = (event) => {
         if (event.origin !== dialogOrigin) return;
         const data = event.data;
+        if (data?.type === "PASSKEY_READY") {
+          dialogReady = true;
+          iframe.contentWindow?.postMessage({
+            type: "PASSKEY_INIT",
+            mode: "iframe"
+          }, dialogOrigin);
+          return;
+        }
+        if (!dialogReady && data?.type === "PASSKEY_CLOSE") {
+          return;
+        }
         if (data?.type === "PASSKEY_LOGIN_RESULT") {
           window.removeEventListener("message", handleMessage);
           cleanup();
@@ -1339,6 +1834,11 @@ var PasskeyProviderClient = class {
               error: data.error
             });
           }
+        } else if (data?.type === "PASSKEY_RETRY_POPUP") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          const popupUrl = data.data?.url?.replace("mode=iframe", "mode=popup") || `${this.getDialogUrl()}/dialog/auth?mode=popup${this.config.clientId ? `&clientId=${this.config.clientId}` : ""}`;
+          this.waitForPopupAuthResponse(popupUrl).then(resolve);
         } else if (data?.type === "PASSKEY_CLOSE") {
           window.removeEventListener("message", handleMessage);
           cleanup();
@@ -1354,6 +1854,77 @@ var PasskeyProviderClient = class {
       window.addEventListener("message", handleMessage);
     });
   }
+  /**
+   * Open a popup for auth and wait for the result.
+   * Used when iframe mode fails (e.g., due to password manager interference).
+   */
+  waitForPopupAuthResponse(url) {
+    const dialogOrigin = this.getDialogOrigin();
+    const popup = this.openPopup(url);
+    return new Promise((resolve) => {
+      const pollTimer = setInterval(() => {
+        if (popup?.closed) {
+          clearInterval(pollTimer);
+          window.removeEventListener("message", handleMessage);
+          resolve({
+            success: false,
+            error: {
+              code: "USER_CANCELLED",
+              message: "Authentication was cancelled"
+            }
+          });
+        }
+      }, 500);
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const data = event.data;
+        if (data?.type === "PASSKEY_LOGIN_RESULT") {
+          clearInterval(pollTimer);
+          window.removeEventListener("message", handleMessage);
+          popup?.close();
+          if (data.success) {
+            resolve({
+              success: true,
+              username: data.data?.username,
+              user: data.data?.user
+            });
+          } else {
+            resolve({
+              success: false,
+              error: data.error
+            });
+          }
+        } else if (data?.type === "PASSKEY_REGISTER_RESULT") {
+          clearInterval(pollTimer);
+          window.removeEventListener("message", handleMessage);
+          popup?.close();
+          if (data.success) {
+            resolve({
+              success: true,
+              username: data.data?.username
+            });
+          } else {
+            resolve({
+              success: false,
+              error: data.error
+            });
+          }
+        } else if (data?.type === "PASSKEY_CLOSE") {
+          clearInterval(pollTimer);
+          window.removeEventListener("message", handleMessage);
+          popup?.close();
+          resolve({
+            success: false,
+            error: {
+              code: "USER_CANCELLED",
+              message: "Authentication was cancelled"
+            }
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
   waitForAuthenticateResponse(_dialog, _iframe, cleanup) {
     const dialogOrigin = this.getDialogOrigin();
     return new Promise((resolve) => {
@@ -1393,6 +1964,44 @@ var PasskeyProviderClient = class {
       window.addEventListener("message", handleMessage);
     });
   }
+  waitForConnectResponse(_dialog, _iframe, cleanup) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const data = event.data;
+        if (data?.type === "PASSKEY_CONNECT_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          if (data.success) {
+            resolve({
+              success: true,
+              username: data.data?.username,
+              autoConnected: data.data?.autoConnected
+            });
+          } else {
+            resolve({
+              success: false,
+              action: data.data?.action,
+              error: data.error
+            });
+          }
+        } else if (data?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve({
+            success: false,
+            action: "cancel",
+            error: {
+              code: "USER_CANCELLED",
+              message: "Connection was cancelled"
+            }
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
   waitForModalSigningResponse(requestId, _dialog, _iframe, cleanup) {
     const dialogOrigin = this.getDialogOrigin();
     return new Promise((resolve) => {
@@ -1481,9 +2090,7 @@ var PasskeyProviderClient = class {
     const response = await fetch(
       `${this.config.providerUrl}/api/sign/request/${requestId}`,
       {
-        headers: {
-          "x-client-id": this.config.clientId
-        }
+        headers: this.config.clientId ? { "x-client-id": this.config.clientId } : {}
       }
     );
     if (!response.ok) {
@@ -1601,7 +2208,7 @@ import {
 } from "viem";
 import { toAccount as toAccount2 } from "viem/accounts";
 function createPasskeyWalletClient(config) {
-  const provider = new PasskeyProviderClient({
+  const provider = new OneAuthClient({
     providerUrl: config.providerUrl,
     clientId: config.clientId,
     dialogUrl: config.dialogUrl
@@ -1625,6 +2232,9 @@ function createPasskeyWalletClient(config) {
     if (!result.success) {
       throw new Error(result.error?.message || "Signing failed");
     }
+    if (!result.signature) {
+      throw new Error("No signature received");
+    }
     return encodeWebAuthnSignature(result.signature);
   };
   const signTransactionImpl = async (transaction) => {
@@ -1645,6 +2255,9 @@ function createPasskeyWalletClient(config) {
     if (!result.success) {
       throw new Error(result.error?.message || "Signing failed");
     }
+    if (!result.signature) {
+      throw new Error("No signature received");
+    }
     return encodeWebAuthnSignature(result.signature);
   };
   const signTypedDataImpl = async (typedData) => {
@@ -1666,8 +2279,35 @@ function createPasskeyWalletClient(config) {
     if (!result.success) {
       throw new Error(result.error?.message || "Signing failed");
     }
+    if (!result.signature) {
+      throw new Error("No signature received");
+    }
     return encodeWebAuthnSignature(result.signature);
   };
+  const buildIntentPayload = async (calls, targetChainOverride) => {
+    const targetChain = targetChainOverride ?? config.chain.id;
+    const intentCalls = calls.map((call) => ({
+      to: call.to,
+      data: call.data || "0x",
+      value: call.value !== void 0 ? call.value.toString() : "0",
+      label: call.label,
+      sublabel: call.sublabel
+    }));
+    if (config.signIntent) {
+      const signedIntent = await config.signIntent({
+        username: config.username,
+        accountAddress: config.accountAddress,
+        targetChain,
+        calls: intentCalls
+      });
+      return { signedIntent };
+    }
+    return {
+      username: config.username,
+      targetChain,
+      calls: intentCalls
+    };
+  };
   const account = toAccount2({
     address: config.accountAddress,
     signMessage: ({ message }) => signMessageImpl(message),
@@ -1684,24 +2324,18 @@ function createPasskeyWalletClient(config) {
      * Send a single transaction via intent flow
      */
     async sendTransaction(transaction) {
+      const targetChain = typeof transaction.chainId === "number" ? transaction.chainId : transaction.chain?.id;
       const calls = [
         {
           to: transaction.to,
-          data: transaction.data,
+          data: transaction.data || "0x",
           value: transaction.value
         }
       ];
       const closeOn = config.waitForHash ?? true ? "completed" : "preconfirmed";
+      const intentPayload = await buildIntentPayload(calls, targetChain);
       const result = await provider.sendIntent({
-        username: config.username,
-        targetChain: config.chain.id,
-        calls: calls.map((call) => ({
-          to: call.to,
-          data: call.data,
-          value: call.value ? call.value.toString() : "0",
-          label: call.label,
-          sublabel: call.sublabel
-        })),
+        ...intentPayload,
         closeOn,
         waitForHash: config.waitForHash ?? true,
         hashTimeoutMs: config.hashTimeoutMs,
@@ -1716,18 +2350,12 @@ function createPasskeyWalletClient(config) {
      * Send multiple calls as a single batched transaction
      */
     async sendCalls(params) {
-      const { calls } = params;
+      const { calls, chainId: targetChain, tokenRequests } = params;
       const closeOn = config.waitForHash ?? true ? "completed" : "preconfirmed";
+      const intentPayload = await buildIntentPayload(calls, targetChain);
       const result = await provider.sendIntent({
-        username: config.username,
-        targetChain: config.chain.id,
-        calls: calls.map((call) => ({
-          to: call.to,
-          data: call.data,
-          value: call.value ? call.value.toString() : "0",
-          label: call.label,
-          sublabel: call.sublabel
-        })),
+        ...intentPayload,
+        tokenRequests,
         closeOn,
         waitForHash: config.waitForHash ?? true,
         hashTimeoutMs: config.hashTimeoutMs,
@@ -2171,9 +2799,10 @@ function BatchQueueWidget({ onSignAll }) {
 
 // src/verify.ts
 import { keccak256, toBytes } from "viem";
-var PASSKEY_MESSAGE_PREFIX = "Passkey Signed Message:\n";
+var ETHEREUM_MESSAGE_PREFIX = "Ethereum Signed Message:\n";
+var PASSKEY_MESSAGE_PREFIX = ETHEREUM_MESSAGE_PREFIX;
 function hashMessage2(message) {
-  const prefixed = PASSKEY_MESSAGE_PREFIX + message.length.toString() + message;
+  const prefixed = ETHEREUM_MESSAGE_PREFIX + message.length.toString() + message;
   return keccak256(toBytes(prefixed));
 }
 function verifyMessageHash(message, signedHash) {
@@ -2184,8 +2813,11 @@ function verifyMessageHash(message, signedHash) {
 export {
   BatchQueueProvider,
   BatchQueueWidget,
+  ETHEREUM_MESSAGE_PREFIX,
+  OneAuthClient,
   PASSKEY_MESSAGE_PREFIX,
-  PasskeyProviderClient,
+  OneAuthClient as PasskeyProviderClient,
+  createOneAuthProvider,
   createPasskeyAccount,
   createPasskeyProvider,
   createPasskeyWalletClient,