@rhinestone/1auth 0.1.0

package/dist/client-C1inywuT.d.mts

@@ -0,0 +1,777 @@
+/**
+ * Theme configuration for the dialog UI
+ */
+interface ThemeConfig {
+    /** Color mode: 'light', 'dark', or 'system' (follows user's OS preference) */
+    mode?: 'light' | 'dark' | 'system';
+    /** Primary accent color (hex). Used for buttons and interactive elements */
+    accent?: string;
+}
+interface PasskeyProviderConfig {
+    /** Base URL of the auth API (Next.js server) */
+    providerUrl: string;
+    /** Client identifier for this application */
+    clientId: string;
+    /** Optional redirect URL for redirect flow */
+    redirectUrl?: string;
+    /** Optional URL of the dialog UI (Vite app). Defaults to providerUrl + /dialog */
+    dialogUrl?: string;
+    /** Optional theme configuration for the dialog */
+    theme?: ThemeConfig;
+}
+interface LoginOptions {
+    username: string;
+}
+interface LoginResult {
+    success: boolean;
+    username?: string;
+    user?: {
+        id: string;
+        username: string;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface RegisterOptions {
+    username: string;
+}
+interface RegisterResult {
+    success: boolean;
+    username?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Options for the authenticate() method
+ */
+interface AuthenticateOptions {
+    /**
+     * Human-readable challenge message for the user to sign.
+     * The provider will hash this with a domain separator to prevent
+     * the signature from being reused for transaction signing.
+     */
+    challenge?: string;
+}
+/**
+ * Result of the authenticate() method
+ */
+interface AuthenticateResult {
+    success: boolean;
+    username?: string;
+    user?: {
+        id: string;
+        username: string;
+    };
+    /**
+     * The user's smart account address (derived from their passkey).
+     */
+    accountAddress?: `0x${string}`;
+    /**
+     * Signature of the hashed challenge.
+     * Only present if a challenge was provided in the options.
+     */
+    signature?: WebAuthnSignature;
+    /**
+     * The hash that was actually signed (so apps can verify server-side).
+     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + challenge)
+     */
+    signedHash?: `0x${string}`;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Options for signMessage
+ */
+interface SignMessageOptions {
+    /** Username of the signer */
+    username: string;
+    /** Human-readable message to sign */
+    message: string;
+    /** Optional custom challenge (defaults to message hash) */
+    challenge?: string;
+    /** Description shown to user in the dialog */
+    description?: string;
+    /** Optional metadata to display to the user */
+    metadata?: Record<string, unknown>;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+}
+/**
+ * Result of signMessage
+ */
+interface SignMessageResult {
+    success: boolean;
+    /** WebAuthn signature if successful */
+    signature?: WebAuthnSignature;
+    /** The message that was signed */
+    signedMessage?: string;
+    /**
+     * The hash that was actually signed (with domain separator).
+     * Computed as: keccak256("\x19Passkey Signed Message:\n" + len + message)
+     * Use hashMessage() from the SDK to verify this matches your original message.
+     */
+    signedHash?: `0x${string}`;
+    /** Passkey credentials used for signing */
+    passkey?: PasskeyCredentials;
+    /** Error details if failed */
+    error?: {
+        code: SigningErrorCode;
+        message: string;
+    };
+}
+interface TransactionAction {
+    type: 'send' | 'receive' | 'approve' | 'swap' | 'mint' | 'custom';
+    label: string;
+    sublabel?: string;
+    amount?: string;
+    icon?: string;
+}
+interface TransactionFees {
+    estimated: string;
+    network: {
+        name: string;
+        icon?: string;
+    };
+}
+interface BalanceRequirement {
+    token: string;
+    amount: string;
+    faucetUrl?: string;
+}
+interface TransactionDetails {
+    actions: TransactionAction[];
+    fees?: TransactionFees;
+    requiredBalance?: BalanceRequirement;
+    account?: {
+        address: string;
+        label?: string;
+    };
+}
+interface SigningRequestOptions {
+    challenge: string;
+    username: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    transaction?: TransactionDetails;
+}
+interface PasskeyCredential {
+    id: string;
+    deviceName: string | null;
+    publicKeyX: string;
+    publicKeyY: string;
+}
+interface UserPasskeysResponse {
+    passkeys: PasskeyCredential[];
+}
+interface WebAuthnSignature {
+    authenticatorData: string;
+    clientDataJSON: string;
+    challengeIndex: number;
+    typeIndex: number;
+    r: string;
+    s: string;
+    topOrigin: string | null;
+}
+interface PasskeyCredentials {
+    credentialId: string;
+    publicKeyX: string;
+    publicKeyY: string;
+}
+interface SigningSuccess {
+    success: true;
+    requestId?: string;
+    signature: WebAuthnSignature;
+    passkey?: PasskeyCredentials;
+}
+type SigningErrorCode = "USER_REJECTED" | "EXPIRED" | "INVALID_REQUEST" | "NETWORK_ERROR" | "POPUP_BLOCKED" | "SIGNING_FAILED" | "UNKNOWN";
+interface EmbedOptions {
+    container: HTMLElement;
+    width?: string;
+    height?: string;
+    onReady?: () => void;
+    onClose?: () => void;
+}
+interface SigningError {
+    success: false;
+    requestId?: string;
+    error: {
+        code: SigningErrorCode;
+        message: string;
+    };
+}
+type SigningResult = SigningSuccess | SigningError;
+interface CreateSigningRequestResponse {
+    requestId: string;
+    nonce: string;
+    signingUrl: string;
+    expiresAt: string;
+}
+interface SigningRequestStatus {
+    id: string;
+    status: "PENDING" | "COMPLETED" | "REJECTED" | "EXPIRED" | "FAILED";
+    signature?: WebAuthnSignature;
+    error?: {
+        code: SigningErrorCode;
+        message: string;
+    };
+}
+/**
+ * A call to execute on the target chain
+ */
+interface IntentCall {
+    /** Target contract address */
+    to: string;
+    /** Calldata to send */
+    data?: string;
+    /** Value in wei (as string for serialization) */
+    value?: string;
+    /** Optional label for the transaction review UI */
+    label?: string;
+    /** Optional sublabel for additional context */
+    sublabel?: string;
+}
+/**
+ * Token request for the intent
+ */
+interface IntentTokenRequest {
+    /** Token contract address */
+    token: string;
+    /** Amount (as string for serialization) */
+    amount: string;
+}
+/**
+ * A signed intent request from a merchant backend
+ * This provides XSS protection by ensuring calls were constructed server-side
+ */
+interface MerchantSignedIntent {
+    /** Merchant ID (from seed/registration) */
+    merchantId: string;
+    /** Target chain ID */
+    targetChain: number;
+    /** Calls to execute (signed by merchant) */
+    calls: IntentCall[];
+    /** Username of the signer */
+    username?: string;
+    /** Alternative to username: account address */
+    accountAddress?: string;
+    /** Unique nonce for replay protection */
+    nonce: string;
+    /** Expiry timestamp (Unix ms) */
+    expiresAt: number;
+    /** Ed25519 signature over the canonical message (base64) */
+    signature: string;
+    /** Optional client ID */
+    clientId?: string;
+    /** Optional token requests */
+    tokenRequests?: IntentTokenRequest[];
+}
+/**
+ * Options for sendIntent
+ */
+interface SendIntentOptions {
+    /** Username of the signer (for unsigned requests) */
+    username?: string;
+    /** Target chain ID (for unsigned requests) */
+    targetChain?: number;
+    /** Calls to execute on the target chain (for unsigned requests) */
+    calls?: IntentCall[];
+    /** Optional token requests (for unsigned requests) */
+    tokenRequests?: IntentTokenRequest[];
+    /**
+     * Constrain which tokens can be used as input/payment.
+     * If not specified, orchestrator picks from all available balances.
+     * Example: ['USDC'] or ['0x...'] to only use USDC as input.
+     */
+    sourceAssets?: string[];
+    /** When to close the dialog and return success. Defaults to "preconfirmed" */
+    closeOn?: CloseOnStatus;
+    /**
+     * Pre-signed intent from merchant backend (XSS protected)
+     * If provided, username/targetChain/calls/tokenRequests are ignored
+     */
+    signedIntent?: MerchantSignedIntent;
+    /**
+     * Wait for a transaction hash before resolving.
+     * Defaults to false to preserve existing behavior.
+     */
+    waitForHash?: boolean;
+    /** Maximum time to wait for a transaction hash in ms. */
+    hashTimeoutMs?: number;
+    /** Poll interval for transaction hash in ms. */
+    hashIntervalMs?: number;
+}
+/**
+ * Quote from the Rhinestone orchestrator
+ */
+interface IntentQuote {
+    /** Total cost in input tokens */
+    cost: {
+        total: string;
+        breakdown?: {
+            gas?: string;
+            bridge?: string;
+            swap?: string;
+        };
+    };
+    /** Token requirements to fulfill the intent */
+    tokenRequirements: Array<{
+        token: string;
+        amount: string;
+        chainId: number;
+    }>;
+}
+/**
+ * Status of an intent (local states)
+ */
+type IntentStatus = "pending" | "quoted" | "signed" | "submitted" | "completed" | "failed" | "expired";
+/**
+ * Orchestrator status (from Rhinestone)
+ * These are the statuses we can receive when polling
+ */
+type OrchestratorStatus = "PENDING" | "CLAIMED" | "PRECONFIRMED" | "FILLED" | "COMPLETED" | "FAILED" | "EXPIRED";
+/**
+ * When to consider the transaction complete and close the dialog
+ * - "claimed" - Close when a solver has claimed the intent (fastest)
+ * - "preconfirmed" - Close on pre-confirmation (recommended)
+ * - "filled" - Close when the transaction is filled
+ * - "completed" - Wait for full completion (slowest, most certain)
+ */
+type CloseOnStatus = "claimed" | "preconfirmed" | "filled" | "completed";
+/**
+ * Result of sendIntent
+ */
+interface SendIntentResult {
+    /** Whether the intent was successfully submitted */
+    success: boolean;
+    /** Intent ID for tracking */
+    intentId: string;
+    /** Current status */
+    status: IntentStatus;
+    /** Transaction hash if completed */
+    transactionHash?: string;
+    /** Operation ID from orchestrator */
+    operationId?: string;
+    /** Error details if failed */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Prepare intent response from auth service
+ */
+interface PrepareIntentResponse {
+    intentId: string;
+    quote: IntentQuote;
+    transaction: TransactionDetails;
+    challenge: string;
+    expiresAt: string;
+    /** Account address for the sign dialog to detect self-transfer vs external send */
+    accountAddress?: string;
+}
+/**
+ * Execute intent response from auth service
+ */
+interface ExecuteIntentResponse {
+    success: boolean;
+    intentId: string;
+    operationId?: string;
+    status: IntentStatus;
+    transactionHash?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Options for sendSwap - high-level swap abstraction
+ */
+interface SendSwapOptions {
+    /** Username of the signer */
+    username: string;
+    /** Target chain ID where swap executes */
+    targetChain: number;
+    /** Token to swap from (address or supported symbol like 'ETH', 'USDC') */
+    fromToken: string;
+    /** Token to swap to (address or supported symbol) */
+    toToken: string;
+    /** Amount to swap in human-readable format (e.g., "0.1") */
+    amount: string;
+    /** Maximum slippage in basis points (1 bp = 0.01%). Default: 50 (0.5%) */
+    slippageBps?: number;
+    /**
+     * Override source assets for the swap. If not specified, defaults to [fromToken].
+     * This constrains which tokens the orchestrator can use as input.
+     */
+    sourceAssets?: string[];
+    /** When to close the dialog. Defaults to "preconfirmed" */
+    closeOn?: CloseOnStatus;
+    /** Wait for a transaction hash before resolving. */
+    waitForHash?: boolean;
+    /** Maximum time to wait for a transaction hash in ms. */
+    hashTimeoutMs?: number;
+    /** Poll interval for transaction hash in ms. */
+    hashIntervalMs?: number;
+}
+/**
+ * Quote information from DEX aggregator
+ */
+interface SwapQuote {
+    /** Token being sold */
+    fromToken: string;
+    /** Token being bought */
+    toToken: string;
+    /** Amount of fromToken being sold */
+    amountIn: string;
+    /** Amount of toToken being received */
+    amountOut: string;
+    /** Exchange rate (amountOut / amountIn) */
+    rate: string;
+    /** Price impact percentage (if available) */
+    priceImpact?: string;
+}
+/**
+ * Result of sendSwap - extends SendIntentResult with swap-specific data
+ */
+interface SendSwapResult extends SendIntentResult {
+    /** The swap quote that was executed */
+    quote?: SwapQuote;
+}
+/**
+ * EIP-712 Domain parameters
+ */
+interface EIP712Domain {
+    /** Name of the signing domain (e.g., "Dai Stablecoin") */
+    name: string;
+    /** Version of the signing domain (e.g., "1") */
+    version: string;
+    /** Chain ID (optional) */
+    chainId?: number;
+    /** Verifying contract address (optional) */
+    verifyingContract?: `0x${string}`;
+    /** Salt for disambiguation (optional) */
+    salt?: `0x${string}`;
+}
+/**
+ * EIP-712 Type field definition
+ */
+interface EIP712TypeField {
+    /** Field name */
+    name: string;
+    /** Solidity type (e.g., "address", "uint256", "bytes32") */
+    type: string;
+}
+/**
+ * EIP-712 Types map - maps type names to their field definitions
+ */
+type EIP712Types = {
+    [typeName: string]: EIP712TypeField[];
+};
+/**
+ * Options for signTypedData
+ */
+interface SignTypedDataOptions {
+    /** Username of the signer */
+    username: string;
+    /** EIP-712 domain parameters */
+    domain: EIP712Domain;
+    /** Type definitions for all types used in the message */
+    types: EIP712Types;
+    /** Primary type being signed (must be a key in types) */
+    primaryType: string;
+    /** Message values matching the primaryType structure */
+    message: Record<string, unknown>;
+    /** Optional description shown in the dialog */
+    description?: string;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+}
+/**
+ * Result of signTypedData
+ */
+interface SignTypedDataResult {
+    success: boolean;
+    /** WebAuthn signature if successful */
+    signature?: WebAuthnSignature;
+    /** The EIP-712 hash that was signed */
+    signedHash?: `0x${string}`;
+    /** Passkey credentials used for signing */
+    passkey?: PasskeyCredentials;
+    /** Error details if failed */
+    error?: {
+        code: SigningErrorCode;
+        message: string;
+    };
+}
+
+declare class PasskeyProviderClient {
+    private config;
+    private theme;
+    constructor(config: PasskeyProviderConfig);
+    /**
+     * Update the theme configuration at runtime
+     */
+    setTheme(theme: ThemeConfig): void;
+    /**
+     * Build theme URL parameters
+     */
+    private getThemeParams;
+    /**
+     * Get the dialog URL (Vite app URL)
+     * Defaults to providerUrl if dialogUrl is not set
+     */
+    private getDialogUrl;
+    /**
+     * Get the origin for message validation
+     * Uses dialogUrl origin if set, otherwise providerUrl origin
+     */
+    private getDialogOrigin;
+    /**
+     * Get the base provider URL
+     */
+    getProviderUrl(): string;
+    /**
+     * Get the configured client ID
+     */
+    getClientId(): string;
+    private waitForTransactionHash;
+    /**
+     * Show Porto-style "Get started" auth dialog (combines sign in + sign up)
+     * This is the recommended method for authentication - shows a modal overlay
+     * with both sign in and create account options.
+     */
+    authWithModal(options?: {
+        username?: string;
+        theme?: ThemeConfig;
+        oauthEnabled?: boolean;
+    }): Promise<LoginResult | RegisterResult>;
+    /**
+     * 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
+     *   );
+     * }
+     * ```
+     */
+    authenticate(options?: AuthenticateOptions & {
+        theme?: ThemeConfig;
+    }): Promise<AuthenticateResult>;
+    /**
+     * Show signing in a modal overlay (Porto-style iframe dialog)
+     */
+    signWithModal(options: SigningRequestOptions & {
+        theme?: ThemeConfig;
+    }): Promise<SigningResult>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    sendIntent(options: SendIntentOptions): Promise<SendIntentResult>;
+    /**
+     * Send transaction status to the dialog iframe
+     */
+    private sendTransactionStatus;
+    /**
+     * Wait for the signing result without closing the modal
+     */
+    private waitForIntentSigningResponse;
+    /**
+     * Wait for signing result (simplified - no requestId matching)
+     */
+    private waitForSigningResponse;
+    /**
+     * Wait for the dialog to be closed
+     */
+    private waitForDialogClose;
+    /**
+     * Poll for intent status
+     *
+     * Use this to check on the status of a submitted intent
+     * that hasn't completed yet.
+     */
+    getIntentStatus(intentId: string): Promise<SendIntentResult>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    sendSwap(options: SendSwapOptions): Promise<SendSwapResult>;
+    /**
+     * 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,
+     *     }),
+     *   });
+     * }
+     * ```
+     */
+    signMessage(options: SignMessageOptions): Promise<SignMessageResult>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    signTypedData(options: SignTypedDataOptions): Promise<SignTypedDataResult>;
+    signWithPopup(options: SigningRequestOptions): Promise<SigningResult>;
+    signWithRedirect(options: SigningRequestOptions, redirectUrl?: string): Promise<void>;
+    signWithEmbed(options: SigningRequestOptions, embedOptions: EmbedOptions): Promise<SigningResult>;
+    private createEmbed;
+    private waitForEmbedResponse;
+    removeEmbed(requestId: string): void;
+    handleRedirectCallback(): Promise<SigningResult>;
+    /**
+     * Fetch passkeys for a user from the auth provider
+     */
+    getPasskeys(username: string): Promise<PasskeyCredential[]>;
+    private createSigningRequest;
+    private openPopup;
+    /**
+     * Create a modal dialog with an iframe inside (Porto-style overlay)
+     */
+    private createModalDialog;
+    private waitForModalAuthResponse;
+    private waitForAuthenticateResponse;
+    private waitForModalSigningResponse;
+    private waitForPopupResponse;
+    private fetchSigningResult;
+}
+
+export { type AuthenticateOptions as A, type BalanceRequirement as B, type CreateSigningRequestResponse as C, type ExecuteIntentResponse as D, type EmbedOptions as E, type SendSwapOptions as F, type SendSwapResult as G, type SwapQuote as H, type IntentCall as I, type ThemeConfig as J, type LoginOptions as L, type MerchantSignedIntent as M, type OrchestratorStatus as O, PasskeyProviderClient as P, type RegisterOptions as R, type SendIntentResult as S, type TransactionAction as T, type UserPasskeysResponse as U, type WebAuthnSignature as W, type PasskeyProviderConfig as a, type SigningRequestOptions as b, type SigningResult as c, type SigningSuccess as d, type SigningError as e, type SigningErrorCode as f, type SigningRequestStatus as g, type PasskeyCredential as h, type RegisterResult as i, type LoginResult as j, type AuthenticateResult as k, type SignMessageOptions as l, type SignMessageResult as m, type SignTypedDataOptions as n, type SignTypedDataResult as o, type EIP712Domain as p, type EIP712Types as q, type EIP712TypeField as r, type TransactionFees as s, type TransactionDetails as t, type IntentTokenRequest as u, type SendIntentOptions as v, type IntentQuote as w, type IntentStatus as x, type CloseOnStatus as y, type PrepareIntentResponse as z };