@coinbase/cdp-core 0.0.98 → 0.0.99

package/dist/types/viem/signAndWrapTypedData.d.ts

@@ -1,20 +1,127 @@
 import { Hash } from 'viem';
 import { EvmAddress, Hex, EIP712TypedData } from '../types.js';
+/**
+ * Options for signing and wrapping EIP-712 typed data with a smart account.
+ */
 export interface SignAndWrapTypedDataForSmartAccountOptions {
+    /** The smart account to sign with. */
     smartAccount: EvmAddress;
+    /** The owner address to sign with. */
     ownerAddress: EvmAddress;
+    /** The hash to sign. */
     hash: Hash;
+    /** The chain ID to sign with. */
     chainId: number;
 }
+/**
+ * Result of signing and wrapping typed data for a smart account.
+ */
 export interface SignAndWrapTypedDataForSmartAccountResult {
+    /** The signature ready for smart contract use. */
     signature: Hex;
 }
+/**
+ * Signs and wraps an EIP-712 message for a smart account using the required Coinbase Smart Wallet signature format.
+ *
+ * **Important: Coinbase Smart Wallet Contract Requirements**
+ *
+ * Due to the Coinbase Smart Wallet contract implementation (ERC-1271), CDP Smart Wallets have
+ * specific requirements for EIP-712 message signing:
+ *
+ * 1. **Replay-Safe Hashing**: All typed messages must be wrapped in a replay-safe hash that
+ *    includes the chain ID and smart account address. This prevents the same signature from
+ *    being valid across different chains or accounts.
+ *
+ * 2. **Signature Wrapping**: The resulting signature must be wrapped in a `SignatureWrapper`
+ *    struct that identifies which owner signed and contains the signature data in the format
+ *    expected by the smart contract's `isValidSignature()` method.
+ *
+ * This function handles both requirements automatically, making it safe and convenient for
+ * developers to sign EIP-712 messages with CDP Smart Wallets.
+ *
+ * @param {SignAndWrapTypedDataForSmartAccountOptions} options - Parameters for signing and wrapping the EIP-712 message.
+ * @returns A promise that resolves to the signature that can be used with smart contracts.
+ *
+ * @example
+ * ```ts
+ * const result = await signAndWrapTypedDataForSmartAccount({
+ *   smartAccount: smartAccount,
+ *   chainId: 1n,
+ *   ownerAddress: ownerAddress,
+ *   typedData: {
+ *     domain: {
+ *       name: "Permit2",
+ *       chainId: 1,
+ *       verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+ *     },
+ *     types: {
+ *       EIP712Domain: [
+ *         { name: "name", type: "string" },
+ *         { name: "chainId", type: "uint256" },
+ *         { name: "verifyingContract", type: "address" },
+ *       ],
+ *       PermitTransferFrom: [
+ *         { name: "permitted", type: "TokenPermissions" },
+ *         { name: "spender", type: "address" },
+ *         { name: "nonce", type: "uint256" },
+ *         { name: "deadline", type: "uint256" },
+ *       ],
+ *       TokenPermissions: [
+ *         { name: "token", type: "address" },
+ *         { name: "amount", type: "uint256" },
+ *       ],
+ *     },
+ *     primaryType: "PermitTransferFrom",
+ *     message: {
+ *       permitted: {
+ *         token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *         amount: "1000000",
+ *       },
+ *       spender: "0xFfFfFfFFfFFfFFfFFfFFFFFffFFFffffFfFFFfFf",
+ *       nonce: "0",
+ *       deadline: "1717123200",
+ *     },
+ *   },
+ * });
+ *
+ * // Use result.signature for smart contract calls
+ * console.log(`Signature: ${result.signature}`);
+ * ```
+ */
 export declare function signAndWrapTypedDataForSmartAccount(options: SignAndWrapTypedDataForSmartAccountOptions): Promise<SignAndWrapTypedDataForSmartAccountResult>;
