@rhinestone/1auth 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2213 @@
+import {
+  buildTransactionReview,
+  createPasskeyProvider,
+  encodeWebAuthnSignature,
+  getAllSupportedChainsAndTokens,
+  getChainById,
+  getChainExplorerUrl,
+  getChainName,
+  getChainRpcUrl,
+  getSupportedChainIds,
+  getSupportedChains,
+  getSupportedTokenSymbols,
+  getSupportedTokens,
+  getTokenAddress,
+  getTokenDecimals,
+  getTokenSymbol,
+  hashCalls,
+  isTestnet,
+  isTokenAddressSupported,
+  resolveTokenAddress
+} from "./chunk-UXYKIMGZ.mjs";
+
+// src/client.ts
+import { parseUnits, hashTypedData } from "viem";
+var POPUP_WIDTH = 450;
+var POPUP_HEIGHT = 600;
+var DEFAULT_EMBED_WIDTH = "400px";
+var DEFAULT_EMBED_HEIGHT = "500px";
+var MODAL_WIDTH = 360;
+var PasskeyProviderClient = class {
+  constructor(config) {
+    this.config = config;
+    this.theme = config.theme || {};
+  }
+  /**
+   * Update the theme configuration at runtime
+   */
+  setTheme(theme) {
+    this.theme = theme;
+  }
+  /**
+   * Build theme URL parameters
+   */
+  getThemeParams(overrideTheme) {
+    const theme = { ...this.theme, ...overrideTheme };
+    const params = new URLSearchParams();
+    if (theme.mode) {
+      params.set("theme", theme.mode);
+    }
+    if (theme.accent) {
+      params.set("accent", theme.accent);
+    }
+    return params.toString();
+  }
+  /**
+   * Get the dialog URL (Vite app URL)
+   * Defaults to providerUrl if dialogUrl is not set
+   */
+  getDialogUrl() {
+    return this.config.dialogUrl || this.config.providerUrl;
+  }
+  /**
+   * Get the origin for message validation
+   * Uses dialogUrl origin if set, otherwise providerUrl origin
+   */
+  getDialogOrigin() {
+    const dialogUrl = this.getDialogUrl();
+    try {
+      return new URL(dialogUrl).origin;
+    } catch {
+      return dialogUrl;
+    }
+  }
+  /**
+   * Get the base provider URL
+   */
+  getProviderUrl() {
+    return this.config.providerUrl;
+  }
+  /**
+   * Get the configured client ID
+   */
+  getClientId() {
+    return this.config.clientId;
+  }
+  async waitForTransactionHash(intentId, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 12e4;
+    const intervalMs = options.intervalMs ?? 2e3;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try {
+        const response = await fetch(
+          `${this.config.providerUrl}/api/intent/status/${intentId}`,
+          {
+            headers: {
+              "x-client-id": this.config.clientId
+            }
+          }
+        );
+        if (response.ok) {
+          const data = await response.json();
+          if (data.transactionHash) {
+            return data.transactionHash;
+          }
+          if (data.status === "failed" || data.status === "expired") {
+            return void 0;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    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.
+   */
+  async authWithModal(options) {
+    const dialogUrl = this.getDialogUrl();
+    const params = new URLSearchParams({
+      clientId: this.config.clientId,
+      mode: "iframe"
+    });
+    if (options?.username) {
+      params.set("username", options.username);
+    }
+    if (options?.oauthEnabled === false) {
+      params.set("oauth", "0");
+    }
+    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/auth?${params.toString()}`;
+    const { dialog, iframe, cleanup } = this.createModalDialog(url);
+    return this.waitForModalAuthResponse(dialog, iframe, cleanup);
+  }
+  /**
+   * Authenticate a user with an optional challenge to sign.
+   *
+   * This method combines authentication (sign in / sign up) with optional
+   * challenge signing, enabling off-chain login without on-chain transactions.
+   *
+   * When a challenge is provided:
+   * 1. User authenticates (sign in or sign up)
+   * 2. The challenge is hashed with a domain separator
+   * 3. User signs the hash with their passkey
+   * 4. Returns user info + signature for server-side verification
+   *
+   * The domain separator ("\x19Passkey Signed Message:\n") ensures the signature
+   * cannot be reused for transaction signing, preventing phishing attacks.
+   *
+   * @example
+   * ```typescript
+   * // Authenticate with a login challenge
+   * const result = await client.authenticate({
+   *   challenge: `Login to MyApp\nTimestamp: ${Date.now()}\nNonce: ${crypto.randomUUID()}`
+   * });
+   *
+   * if (result.success && result.signature) {
+   *   // Verify signature server-side
+   *   const isValid = await verifyOnServer(
+   *     result.username,
+   *     result.signature,
+   *     result.signedHash
+   *   );
+   * }
+   * ```
+   */
+  async authenticate(options) {
+    const dialogUrl = this.getDialogUrl();
+    const params = new URLSearchParams({
+      clientId: this.config.clientId,
+      mode: "iframe"
+    });
+    if (options?.challenge) {
+      params.set("challenge", options.challenge);
+    }
+    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/authenticate?${params.toString()}`;
+    const { dialog, iframe, cleanup } = this.createModalDialog(url);
+    return this.waitForAuthenticateResponse(dialog, iframe, cleanup);
+  }
+  /**
+   * Show signing in a modal overlay (Porto-style 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();
+      };
+    });
+    return this.waitForSigningResponse(dialog, iframe, cleanup);
+  }
+  /**
+   * Send an intent to the Rhinestone orchestrator
+   *
+   * This is the high-level method for cross-chain transactions:
+   * 1. Prepares the intent (gets quote from orchestrator)
+   * 2. Shows the signing modal with real fees
+   * 3. Submits the signed intent for execution
+   * 4. Returns the transaction hash
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sendIntent({
+   *   username: 'alice',
+   *   targetChain: 8453, // Base
+   *   calls: [
+   *     {
+   *       to: '0x...',
+   *       data: '0x...',
+   *       label: 'Swap ETH for USDC',
+   *       sublabel: '0.1 ETH → ~250 USDC',
+   *     },
+   *   ],
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Transaction hash:', result.transactionHash);
+   * }
+   * ```
+   */
+  async sendIntent(options) {
+    const signedIntent = options.signedIntent;
+    const username = signedIntent?.username || options.username;
+    const targetChain = signedIntent?.targetChain || options.targetChain;
+    const calls = signedIntent?.calls || options.calls;
+    if (!username && !signedIntent?.accountAddress) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "INVALID_OPTIONS",
+          message: "Either username, accountAddress, or signedIntent with user identifier is required"
+        }
+      };
+    }
+    if (!targetChain || !calls?.length) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "INVALID_OPTIONS",
+          message: "targetChain and calls are required (either directly or via signedIntent)"
+        }
+      };
+    }
+    let prepareResponse;
+    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: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errorMessage = errorData.error || "Failed to prepare intent";
+        if (errorMessage.includes("User not found")) {
+          localStorage.removeItem("1auth-user");
+        }
+        return {
+          success: false,
+          intentId: "",
+          status: "failed",
+          error: {
+            code: errorMessage.includes("User not found") ? "USER_NOT_FOUND" : "PREPARE_FAILED",
+            message: errorMessage
+          }
+        };
+      }
+      prepareResponse = await response.json();
+    } catch (error) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "Network error"
+        }
+      };
+    }
+    const dialogUrl = this.getDialogUrl();
+    const signingUrl = `${dialogUrl}/dialog/sign?mode=iframe`;
+    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 signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
+    if (!signingResult.success) {
+      return {
+        success: false,
+        intentId: prepareResponse.intentId,
+        status: "failed",
+        error: signingResult.error
+      };
+    }
+    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(() => ({}));
+        this.sendTransactionStatus(iframe, "failed");
+        await this.waitForDialogClose(dialog, cleanup);
+        return {
+          success: false,
+          intentId: prepareResponse.intentId,
+          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,
+        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
+            }
+          }
+        );
+        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 (waitError) {
+        console.error("Failed to wait for intent:", waitError);
+      }
+    }
+    const displayStatus = finalStatus === "completed" ? "confirmed" : finalStatus;
+    this.sendTransactionStatus(iframe, displayStatus, finalTxHash);
+    await this.waitForDialogClose(dialog, cleanup);
+    if (options.waitForHash && !finalTxHash) {
+      const hash = await this.waitForTransactionHash(prepareResponse.intentId, {
+        timeoutMs: options.hashTimeoutMs,
+        intervalMs: options.hashIntervalMs
+      });
+      if (hash) {
+        finalTxHash = hash;
+        finalStatus = "completed";
+      } else {
+        finalStatus = "failed";
+        return {
+          success: false,
+          intentId: prepareResponse.intentId,
+          status: finalStatus,
+          transactionHash: finalTxHash,
+          operationId: executeResponse.operationId,
+          error: {
+            code: "HASH_TIMEOUT",
+            message: "Timed out waiting for transaction hash"
+          }
+        };
+      }
+    }
+    return {
+      success: finalStatus === "completed",
+      intentId: prepareResponse.intentId,
+      status: finalStatus,
+      transactionHash: finalTxHash,
+      operationId: executeResponse.operationId,
+      error: executeResponse.error
+    };
+  }
+  /**
+   * Send transaction status to the dialog iframe
+   */
+  sendTransactionStatus(iframe, status, transactionHash) {
+    const dialogOrigin = this.getDialogOrigin();
+    iframe.contentWindow?.postMessage(
+      {
+        type: "TRANSACTION_STATUS",
+        status,
+        transactionHash
+      },
+      dialogOrigin
+    );
+  }
+  /**
+   * Wait for the signing result without closing the modal
+   */
+  waitForIntentSigningResponse(requestId, dialog, _iframe, cleanup) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const message = event.data;
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT" && payload?.requestId === requestId) {
+          window.removeEventListener("message", handleMessage);
+          if (message.success && payload.signature) {
+            resolve({
+              success: true,
+              requestId,
+              signature: payload.signature,
+              passkey: payload.passkey
+              // Include passkey info for signature encoding
+            });
+          } 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);
+      dialog.showModal();
+    });
+  }
+  /**
+   * Wait for signing result (simplified - no requestId matching)
+   */
+  waitForSigningResponse(dialog, _iframe, cleanup) {
+    const dialogOrigin = this.getDialogOrigin();
+    console.log("[SDK] waitForSigningResponse, expecting origin:", dialogOrigin);
+    return new Promise((resolve) => {
+      const handleMessage = (event) => {
+        console.log("[SDK] Received message:", event.origin, event.data?.type);
+        if (event.origin !== dialogOrigin) {
+          console.log("[SDK] Origin mismatch, ignoring. Expected:", dialogOrigin, "Got:", event.origin);
+          return;
+        }
+        const message = event.data;
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          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 the dialog to be closed
+   */
+  waitForDialogClose(dialog, cleanup) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        if (event.data?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve();
+        }
+      };
+      const handleClose = () => {
+        window.removeEventListener("message", handleMessage);
+        dialog.removeEventListener("close", handleClose);
+        cleanup();
+        resolve();
+      };
+      window.addEventListener("message", handleMessage);
+      dialog.addEventListener("close", handleClose);
+    });
+  }
+  /**
+   * Poll for intent status
+   *
+   * Use this to check on the status of a submitted intent
+   * that hasn't completed yet.
+   */
+  async getIntentStatus(intentId) {
+    try {
+      const response = await fetch(
+        `${this.config.providerUrl}/api/intent/status/${intentId}`,
+        {
+          headers: {
+            "x-client-id": this.config.clientId
+          }
+        }
+      );
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          intentId,
+          status: "failed",
+          error: {
+            code: "STATUS_FAILED",
+            message: errorData.error || "Failed to get intent status"
+          }
+        };
+      }
+      const data = await response.json();
+      return {
+        success: data.status === "completed",
+        intentId,
+        status: data.status,
+        transactionHash: data.transactionHash,
+        operationId: data.operationId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        intentId,
+        status: "failed",
+        error: {
+          code: "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "Network error"
+        }
+      };
+    }
+  }
+  /**
+   * Send a swap intent through the Rhinestone orchestrator
+   *
+   * This is a high-level abstraction for token swaps (including cross-chain):
+   * 1. Resolves token symbols to addresses
+   * 2. Builds the swap intent with tokenRequests (output-first model)
+   * 3. The orchestrator's solver network finds the best route
+   * 4. Executes via the standard intent flow
+   *
+   * NOTE: The `amount` parameter specifies the OUTPUT amount (what the user wants to receive),
+   * not the input amount. The orchestrator will calculate the required input from sourceAssets.
+   *
+   * @example
+   * ```typescript
+   * // Buy 100 USDC using ETH on Base
+   * const result = await client.sendSwap({
+   *   username: 'alice',
+   *   targetChain: 8453,
+   *   fromToken: 'ETH',
+   *   toToken: 'USDC',
+   *   amount: '100', // Receive 100 USDC
+   * });
+   *
+   * // Cross-chain: Buy 50 USDC on Base, paying with ETH from any chain
+   * const result = await client.sendSwap({
+   *   username: 'alice',
+   *   targetChain: 8453, // Base
+   *   fromToken: 'ETH',
+   *   toToken: 'USDC',
+   *   amount: '50', // Receive 50 USDC
+   * });
+   * ```
+   */
+  async sendSwap(options) {
+    try {
+      getChainById(options.targetChain);
+    } catch {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "INVALID_CHAIN",
+          message: `Unsupported chain: ${options.targetChain}`
+        }
+      };
+    }
+    const resolveToken = (token, label) => {
+      try {
+        const address = resolveTokenAddress(token, options.targetChain);
+        if (!isTokenAddressSupported(address, options.targetChain)) {
+          return {
+            error: `Unsupported ${label}: ${token} on chain ${options.targetChain}`
+          };
+        }
+        return { address };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : `Unsupported ${label}: ${token} on chain ${options.targetChain}`
+        };
+      }
+    };
+    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}`
+        }
+      };
+    }
+    const toTokenResult = resolveToken(options.toToken, "toToken");
+    if (!toTokenResult.address) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "INVALID_TOKEN",
+          message: toTokenResult.error || `Unknown toToken: ${options.toToken}`
+        }
+      };
+    }
+    const fromTokenAddress = fromTokenResult.address;
+    const toTokenAddress = toTokenResult.address;
+    console.log("[SDK sendSwap] Token resolution:", {
+      fromToken: options.fromToken,
+      fromTokenAddress,
+      toToken: options.toToken,
+      toTokenAddress,
+      targetChain: options.targetChain
+    });
+    const formatTokenLabel = (token, fallback) => {
+      if (!token.startsWith("0x")) {
+        return token.toUpperCase();
+      }
+      try {
+        return getTokenSymbol(token, options.targetChain);
+      } catch {
+        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 isToNativeEth = toTokenAddress === "0x0000000000000000000000000000000000000000";
+    const KNOWN_DECIMALS = {
+      ETH: 18,
+      WETH: 18,
+      USDC: 6,
+      USDT: 6,
+      USDT0: 6
+    };
+    const getDecimals = (symbol, chainId) => {
+      const upperSymbol = symbol.toUpperCase();
+      try {
+        const decimals = getTokenDecimals(upperSymbol, chainId);
+        console.log(`[SDK] getTokenDecimals(${upperSymbol}, ${chainId}) = ${decimals}`);
+        return decimals;
+      } catch (e) {
+        console.warn(`[SDK] getTokenDecimals failed for ${upperSymbol}, 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()
+      }];
+    }
+    console.log("[SDK sendSwap] Building intent:", {
+      isBridge,
+      isFromNativeEth,
+      isToNativeEth,
+      fromDecimals,
+      toDecimals,
+      tokenRequests
+    });
+    const result = await this.sendIntent({
+      username: options.username,
+      targetChain: options.targetChain,
+      calls: [
+        {
+          // Minimal call - just signals to orchestrator we want the tokenRequests delivered
+          to: toTokenAddress,
+          value: "0"
+        }
+      ],
+      // 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()],
+      closeOn: options.closeOn || "preconfirmed",
+      waitForHash: options.waitForHash,
+      hashTimeoutMs: options.hashTimeoutMs,
+      hashIntervalMs: options.hashIntervalMs
+    });
+    return {
+      ...result,
+      quote: result.success ? {
+        fromToken: fromTokenAddress,
+        toToken: toTokenAddress,
+        amountIn: options.amount,
+        amountOut: "",
+        // Filled by orchestrator quote
+        rate: ""
+      } : void 0
+    };
+  }
+  /**
+   * Sign an arbitrary message with the user's passkey
+   *
+   * This is for off-chain message signing (e.g., authentication challenges,
+   * terms acceptance, login signatures), NOT for transaction signing.
+   * The message is displayed to the user and signed with their passkey.
+   *
+   * @example
+   * ```typescript
+   * // Sign a login challenge
+   * const result = await client.signMessage({
+   *   username: 'alice',
+   *   message: `Sign in to MyApp\nTimestamp: ${Date.now()}\nNonce: ${crypto.randomUUID()}`,
+   *   description: 'Verify your identity to continue',
+   * });
+   *
+   * if (result.success) {
+   *   // Send signature to your backend for verification
+   *   await fetch('/api/verify', {
+   *     method: 'POST',
+   *     body: JSON.stringify({
+   *       signature: result.signature,
+   *       message: result.signedMessage,
+   *     }),
+   *   });
+   * }
+   * ```
+   */
+  async signMessage(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) => {
+      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();
+        }
+      };
+      window.addEventListener("message", handleReady);
+    });
+    const signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
+    cleanup();
+    if (signingResult.success) {
+      return {
+        success: true,
+        signature: signingResult.signature,
+        signedMessage: options.message,
+        signedHash: signingResult.signedHash,
+        passkey: signingResult.passkey
+      };
+    }
+    return {
+      success: false,
+      error: signingResult.error
+    };
+  }
+  /**
+   * Sign EIP-712 typed data with the user's passkey
+   *
+   * This method allows signing structured data following the EIP-712 standard.
+   * The typed data is displayed to the user in a human-readable format before signing.
+   *
+   * @example
+   * ```typescript
+   * // Sign an ERC-2612 Permit
+   * const result = await client.signTypedData({
+   *   username: 'alice',
+   *   domain: {
+   *     name: 'Dai Stablecoin',
+   *     version: '1',
+   *     chainId: 1,
+   *     verifyingContract: '0x6B175474E89094C44Da98b954EecdeCB5BE3830F',
+   *   },
+   *   types: {
+   *     Permit: [
+   *       { name: 'owner', type: 'address' },
+   *       { name: 'spender', type: 'address' },
+   *       { name: 'value', type: 'uint256' },
+   *       { name: 'nonce', type: 'uint256' },
+   *       { name: 'deadline', type: 'uint256' },
+   *     ],
+   *   },
+   *   primaryType: 'Permit',
+   *   message: {
+   *     owner: '0xabc...',
+   *     spender: '0xdef...',
+   *     value: 1000000000000000000n,
+   *     nonce: 0n,
+   *     deadline: 1735689600n,
+   *   },
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Signed hash:', result.signedHash);
+   * }
+   * ```
+   */
+  async signTypedData(options) {
+    const signedHash = hashTypedData({
+      domain: options.domain,
+      types: options.types,
+      primaryType: options.primaryType,
+      message: options.message
+    });
+    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) => {
+      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();
+        }
+      };
+      window.addEventListener("message", handleReady);
+    });
+    const signingResult = await this.waitForSigningResponse(dialog, iframe, cleanup);
+    cleanup();
+    if (signingResult.success) {
+      return {
+        success: true,
+        signature: signingResult.signature,
+        signedHash,
+        passkey: signingResult.passkey
+      };
+    }
+    return {
+      success: false,
+      error: signingResult.error
+    };
+  }
+  async signWithPopup(options) {
+    const request = await this.createSigningRequest(options, "popup");
+    const dialogUrl = this.getDialogUrl();
+    const signingUrl = `${dialogUrl}/dialog/sign/${request.requestId}?mode=popup`;
+    const popup = this.openPopup(signingUrl);
+    if (!popup) {
+      return {
+        success: false,
+        error: {
+          code: "POPUP_BLOCKED",
+          message: "Popup was blocked by the browser. Please allow popups for this site."
+        }
+      };
+    }
+    return this.waitForPopupResponse(request.requestId, popup);
+  }
+  async signWithRedirect(options, redirectUrl) {
+    const finalRedirectUrl = redirectUrl || this.config.redirectUrl;
+    if (!finalRedirectUrl) {
+      throw new Error(
+        "redirectUrl is required for redirect flow. Pass it to signWithRedirect() or set it in the constructor."
+      );
+    }
+    const request = await this.createSigningRequest(
+      options,
+      "redirect",
+      finalRedirectUrl
+    );
+    const dialogUrl = this.getDialogUrl();
+    const signingUrl = `${dialogUrl}/dialog/sign/${request.requestId}?mode=redirect&redirectUrl=${encodeURIComponent(finalRedirectUrl)}`;
+    window.location.href = signingUrl;
+  }
+  async signWithEmbed(options, embedOptions) {
+    const request = await this.createSigningRequest(options, "embed");
+    const iframe = this.createEmbed(request.requestId, embedOptions);
+    return this.waitForEmbedResponse(request.requestId, iframe, embedOptions);
+  }
+  createEmbed(requestId, options) {
+    const dialogUrl = this.getDialogUrl();
+    const iframe = document.createElement("iframe");
+    iframe.src = `${dialogUrl}/dialog/sign/${requestId}?mode=iframe`;
+    iframe.style.width = options.width || DEFAULT_EMBED_WIDTH;
+    iframe.style.height = options.height || DEFAULT_EMBED_HEIGHT;
+    iframe.style.border = "none";
+    iframe.style.borderRadius = "12px";
+    iframe.style.boxShadow = "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)";
+    iframe.id = `passkey-embed-${requestId}`;
+    iframe.allow = "publickey-credentials-get *; publickey-credentials-create *";
+    iframe.onload = () => {
+      options.onReady?.();
+    };
+    options.container.appendChild(iframe);
+    return iframe;
+  }
+  waitForEmbedResponse(requestId, iframe, embedOptions) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const cleanup = () => {
+        window.removeEventListener("message", handleMessage);
+        iframe.remove();
+        embedOptions.onClose?.();
+      };
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) {
+          return;
+        }
+        const message = event.data;
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT" && payload?.requestId === requestId) {
+          cleanup();
+          if (message.success && payload.signature) {
+            resolve({
+              success: true,
+              requestId,
+              signature: payload.signature
+            });
+          } else {
+            resolve({
+              success: false,
+              requestId,
+              error: message.error
+            });
+          }
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
+  removeEmbed(requestId) {
+    const iframe = document.getElementById(`passkey-embed-${requestId}`);
+    if (iframe) {
+      iframe.remove();
+    }
+  }
+  async handleRedirectCallback() {
+    const params = new URLSearchParams(window.location.search);
+    const requestId = params.get("request_id");
+    const status = params.get("status");
+    const error = params.get("error");
+    const errorMessage = params.get("error_message");
+    if (error) {
+      return {
+        success: false,
+        requestId: requestId || void 0,
+        error: {
+          code: error,
+          message: errorMessage || "Unknown error"
+        }
+      };
+    }
+    if (!requestId) {
+      return {
+        success: false,
+        error: {
+          code: "INVALID_REQUEST",
+          message: "No request_id found in callback URL"
+        }
+      };
+    }
+    if (status !== "completed") {
+      return {
+        success: false,
+        requestId,
+        error: {
+          code: "UNKNOWN",
+          message: `Unexpected status: ${status}`
+        }
+      };
+    }
+    return this.fetchSigningResult(requestId);
+  }
+  /**
+   * Fetch passkeys for a user from the auth provider
+   */
+  async getPasskeys(username) {
+    const response = await fetch(
+      `${this.config.providerUrl}/api/users/${encodeURIComponent(username)}/passkeys`,
+      {
+        headers: {
+          "x-client-id": this.config.clientId
+        }
+      }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || errorData.message || "Failed to fetch passkeys");
+    }
+    const data = await response.json();
+    return data.passkeys;
+  }
+  async createSigningRequest(options, mode, redirectUrl) {
+    const response = await fetch(
+      `${this.config.providerUrl}/api/sign/request`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          clientId: this.config.clientId,
+          username: options.username,
+          challenge: options.challenge,
+          description: options.description,
+          metadata: options.metadata,
+          transaction: options.transaction,
+          mode,
+          redirectUrl
+        })
+      }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || errorData.message || "Failed to create signing request");
+    }
+    return response.json();
+  }
+  openPopup(url) {
+    const left = window.screenX + (window.outerWidth - POPUP_WIDTH) / 2;
+    const top = window.screenY + 50;
+    return window.open(
+      url,
+      "passkey-signing",
+      `width=${POPUP_WIDTH},height=${POPUP_HEIGHT},left=${left},top=${top},popup=true`
+    );
+  }
+  /**
+   * Create a modal dialog with an iframe inside (Porto-style overlay)
+   */
+  createModalDialog(url) {
+    const dialogUrl = this.getDialogUrl();
+    const hostUrl = new URL(dialogUrl);
+    const dialog = document.createElement("dialog");
+    dialog.dataset.passkey = "";
+    document.body.appendChild(dialog);
+    const style = document.createElement("style");
+    style.textContent = `
+      dialog[data-passkey] {
+        padding: 0;
+        border: none;
+        background: transparent;
+        max-width: none;
+        max-height: none;
+        margin: 0;
+        position: fixed;
+        top: 50px;
+        left: 50%;
+        transform: translateX(-50%);
+        outline: none;
+      }
+
+      dialog[data-passkey]::backdrop {
+        background-color: rgba(0, 0, 0, 0.4);
+        backdrop-filter: blur(8px);
+        -webkit-backdrop-filter: blur(8px);
+      }
+
+      dialog[data-passkey] iframe {
+        background-color: transparent;
+        border-radius: 14px;
+        border: none;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.12), 0 2px 8px rgba(0, 0, 0, 0.08);
+        transition: width 0.2s ease-out, height 0.15s ease-out;
+      }
+
+      @media (min-width: 769px) {
+        dialog[data-passkey] iframe {
+          animation: passkey_zoomIn 0.2s cubic-bezier(0.32, 0.72, 0, 1);
+        }
+      }
+
+      @media (max-width: 768px) {
+        dialog[data-passkey] {
+          width: 100vw !important;
+          height: auto !important;
+          max-height: 90vh !important;
+          max-height: 90dvh !important;
+          top: auto !important;
+          bottom: 0 !important;
+          left: 0 !important;
+          right: 0 !important;
+          transform: none !important;
+          margin: 0 !important;
+        }
+
+        dialog[data-passkey] iframe {
+          animation: passkey_slideFromBottom 0.3s cubic-bezier(0.32, 0.72, 0, 1);
+          border-bottom-left-radius: 0 !important;
+          border-bottom-right-radius: 0 !important;
+          width: 100% !important;
+          max-height: 90vh !important;
+          max-height: 90dvh !important;
+          box-shadow: 0 -4px 32px rgba(0, 0, 0, 0.15) !important;
+        }
+      }
+
+      @keyframes passkey_zoomIn {
+        from {
+          opacity: 0;
+          transform: scale(0.96) translateY(8px);
+        }
+        to {
+          opacity: 1;
+          transform: scale(1) translateY(0);
+        }
+      }
+
+      @keyframes passkey_slideFromBottom {
+        from { transform: translate3d(0, 100%, 0); }
+        to { transform: translate3d(0, 0, 0); }
+      }
+
+      @keyframes passkey_shake {
+        0%, 100% { transform: translateX(0); }
+        20% { transform: translateX(-4px); }
+        40% { transform: translateX(4px); }
+        60% { transform: translateX(-4px); }
+        80% { transform: translateX(4px); }
+      }
+    `;
+    dialog.appendChild(style);
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute(
+      "allow",
+      "publickey-credentials-get *; publickey-credentials-create *; clipboard-write"
+    );
+    iframe.setAttribute("aria-label", "Passkey Authentication");
+    iframe.setAttribute("tabindex", "0");
+    iframe.setAttribute(
+      "sandbox",
+      "allow-forms allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox"
+    );
+    iframe.setAttribute("src", url);
+    iframe.setAttribute("title", "Passkey");
+    iframe.style.border = "none";
+    iframe.style.height = "400px";
+    iframe.style.width = `${MODAL_WIDTH}px`;
+    dialog.appendChild(iframe);
+    const handleMessage = (event) => {
+      if (event.origin !== hostUrl.origin) return;
+      if (event.data?.type === "PASSKEY_RESIZE") {
+        iframe.style.height = `${event.data.height}px`;
+        if (event.data.width) {
+          iframe.style.width = `${event.data.width}px`;
+        }
+      } else if (event.data?.type === "PASSKEY_DISCONNECT") {
+        localStorage.removeItem("1auth-user");
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const handleEscape = (event) => {
+      if (event.key === "Escape") {
+        cleanup();
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    dialog.addEventListener("click", (event) => {
+      if (event.target === dialog) {
+        cleanup();
+      }
+    });
+    dialog.showModal();
+    const cleanup = () => {
+      window.removeEventListener("message", handleMessage);
+      document.removeEventListener("keydown", handleEscape);
+      dialog.close();
+      dialog.remove();
+    };
+    return { dialog, iframe, cleanup };
+  }
+  waitForModalAuthResponse(_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_LOGIN_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          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") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          if (data.success) {
+            resolve({
+              success: true,
+              username: data.data?.username
+            });
+          } else {
+            resolve({
+              success: false,
+              error: data.error
+            });
+          }
+        } else if (data?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          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) => {
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const data = event.data;
+        if (data?.type === "PASSKEY_AUTHENTICATE_RESULT") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          if (data.success) {
+            resolve({
+              success: true,
+              username: data.data?.username,
+              user: data.data?.user,
+              accountAddress: data.data?.accountAddress,
+              signature: data.data?.signature,
+              signedHash: data.data?.signedHash
+            });
+          } else {
+            resolve({
+              success: false,
+              error: data.error
+            });
+          }
+        } else if (data?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve({
+            success: false,
+            error: {
+              code: "USER_CANCELLED",
+              message: "Authentication was cancelled"
+            }
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
+  waitForModalSigningResponse(requestId, _dialog, _iframe, cleanup) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) return;
+        const message = event.data;
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT" && payload?.requestId === requestId) {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          if (message.success && payload.signature) {
+            resolve({
+              success: true,
+              requestId,
+              signature: payload.signature
+            });
+          } else {
+            resolve({
+              success: false,
+              requestId,
+              error: message.error
+            });
+          }
+        } else if (message?.type === "PASSKEY_CLOSE") {
+          window.removeEventListener("message", handleMessage);
+          cleanup();
+          resolve({
+            success: false,
+            requestId,
+            error: {
+              code: "USER_REJECTED",
+              message: "Signing was cancelled"
+            }
+          });
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
+  waitForPopupResponse(requestId, popup) {
+    const dialogOrigin = this.getDialogOrigin();
+    return new Promise((resolve) => {
+      const checkClosed = setInterval(() => {
+        if (popup.closed) {
+          clearInterval(checkClosed);
+          window.removeEventListener("message", handleMessage);
+          resolve({
+            success: false,
+            requestId,
+            error: {
+              code: "USER_REJECTED",
+              message: "Popup was closed without completing"
+            }
+          });
+        }
+      }, 500);
+      const handleMessage = (event) => {
+        if (event.origin !== dialogOrigin) {
+          return;
+        }
+        const message = event.data;
+        const payload = message?.data;
+        if (message?.type === "PASSKEY_SIGNING_RESULT" && payload?.requestId === requestId) {
+          clearInterval(checkClosed);
+          window.removeEventListener("message", handleMessage);
+          popup.close();
+          if (message.success && payload.signature) {
+            resolve({
+              success: true,
+              requestId,
+              signature: payload.signature
+            });
+          } else {
+            resolve({
+              success: false,
+              requestId,
+              error: message.error
+            });
+          }
+        }
+      };
+      window.addEventListener("message", handleMessage);
+    });
+  }
+  async fetchSigningResult(requestId) {
+    const response = await fetch(
+      `${this.config.providerUrl}/api/sign/request/${requestId}`,
+      {
+        headers: {
+          "x-client-id": this.config.clientId
+        }
+      }
+    );
+    if (!response.ok) {
+      return {
+        success: false,
+        requestId,
+        error: {
+          code: "NETWORK_ERROR",
+          message: "Failed to fetch signing result"
+        }
+      };
+    }
+    const data = await response.json();
+    if (data.status === "COMPLETED" && data.signature) {
+      return {
+        success: true,
+        requestId,
+        signature: data.signature
+      };
+    }
+    const errorCode = data.error?.code || "UNKNOWN";
+    return {
+      success: false,
+      requestId,
+      error: {
+        code: errorCode,
+        message: data.error?.message || `Request status: ${data.status}`
+      }
+    };
+  }
+};
+
+// src/account.ts
+import {
+  bytesToString,
+  hexToString,
+  isHex
+} from "viem";
+import { toAccount } from "viem/accounts";
+function createPasskeyAccount(client, params) {
+  const { address, username } = params;
+  const normalizeMessage = (message) => {
+    if (typeof message === "string") return message;
+    const raw = message.raw;
+    if (isHex(raw)) {
+      try {
+        return hexToString(raw);
+      } catch {
+        return raw;
+      }
+    }
+    return bytesToString(raw);
+  };
+  const account = toAccount({
+    address,
+    signMessage: async ({ message }) => {
+      const result = await client.signMessage({
+        username,
+        message: normalizeMessage(message)
+      });
+      if (!result.success || !result.signature) {
+        throw new Error(result.error?.message || "Signing failed");
+      }
+      return encodeWebAuthnSignature(result.signature);
+    },
+    signTransaction: async () => {
+      throw new Error("signTransaction not supported; use sendIntent");
+    },
+    signTypedData: async (typedData) => {
+      if (!typedData.domain || !typedData.types || !typedData.primaryType) {
+        throw new Error("Invalid typed data");
+      }
+      const domainInput = typedData.domain;
+      if (!domainInput.name || !domainInput.version) {
+        throw new Error("Typed data domain must include name and version");
+      }
+      const domain = {
+        name: domainInput.name,
+        version: domainInput.version,
+        chainId: typeof domainInput.chainId === "bigint" ? Number(domainInput.chainId) : domainInput.chainId,
+        verifyingContract: domainInput.verifyingContract,
+        salt: domainInput.salt
+      };
+      const rawTypes = typedData.types;
+      const normalizedTypes = Object.fromEntries(
+        Object.entries(rawTypes).map(([key, fields]) => [
+          key,
+          fields.map((field) => ({ name: field.name, type: field.type }))
+        ])
+      );
+      const result = await client.signTypedData({
+        username,
+        domain,
+        types: normalizedTypes,
+        primaryType: typedData.primaryType,
+        message: typedData.message
+      });
+      if (!result.success || !result.signature) {
+        throw new Error(result.error?.message || "Signing failed");
+      }
+      return encodeWebAuthnSignature(result.signature);
+    }
+  });
+  return {
+    ...account,
+    username
+  };
+}
+
+// src/walletClient/index.ts
+import {
+  createWalletClient,
+  hashMessage,
+  hashTypedData as hashTypedData2
+} from "viem";
+import { toAccount as toAccount2 } from "viem/accounts";
+function createPasskeyWalletClient(config) {
+  const provider = new PasskeyProviderClient({
+    providerUrl: config.providerUrl,
+    clientId: config.clientId,
+    dialogUrl: config.dialogUrl
+  });
+  const signMessageImpl = async (message) => {
+    const hash = hashMessage(message);
+    const result = await provider.signWithModal({
+      challenge: hash,
+      username: config.username,
+      description: "Sign message",
+      transaction: {
+        actions: [
+          {
+            type: "custom",
+            label: "Sign Message",
+            sublabel: typeof message === "string" ? message.slice(0, 50) + (message.length > 50 ? "..." : "") : "Raw message"
+          }
+        ]
+      }
+    });
+    if (!result.success) {
+      throw new Error(result.error?.message || "Signing failed");
+    }
+    return encodeWebAuthnSignature(result.signature);
+  };
+  const signTransactionImpl = async (transaction) => {
+    const calls = [
+      {
+        to: transaction.to,
+        data: transaction.data,
+        value: transaction.value
+      }
+    ];
+    const hash = hashCalls(calls);
+    const result = await provider.signWithModal({
+      challenge: hash,
+      username: config.username,
+      description: "Sign transaction",
+      transaction: buildTransactionReview(calls)
+    });
+    if (!result.success) {
+      throw new Error(result.error?.message || "Signing failed");
+    }
+    return encodeWebAuthnSignature(result.signature);
+  };
+  const signTypedDataImpl = async (typedData) => {
+    const hash = hashTypedData2(typedData);
+    const result = await provider.signWithModal({
+      challenge: hash,
+      username: config.username,
+      description: "Sign typed data",
+      transaction: {
+        actions: [
+          {
+            type: "custom",
+            label: "Sign Data",
+            sublabel: typedData.primaryType || "Typed Data"
+          }
+        ]
+      }
+    });
+    if (!result.success) {
+      throw new Error(result.error?.message || "Signing failed");
+    }
+    return encodeWebAuthnSignature(result.signature);
+  };
+  const account = toAccount2({
+    address: config.accountAddress,
+    signMessage: ({ message }) => signMessageImpl(message),
+    signTransaction: signTransactionImpl,
+    signTypedData: signTypedDataImpl
+  });
+  const client = createWalletClient({
+    account,
+    chain: config.chain,
+    transport: config.transport
+  });
+  const extendedClient = Object.assign(client, {
+    /**
+     * Send a single transaction via intent flow
+     */
+    async sendTransaction(transaction) {
+      const calls = [
+        {
+          to: transaction.to,
+          data: transaction.data,
+          value: transaction.value
+        }
+      ];
+      const closeOn = config.waitForHash ?? true ? "completed" : "preconfirmed";
+      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
+        })),
+        closeOn,
+        waitForHash: config.waitForHash ?? true,
+        hashTimeoutMs: config.hashTimeoutMs,
+        hashIntervalMs: config.hashIntervalMs
+      });
+      if (!result.success || !result.transactionHash) {
+        throw new Error(result.error?.message || "Transaction failed");
+      }
+      return result.transactionHash;
+    },
+    /**
+     * Send multiple calls as a single batched transaction
+     */
+    async sendCalls(params) {
+      const { calls } = params;
+      const closeOn = config.waitForHash ?? true ? "completed" : "preconfirmed";
+      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
+        })),
+        closeOn,
+        waitForHash: config.waitForHash ?? true,
+        hashTimeoutMs: config.hashTimeoutMs,
+        hashIntervalMs: config.hashIntervalMs
+      });
+      if (!result.success || !result.transactionHash) {
+        throw new Error(result.error?.message || "Transaction failed");
+      }
+      return result.transactionHash;
+    }
+  });
+  return extendedClient;
+}
+
+// src/batch/BatchQueueContext.tsx
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+function getChainName2(chainId) {
+  return getChainName(chainId);
+}
+var BatchQueueContext = React.createContext(null);
+function useBatchQueue() {
+  const context = React.useContext(BatchQueueContext);
+  if (!context) {
+    throw new Error("useBatchQueue must be used within a BatchQueueProvider");
+  }
+  return context;
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function getStorageKey(username) {
+  return username ? `1auth_batch_queue_${username}` : "1auth_batch_queue_anonymous";
+}
+function BatchQueueProvider({
+  client,
+  username,
+  children
+}) {
+  const [queue, setQueue] = React.useState([]);
+  const [isExpanded, setExpanded] = React.useState(false);
+  const [isSigning, setIsSigning] = React.useState(false);
+  const [animationTrigger, setAnimationTrigger] = React.useState(0);
+  const batchChainId = queue.length > 0 ? queue[0].targetChain : null;
+  React.useEffect(() => {
+    const storageKey = getStorageKey(username);
+    try {
+      const stored = localStorage.getItem(storageKey);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed) && parsed.every(
+          (item) => typeof item.id === "string" && typeof item.call === "object" && typeof item.targetChain === "number"
+        )) {
+          setQueue(parsed);
+        }
+      }
+    } catch {
+    }
+  }, [username]);
+  React.useEffect(() => {
+    const storageKey = getStorageKey(username);
+    try {
+      if (queue.length > 0) {
+        localStorage.setItem(storageKey, JSON.stringify(queue));
+      } else {
+        localStorage.removeItem(storageKey);
+      }
+    } catch {
+    }
+  }, [queue, username]);
+  const addToBatch = React.useCallback((call, targetChain) => {
+    if (batchChainId !== null && batchChainId !== targetChain) {
+      return {
+        success: false,
+        error: `Batch is set to ${getChainName2(batchChainId)}. Sign current batch first or clear it.`
+      };
+    }
+    const batchedCall = {
+      id: generateId(),
+      call,
+      targetChain,
+      addedAt: Date.now()
+    };
+    setQueue((prev) => [...prev, batchedCall]);
+    setAnimationTrigger((prev) => prev + 1);
+    return { success: true };
+  }, [batchChainId]);
+  const removeFromBatch = React.useCallback((id) => {
+    setQueue((prev) => prev.filter((item) => item.id !== id));
+  }, []);
+  const clearBatch = React.useCallback(() => {
+    setQueue([]);
+    setExpanded(false);
+  }, []);
+  const signAll = React.useCallback(async (username2) => {
+    if (queue.length === 0) {
+      return {
+        success: false,
+        intentId: "",
+        status: "failed",
+        error: {
+          code: "EMPTY_BATCH",
+          message: "No calls in batch to sign"
+        }
+      };
+    }
+    const targetChain = queue[0].targetChain;
+    const calls = queue.map((item) => item.call);
+    setIsSigning(true);
+    try {
+      const result = await client.sendIntent({
+        username: username2,
+        targetChain,
+        calls
+      });
+      if (result.success) {
+        clearBatch();
+      }
+      return result;
+    } finally {
+      setIsSigning(false);
+    }
+  }, [queue, client, clearBatch]);
+  const value = {
+    queue,
+    batchChainId,
+    addToBatch,
+    removeFromBatch,
+    clearBatch,
+    signAll,
+    isExpanded,
+    setExpanded,
+    isSigning,
+    animationTrigger
+  };
+  return /* @__PURE__ */ jsx(BatchQueueContext.Provider, { value, children });
+}
+
+// src/batch/BatchQueueWidget.tsx
+import * as React2 from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ANIMATION_STYLES = `
+@keyframes batch-bounce-in {
+  0% { transform: scale(0.8); opacity: 0; }
+  50% { transform: scale(1.05); }
+  100% { transform: scale(1); opacity: 1; }
+}
+@keyframes batch-item-bounce {
+  0%, 100% { transform: translateX(0); }
+  25% { transform: translateX(-2px); }
+  75% { transform: translateX(2px); }
+}
+`;
+function injectStyles() {
+  if (typeof document === "undefined") return;
+  const styleId = "batch-queue-widget-styles";
+  if (document.getElementById(styleId)) return;
+  const style = document.createElement("style");
+  style.id = styleId;
+  style.textContent = ANIMATION_STYLES;
+  document.head.appendChild(style);
+}
+var widgetStyles = {
+  position: "fixed",
+  bottom: "16px",
+  right: "16px",
+  zIndex: 50,
+  backgroundColor: "#18181b",
+  color: "#ffffff",
+  borderRadius: "12px",
+  boxShadow: "0 4px 12px rgba(0,0,0,0.3)",
+  minWidth: "240px",
+  maxWidth: "360px",
+  fontFamily: "system-ui, -apple-system, sans-serif",
+  fontSize: "14px",
+  overflow: "hidden"
+};
+var headerStyles = {
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  padding: "12px 16px",
+  cursor: "pointer",
+  userSelect: "none"
+};
+var headerLeftStyles = {
+  display: "flex",
+  alignItems: "center",
+  gap: "8px"
+};
+var counterBadgeStyles = {
+  backgroundColor: "#ffffff",
+  color: "#18181b",
+  borderRadius: "9999px",
+  padding: "2px 8px",
+  fontSize: "12px",
+  fontWeight: 600
+};
+var chainBadgeStyles = {
+  backgroundColor: "rgba(255,255,255,0.15)",
+  color: "#a1a1aa",
+  borderRadius: "4px",
+  padding: "2px 6px",
+  fontSize: "11px"
+};
+var signAllButtonStyles = {
+  backgroundColor: "#ffffff",
+  color: "#18181b",
+  border: "none",
+  borderRadius: "6px",
+  padding: "6px 12px",
+  fontSize: "13px",
+  fontWeight: 500,
+  cursor: "pointer",
+  transition: "background-color 0.15s"
+};
+var signAllButtonHoverStyles = {
+  backgroundColor: "#e4e4e7"
+};
+var signAllButtonDisabledStyles = {
+  opacity: 0.5,
+  cursor: "not-allowed"
+};
+var listContainerStyles = {
+  maxHeight: "300px",
+  overflowY: "auto",
+  borderTop: "1px solid #27272a"
+};
+var callItemStyles = {
+  display: "flex",
+  alignItems: "flex-start",
+  padding: "10px 16px",
+  borderBottom: "1px solid #27272a",
+  position: "relative"
+};
+var callItemLastStyles = {
+  borderBottom: "none"
+};
+var callContentStyles = {
+  flex: 1,
+  minWidth: 0
+};
+var callLabelStyles = {
+  fontWeight: 500,
+  marginBottom: "2px"
+};
+var callSublabelStyles = {
+  color: "#a1a1aa",
+  fontSize: "12px",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+};
+var removeButtonStyles = {
+  position: "absolute",
+  left: "8px",
+  top: "50%",
+  transform: "translateY(-50%)",
+  backgroundColor: "#dc2626",
+  color: "#ffffff",
+  border: "none",
+  borderRadius: "4px",
+  width: "20px",
+  height: "20px",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  cursor: "pointer",
+  fontSize: "14px",
+  opacity: 0,
+  transition: "opacity 0.15s"
+};
+var removeButtonVisibleStyles = {
+  opacity: 1
+};
+var clearButtonStyles = {
+  display: "block",
+  width: "100%",
+  padding: "10px 16px",
+  backgroundColor: "transparent",
+  color: "#a1a1aa",
+  border: "none",
+  borderTop: "1px solid #27272a",
+  fontSize: "12px",
+  cursor: "pointer",
+  textAlign: "center",
+  transition: "color 0.15s"
+};
+var clearButtonHoverStyles = {
+  color: "#ffffff"
+};
+function ChevronIcon({ down }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      style: {
+        transition: "transform 0.2s",
+        transform: down ? "rotate(0deg)" : "rotate(-90deg)"
+      },
+      children: /* @__PURE__ */ jsx2("path", { d: "m6 9 6 6 6-6" })
+    }
+  );
+}
+function BatchQueueWidget({ onSignAll }) {
+  const {
+    queue,
+    batchChainId,
+    removeFromBatch,
+    clearBatch,
+    isExpanded,
+    setExpanded,
+    isSigning,
+    animationTrigger
+  } = useBatchQueue();
+  const [hoveredItemId, setHoveredItemId] = React2.useState(null);
+  const [isSignAllHovered, setIsSignAllHovered] = React2.useState(false);
+  const [isClearHovered, setIsClearHovered] = React2.useState(false);
+  const [shouldAnimate, setShouldAnimate] = React2.useState(false);
+  React2.useEffect(() => {
+    injectStyles();
+  }, []);
+  React2.useEffect(() => {
+    if (animationTrigger > 0) {
+      setShouldAnimate(true);
+      const timer = setTimeout(() => setShouldAnimate(false), 300);
+      return () => clearTimeout(timer);
+    }
+  }, [animationTrigger]);
+  if (queue.length === 0) {
+    return null;
+  }
+  const handleHeaderClick = () => {
+    setExpanded(!isExpanded);
+  };
+  const handleSignAllClick = (e) => {
+    e.stopPropagation();
+    if (!isSigning) {
+      onSignAll();
+    }
+  };
+  const animatedWidgetStyles = {
+    ...widgetStyles,
+    animation: shouldAnimate ? "batch-bounce-in 0.3s ease-out" : void 0
+  };
+  const currentSignAllStyles = {
+    ...signAllButtonStyles,
+    ...isSignAllHovered && !isSigning ? signAllButtonHoverStyles : {},
+    ...isSigning ? signAllButtonDisabledStyles : {}
+  };
+  return /* @__PURE__ */ jsxs("div", { style: animatedWidgetStyles, children: [
+    /* @__PURE__ */ jsxs("div", { style: headerStyles, onClick: handleHeaderClick, children: [
+      /* @__PURE__ */ jsxs("div", { style: headerLeftStyles, children: [
+        /* @__PURE__ */ jsx2(ChevronIcon, { down: isExpanded }),
+        /* @__PURE__ */ jsx2("span", { style: counterBadgeStyles, children: queue.length }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          "call",
+          queue.length !== 1 ? "s" : "",
+          " queued"
+        ] }),
+        batchChainId && /* @__PURE__ */ jsx2("span", { style: chainBadgeStyles, children: getChainName2(batchChainId) })
+      ] }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          style: currentSignAllStyles,
+          onClick: handleSignAllClick,
+          onMouseEnter: () => setIsSignAllHovered(true),
+          onMouseLeave: () => setIsSignAllHovered(false),
+          disabled: isSigning,
+          children: isSigning ? "Signing..." : "Sign All"
+        }
+      )
+    ] }),
+    isExpanded && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx2("div", { style: listContainerStyles, children: queue.map((item, index) => {
+        const isHovered = hoveredItemId === item.id;
+        const isLast = index === queue.length - 1;
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              ...callItemStyles,
+              ...isLast ? callItemLastStyles : {},
+              paddingLeft: isHovered ? "36px" : "16px",
+              transition: "padding-left 0.15s"
+            },
+            onMouseEnter: () => setHoveredItemId(item.id),
+            onMouseLeave: () => setHoveredItemId(null),
+            children: [
+              /* @__PURE__ */ jsx2(
+                "button",
+                {
+                  style: {
+                    ...removeButtonStyles,
+                    ...isHovered ? removeButtonVisibleStyles : {}
+                  },
+                  onClick: () => removeFromBatch(item.id),
+                  title: "Remove from batch",
+                  children: "\xD7"
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { style: callContentStyles, children: [
+                /* @__PURE__ */ jsx2("div", { style: callLabelStyles, children: item.call.label || "Contract Call" }),
+                item.call.sublabel && /* @__PURE__ */ jsx2("div", { style: callSublabelStyles, children: item.call.sublabel }),
+                !item.call.sublabel && item.call.to && /* @__PURE__ */ jsxs("div", { style: callSublabelStyles, children: [
+                  "To: ",
+                  item.call.to.slice(0, 6),
+                  "...",
+                  item.call.to.slice(-4)
+                ] })
+              ] })
+            ]
+          },
+          item.id
+        );
+      }) }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          style: {
+            ...clearButtonStyles,
+            ...isClearHovered ? clearButtonHoverStyles : {}
+          },
+          onClick: clearBatch,
+          onMouseEnter: () => setIsClearHovered(true),
+          onMouseLeave: () => setIsClearHovered(false),
+          children: "Clear batch"
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/verify.ts
+import { keccak256, toBytes } from "viem";
+var PASSKEY_MESSAGE_PREFIX = "Passkey Signed Message:\n";
+function hashMessage2(message) {
+  const prefixed = PASSKEY_MESSAGE_PREFIX + message.length.toString() + message;
+  return keccak256(toBytes(prefixed));
+}
+function verifyMessageHash(message, signedHash) {
+  if (!signedHash) return false;
+  const expectedHash = hashMessage2(message);
+  return expectedHash.toLowerCase() === signedHash.toLowerCase();
+}
+export {
+  BatchQueueProvider,
+  BatchQueueWidget,
+  PASSKEY_MESSAGE_PREFIX,
+  PasskeyProviderClient,
+  createPasskeyAccount,
+  createPasskeyProvider,
+  createPasskeyWalletClient,
+  encodeWebAuthnSignature,
+  getAllSupportedChainsAndTokens,
+  getChainById,
+  getChainExplorerUrl,
+  getChainName2 as getChainName,
+  getChainRpcUrl,
+  getSupportedChainIds,
+  getSupportedChains,
+  getSupportedTokenSymbols,
+  getSupportedTokens,
+  getTokenAddress,
+  getTokenDecimals,
+  getTokenSymbol,
+  hashCalls,
+  hashMessage2 as hashMessage,
+  isTestnet,
+  isTokenAddressSupported,
+  resolveTokenAddress,
+  useBatchQueue,
+  verifyMessageHash
+};
+//# sourceMappingURL=index.mjs.map