+/**
+ * Creates a replay-safe EIP-712 typed data structure by wrapping the original typed data with
+ * chain ID and smart account address.
+ *
+ * **Coinbase Smart Wallet Requirement**: Due to the Coinbase Smart Wallet contract's ERC-1271
+ * implementation, all EIP-712 messages must be wrapped in a replay-safe hash before signing.
+ * This prevents signature replay attacks across different chains or smart account addresses.
+ *
+ * The smart contract's `isValidSignature()` method expects signatures to be validated against
+ * this replay-safe hash, not the original message hash.
+ *
+ * @param params - The replay-safe hash parameters
+ * @param params.hash - The hash to sign
+ * @param params.chainId - The chain ID to sign with
+ * @param params.smartAccountAddress - The smart account address for additional context
+ * @returns The EIP-712 typed data structure for the replay-safe hash
+ */
 export declare function createReplaySafeTypedData({ hash, chainId, smartAccountAddress, }: {
     hash: Hash;
     chainId: number;
     smartAccountAddress: EvmAddress;
 }): EIP712TypedData;
+/**
+ * Builds a signature wrapper for Coinbase Smart Wallets by decomposing a hex signature
+ * into r, s, v components and encoding them in the format expected by the smart contract.
+ *
+ * All signatures on Coinbase Smart Wallets must be wrapped in this format to identify
+ * which owner signed and provide the signature data.
+ *
+ * @param params - The signature parameters
+ * @param params.signatureHex - The hex signature to wrap (65 bytes: r + s + v)
+ * @returns The encoded signature wrapper in the format expected by the smart contract
+ */
 export declare function createSmartAccountSignatureWrapper({ signatureHex }: {
     signatureHex: Hex;
 }): Hex;

package/dist/types/viem/toViemAccount.d.ts

@@ -1,2 +1,17 @@
 import { Address, LocalAccount } from 'viem';
+/**
+ * Converts a CDP EVM account into a Viem-compatible LocalAccount.
+ * This enables the CDP account to be used with any library or framework that accepts Viem accounts.
+ *
+ * @param address - The EVM address to create a Viem account for
+ * @returns A Viem LocalAccount that can sign messages and transactions using CDP's signing functions
+ * @throws If the user is not authenticated or the address is not in the user's EVM accounts
+ *
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user.evmAccountObjects[0]?.address;
+ * const viemAccount = await toViemAccount(evmAccount);
+ * ```
+ */
 export declare function toViemAccount(address: Address): LocalAccount;

package/dist/web/index.web.js

@@ -4,8 +4,8 @@ import { setPlatformServices as o } from "./index.web4.js";
 import { webCrypto as e } from "./index.web5.js";
 import { webOAuth as t } from "./index.web6.js";
 import { webStorage as m } from "./index.web7.js";
-import { VERSION as n } from "./index.web8.js";
-import { initialize as S } from "./index.web9.js";
+import { VERSION as a } from "./index.web8.js";
+import { initialize as d } from "./index.web9.js";
 import { signInWithEmail as A } from "./index.web10.js";
 import { signInWithSms as M } from "./index.web11.js";
 import { signInWithOAuth as h } from "./index.web12.js";
@@ -14,9 +14,9 @@ import { verifySmsOTP as C } from "./index.web14.js";
 import { verifyOAuth as R } from "./index.web15.js";
 import { verifyTelegramOAuth as y } from "./index.web16.js";
 import { authenticateWithJWT as k } from "./index.web17.js";
-import { getCurrentUser as N } from "./index.web18.js";
-import { isSignedIn as b } from "./index.web19.js";
-import { signOut as w } from "./index.web20.js";
+import { getCurrentUser as w } from "./index.web18.js";
+import { isSignedIn as V } from "./index.web19.js";
+import { signOut as W } from "./index.web20.js";
 import { getAccessToken as K } from "./index.web21.js";
 import { getAccessTokenExpiration as B } from "./index.web22.js";
 import { onAuthStateChange as X } from "./index.web23.js";
@@ -26,63 +26,65 @@ import { signEvmTransaction as Q } from "./index.web26.js";
 import { signEvmMessage as $ } from "./index.web27.js";
 import { signEvmTypedData as or } from "./index.web28.js";
 import { signSolanaTransaction as tr } from "./index.web29.js";
-import { signSolanaMessage as nr } from "./index.web30.js";
+import { signSolanaMessage as ar } from "./index.web30.js";
 import { sendEvmTransaction as ir } from "./index.web31.js";
 import { sendSolanaTransaction as pr } from "./index.web32.js";
 import { sendUserOperation as xr } from "./index.web33.js";
 import { getUserOperation as cr } from "./index.web34.js";
-import { exportEvmAccount as gr } from "./index.web35.js";
-import { exportSolanaAccount as Sr } from "./index.web36.js";
+import { exportEvmAccount as lr } from "./index.web35.js";
+import { exportSolanaAccount as dr } from "./index.web36.js";
 import { createSpendPermission as Ar } from "./index.web37.js";
 import { listSpendPermissions as Mr } from "./index.web38.js";
-import { APIError as hr, ErrorType as Ir, EvmEip7702DelegationNetwork as Pr, HttpErrorType as _r, OAuth2ProviderType as Cr, SendEvmTransactionWithEndUserAccountBodyNetwork as Or, SendSolanaTransactionWithEndUserAccountBodyNetwork as Rr } from "@coinbase/cdp-api-client";
-import { revokeSpendPermission as yr } from "./index.web39.js";
-import { getCurrentUserSync as kr } from "./index.web40.js";
-import { fetchWithX402 as Nr } from "./index.web41.js";
+import { APIError as hr, ErrorType as Ir, EvmEip7702DelegationNetwork as Pr, EvmSwapsNetwork as _r, HttpErrorType as Cr, OAuth2ProviderType as Or, SendEvmTransactionWithEndUserAccountBodyNetwork as Rr, SendSolanaTransactionWithEndUserAccountBodyNetwork as Ur } from "@coinbase/cdp-api-client";
+import { revokeSpendPermission as Dr } from "./index.web39.js";
+import { getCurrentUserSync as Nr } from "./index.web40.js";
+import { fetchWithX402 as Fr } from "./index.web41.js";
 import { linkGoogle as br } from "./index.web42.js";
-import { linkSms as wr } from "./index.web43.js";
-import { linkEmail as Kr } from "./index.web44.js";
-import { linkOAuth as Br } from "./index.web45.js";
-import { linkApple as Xr } from "./index.web46.js";
-import { createEvmEoaAccount as qr } from "./index.web47.js";
-import { createEvmSmartAccount as Gr } from "./index.web48.js";
-import { createEvmEip7702Delegation as Qr } from "./index.web49.js";
-import { getEvmEip7702DelegationOperation as $r } from "./index.web50.js";
-import { waitForEvmEip7702Delegation as oo } from "./index.web51.js";
-import { createDelegation as to } from "./index.web52.js";
+import { linkSms as Hr } from "./index.web43.js";
+import { linkEmail as Yr } from "./index.web44.js";
+import { linkOAuth as Lr } from "./index.web45.js";
+import { linkApple as jr } from "./index.web46.js";
+import { createEvmEoaAccount as zr } from "./index.web47.js";
+import { createEvmSmartAccount as Jr } from "./index.web48.js";
+import { createEvmEip7702Delegation as Zr } from "./index.web49.js";
+import { getEvmEip7702DelegationOperation as ro } from "./index.web50.js";
+import { waitForEvmEip7702Delegation as eo } from "./index.web51.js";
+import { createDelegation as mo } from "./index.web52.js";
 import { revokeDelegation as no } from "./index.web53.js";
-import { createSolanaAccount as io } from "./index.web54.js";
-import { sendEvmEoaUsdc as po } from "./index.web55.js";
-import { sendEvmSmartAccountUsdc as xo } from "./index.web56.js";
-import { sendSolanaUsdc as co } from "./index.web57.js";
-import { sendUsdc as go } from "./index.web58.js";
-import { getMfaConfig as uo } from "./index.web59.js";
-import { getProjectConfig as To } from "./index.web60.js";
-import { getConfig as vo, getMfaConfigState as ho, getProjectConfigState as Io } from "./index.web61.js";
-import { recordMfaEnrollmentPrompted as _o } from "./index.web62.js";
-import { initiateMfaEnrollment as Oo } from "./index.web63.js";
-import { submitMfaEnrollment as Uo } from "./index.web64.js";
-import { initiateMfaVerification as Do } from "./index.web65.js";
-import { submitMfaVerification as Fo } from "./index.web66.js";
-import { cancelMfaVerification as Vo } from "./index.web67.js";
-import { registerMfaListener as Wo } from "./index.web68.js";
-import { getEnabledMfaMethods as Ho, getEnrolledMfaMethods as Ko, isEnrolledInMfa as Yo } from "./index.web69.js";
-import { isMfaRequired as Lo } from "./index.web70.js";
-import { MFA_PROTECTED_ACTIONS as jo, MFA_PROTECTED_FUNCTIONS as qo, isMfaProtectedAction as zo } from "./index.web71.js";
-import { AuthManager as Jo } from "./index.web72.js";
-import { CustomAuthError as Zo } from "./index.web73.js";
-import { toViemAccount as re } from "./index.web74.js";
-import { InputValidationError as ee, InternalError as te, MfaError as me, ModuleResolutionError as ne, ValidationError as ae } from "./index.web75.js";
-import { validatePhoneNumber as fe } from "./index.web76.js";
-import { createCDPEmbeddedWallet as Ee } from "./index.web77.js";
-import { EIP1193ProviderError as se, STANDARD_ERROR_CODES as ce } from "./index.web78.js";
+import { createSolanaAccount as fo } from "./index.web54.js";
+import { sendEvmEoaUsdc as Eo } from "./index.web55.js";
+import { sendEvmSmartAccountUsdc as so } from "./index.web56.js";
+import { sendSolanaUsdc as go } from "./index.web57.js";
+import { sendUsdc as So } from "./index.web58.js";
+import { getSwapPrice as Ao } from "./index.web59.js";
+import { executeSwap as Mo } from "./index.web60.js";
+import { getMfaConfig as ho } from "./index.web61.js";
+import { getProjectConfig as Po } from "./index.web62.js";
+import { getConfig as Co, getMfaConfigState as Oo, getProjectConfigState as Ro } from "./index.web63.js";
+import { recordMfaEnrollmentPrompted as yo } from "./index.web64.js";
+import { initiateMfaEnrollment as ko } from "./index.web65.js";
+import { submitMfaEnrollment as wo } from "./index.web66.js";
+import { initiateMfaVerification as Vo } from "./index.web67.js";
+import { submitMfaVerification as Wo } from "./index.web68.js";
+import { cancelMfaVerification as Ko } from "./index.web69.js";
+import { registerMfaListener as Bo } from "./index.web70.js";
+import { getEnabledMfaMethods as Xo, getEnrolledMfaMethods as jo, isEnrolledInMfa as qo } from "./index.web71.js";
+import { isMfaRequired as Go } from "./index.web72.js";
+import { MFA_PROTECTED_ACTIONS as Qo, MFA_PROTECTED_FUNCTIONS as Zo, isMfaProtectedAction as $o } from "./index.web73.js";
+import { AuthManager as oe } from "./index.web74.js";
+import { CustomAuthError as te } from "./index.web75.js";
+import { toViemAccount as ae } from "./index.web76.js";
+import { InputValidationError as ie, InternalError as fe, MfaError as pe, ModuleResolutionError as Ee, SwapError as xe, ValidationError as se } from "./index.web77.js";
+import { validatePhoneNumber as ge } from "./index.web78.js";
+import { createCDPEmbeddedWallet as Se } from "./index.web79.js";
+import { EIP1193ProviderError as ue, STANDARD_ERROR_CODES as Ae } from "./index.web80.js";
 import "viem";
 import "zustand";
-import { buildKeyExportIframeUrl as ge, calculateSecureIframeHeight as de, createIframe as Se, getSecureIframeOrigin as ue, isSecureIframeKeyExportMessage as Ae, sendSecureIframeMessage as Te, validateSecureIframeEnvironment as Me } from "./index.web79.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as he, DEFAULT_SECURE_IFRAME_THEME as Ie, SECURE_IFRAME_EVENT_TYPE as Pe, SECURE_IFRAME_EVENT_TYPE_PREFIX as _e, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as Ce } from "./index.web80.js";
-import { createEvmKeyExportIframe as Re, createSolanaKeyExportIframe as Ue } from "./index.web81.js";
-import { toTransactionSigner as De } from "./index.web82.js";
-r.registerPackageVersion("core", n);
+import { buildKeyExportIframeUrl as Me, calculateSecureIframeHeight as ve, createIframe as he, getSecureIframeOrigin as Ie, isSecureIframeKeyExportMessage as Pe, sendSecureIframeMessage as _e, validateSecureIframeEnvironment as Ce } from "./index.web81.js";
+import { DEFAULT_SECURE_IFRAME_BASE_PATH as Re, DEFAULT_SECURE_IFRAME_THEME as Ue, SECURE_IFRAME_EVENT_TYPE as ye, SECURE_IFRAME_EVENT_TYPE_PREFIX as De, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as ke } from "./index.web82.js";
+import { createEvmKeyExportIframe as we, createSolanaKeyExportIframe as Fe } from "./index.web83.js";
+import { toTransactionSigner as be } from "./index.web84.js";
+r.registerPackageVersion("core", a);
 o({
   crypto: e,
   storage: m,
@@ -90,86 +92,90 @@ o({
 });
 export {
   hr as APIError,
-  Jo as AuthManager,
-  Zo as CustomAuthError,
-  he as DEFAULT_SECURE_IFRAME_BASE_PATH,
-  Ie as DEFAULT_SECURE_IFRAME_THEME,
-  se as EIP1193ProviderError,
+  oe as AuthManager,
+  te as CustomAuthError,
+  Re as DEFAULT_SECURE_IFRAME_BASE_PATH,
+  Ue as DEFAULT_SECURE_IFRAME_THEME,
+  ue as EIP1193ProviderError,
   Ir as ErrorType,
   Pr as EvmEip7702DelegationNetwork,
-  _r as HttpErrorType,
-  ee as InputValidationError,
-  te as InternalError,
-  jo as MFA_PROTECTED_ACTIONS,
-  qo as MFA_PROTECTED_FUNCTIONS,
-  me as MfaError,
-  ne as ModuleResolutionError,
-  Cr as OAuth2ProviderType,
-  Pe as SECURE_IFRAME_EVENT_TYPE,
-  _e as SECURE_IFRAME_EVENT_TYPE_PREFIX,
-  Ce as SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE,
-  ce as STANDARD_ERROR_CODES,
-  Or as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  Rr as SendSolanaTransactionWithEndUserAccountBodyNetwork,
-  ae as ValidationError,
+  _r as EvmSwapsNetwork,
+  Cr as HttpErrorType,
+  ie as InputValidationError,
+  fe as InternalError,
+  Qo as MFA_PROTECTED_ACTIONS,
+  Zo as MFA_PROTECTED_FUNCTIONS,
+  pe as MfaError,
+  Ee as ModuleResolutionError,
+  Or as OAuth2ProviderType,
+  ye as SECURE_IFRAME_EVENT_TYPE,
+  De as SECURE_IFRAME_EVENT_TYPE_PREFIX,
+  ke as SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE,
+  Ae as STANDARD_ERROR_CODES,
+  Rr as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  Ur as SendSolanaTransactionWithEndUserAccountBodyNetwork,
+  xe as SwapError,
+  se as ValidationError,
   k as authenticateWithJWT,
-  ge as buildKeyExportIframeUrl,
-  de as calculateSecureIframeHeight,
-  Vo as cancelMfaVerification,
-  Ee as createCDPEmbeddedWallet,
-  to as createDelegation,
-  Qr as createEvmEip7702Delegation,
-  qr as createEvmEoaAccount,
-  Re as createEvmKeyExportIframe,
-  Gr as createEvmSmartAccount,
-  Se as createIframe,
-  io as createSolanaAccount,
-  Ue as createSolanaKeyExportIframe,
+  Me as buildKeyExportIframeUrl,
+  ve as calculateSecureIframeHeight,
+  Ko as cancelMfaVerification,
+  Se as createCDPEmbeddedWallet,
+  mo as createDelegation,
+  Zr as createEvmEip7702Delegation,
+  zr as createEvmEoaAccount,
+  we as createEvmKeyExportIframe,
+  Jr as createEvmSmartAccount,
+  he as createIframe,
+  fo as createSolanaAccount,
+  Fe as createSolanaKeyExportIframe,
   Ar as createSpendPermission,
-  gr as exportEvmAccount,
-  Sr as exportSolanaAccount,
-  Nr as fetchWithX402,
+  Mo as executeSwap,
+  lr as exportEvmAccount,
+  dr as exportSolanaAccount,
+  Fr as fetchWithX402,
   K as getAccessToken,
   B as getAccessTokenExpiration,
-  vo as getConfig,
-  N as getCurrentUser,
-  kr as getCurrentUserSync,
-  Ho as getEnabledMfaMethods,
-  Ko as getEnrolledMfaMethods,
-  $r as getEvmEip7702DelegationOperation,
-  uo as getMfaConfig,
-  ho as getMfaConfigState,
-  To as getProjectConfig,
-  Io as getProjectConfigState,
-  ue as getSecureIframeOrigin,
+  Co as getConfig,
+  w as getCurrentUser,
+  Nr as getCurrentUserSync,
+  Xo as getEnabledMfaMethods,
+  jo as getEnrolledMfaMethods,
+  ro as getEvmEip7702DelegationOperation,
+  ho as getMfaConfig,
+  Oo as getMfaConfigState,
+  Po as getProjectConfig,
+  Ro as getProjectConfigState,
+  Ie as getSecureIframeOrigin,
+  Ao as getSwapPrice,
   cr as getUserOperation,
-  S as initialize,
-  Oo as initiateMfaEnrollment,
-  Do as initiateMfaVerification,
-  Yo as isEnrolledInMfa,
-  zo as isMfaProtectedAction,
-  Lo as isMfaRequired,
-  Ae as isSecureIframeKeyExportMessage,
-  b as isSignedIn,
-  Xr as linkApple,
-  Kr as linkEmail,
+  d as initialize,
+  ko as initiateMfaEnrollment,
+  Vo as initiateMfaVerification,
+  qo as isEnrolledInMfa,
+  $o as isMfaProtectedAction,
+  Go as isMfaRequired,
+  Pe as isSecureIframeKeyExportMessage,
+  V as isSignedIn,
+  jr as linkApple,
+  Yr as linkEmail,
   br as linkGoogle,
-  Br as linkOAuth,
-  wr as linkSms,
+  Lr as linkOAuth,
+  Hr as linkSms,
   Mr as listSpendPermissions,
   X as onAuthStateChange,
   q as onOAuthStateChange,
-  _o as recordMfaEnrollmentPrompted,
-  Wo as registerMfaListener,
+  yo as recordMfaEnrollmentPrompted,
+  Bo as registerMfaListener,
   no as revokeDelegation,
-  yr as revokeSpendPermission,
-  po as sendEvmEoaUsdc,
-  xo as sendEvmSmartAccountUsdc,
+  Dr as revokeSpendPermission,
+  Eo as sendEvmEoaUsdc,
+  so as sendEvmSmartAccountUsdc,
   ir as sendEvmTransaction,
-  Te as sendSecureIframeMessage,
+  _e as sendSecureIframeMessage,
   pr as sendSolanaTransaction,
-  co as sendSolanaUsdc,
-  go as sendUsdc,
+  go as sendSolanaUsdc,
+  So as sendUsdc,
   xr as sendUserOperation,
   G as signEvmHash,
   $ as signEvmMessage,
@@ -178,18 +184,18 @@ export {
   A as signInWithEmail,
   h as signInWithOAuth,
   M as signInWithSms,
-  w as signOut,
-  nr as signSolanaMessage,
+  W as signOut,
+  ar as signSolanaMessage,
   tr as signSolanaTransaction,
-  Uo as submitMfaEnrollment,
-  Fo as submitMfaVerification,
-  De as toTransactionSigner,
-  re as toViemAccount,
-  fe as validatePhoneNumber,
-  Me as validateSecureIframeEnvironment,
+  wo as submitMfaEnrollment,
+  Wo as submitMfaVerification,
+  be as toTransactionSigner,
+  ae as toViemAccount,
+  ge as validatePhoneNumber,
+  Ce as validateSecureIframeEnvironment,
   P as verifyEmailOTP,
   R as verifyOAuth,
   C as verifySmsOTP,
   y as verifyTelegramOAuth,
-  oo as waitForEvmEip7702Delegation
+  eo as waitForEvmEip7702Delegation
 };

package/dist/web/index.web10.js

@@ -1,6 +1,6 @@
 import { Analytics as t } from "./index.web2.js";
 import "./index.web3.js";
-import { initiateSignIn as n } from "./index.web103.js";
+import { initiateSignIn as n } from "./index.web108.js";
 import "@coinbase/cdp-api-client";
 import "viem";
 const l = async (i) => (t.sendActionCallEvent({ name: "sign_in_with_email" }), n(