@coinbase/cdp-core 0.0.98 → 0.0.100

package/dist/native-types/auth/customAuthManager.d.ts

@@ -1,10 +1,56 @@
 import { AuthManager } from './authManager.js';
+/**
+ * The number of milliseconds before the expiration time of credentials
+ * that we should refresh the credentials for custom auth.
+ * This can be any number as long as it's some time in the future
+ * to prevent the wallet secret from being infinitely refreshed.
+ * We use 1 hour as a reasonable default.
+ */
 export declare const CUSTOM_AUTH_REFRESH_BUFFER_MS: number;
+/**
+ * AuthManager for custom authentication flows where JWTs are provided
+ * by an external identity provider via the customAuth.getJwt callback.
+ *
+ * This manager extends AuthManager and overrides key methods to:
+ * - Skip automatic token refresh (tokens are always fresh from the callback)
+ * - Fetch fresh JWTs on each getToken() call via customAuth.getJwt
+ * - Disable scheduled token refresh (not needed for custom auth)
+ */
 export declare class CustomAuthManager extends AuthManager {
+    /**
+     * Signs out the user, clearing all authentication state.
+     * For custom auth, we only clear local state without calling the CDP logout API,
+     * as authentication is managed by the external identity provider.
+     */
     signOut(): Promise<void>;
+    /**
+     * Gets the access token by calling the customAuth.getJwt callback.
+     * Returns null if the user is not signed in.
+     *
+     * @returns The access token from the custom auth provider.
+     */
     getToken(): Promise<string | null>;
+    /**
+     * Internal async initialization logic for custom auth.
+     * No-op for custom auth since tokens are provided via customAuth.getJwt callback.
+     * Unlike standard CDP auth, custom auth doesn't need token refresh or OAuth handling.
+     */
     protected _doInitialize(): Promise<void>;
+    /**
+     * Custom auth always fetches fresh tokens, so never needs to "refresh" in the traditional sense.
+     *
+     * @returns Always false since custom auth doesn't use token refresh logic.
+     */
     protected shouldRefreshToken(): boolean;
+    /**
+     * Custom auth doesn't use CDP's token refresh mechanism.
+     * Tokens are always provided fresh from the customAuth.getJwt callback.
+     * This method should never be called, but we override it as a defensive measure.
+     */
     protected refreshAccessToken(): Promise<void>;
+    /**
+     * Custom auth provides fresh tokens on each request via customAuth.getJwt,
+     * so no scheduled refresh is needed. This method is a no-op for custom auth.
+     */
     protected scheduleTokenRefresh(): void;
 }

package/dist/native-types/auth/oAuthManager.d.ts

@@ -1,11 +1,39 @@
 import { OAuthFlowState, OnOAuthStateChangeFn } from '../types.js';
 import { IOAuthManager } from './types.js';
+/**
+ * Manages the OAuth flow state and related callbacks.
+ */
 export declare class OAuthManager implements IOAuthManager {
     private oauthFlowState;
     private oauthStateChangeCallbacks;
+    /**
+     * Adds a callback to be called when the OAuth state changes.
+     *
+     * @param callback - The function to call when the OAuth state changes.
+     */
     addOAuthStateChangeCallback(callback: OnOAuthStateChangeFn): Promise<void>;
+    /**
+     * Sets the OAuth flow state.
+     *
+     * @param oauthFlowState - The OAuth flow state.
+     */
     setOAuthFlowState(oauthFlowState: OAuthFlowState): Promise<void>;
+    /**
+     * Clears the OAuth flow state.
+     */
     clearOAuthFlowState(): Promise<void>;
+    /**
+     * Gets the OAuth flow state.
+     *
+     * @returns The OAuth flow state.
+     */
     getOAuthFlowState(): Promise<OAuthFlowState | null>;
+    /**
+     * Handles the OAuth code.
+     *
+     * @param url - The URL to handle.
+     * @returns A promise that resolves when the OAuth code is handled.
+     * @throws An error if the URL is required and not provided.
+     */
     handleOAuthCode(url?: string): Promise<void>;
 }

package/dist/native-types/auth/toAuthState.d.ts

@@ -1,6 +1,13 @@
 import { EndUser, EndUserEvmAccount, EndUserEvmSmartAccount, EndUserSolanaAccount, MFAMethods } from '@coinbase/cdp-api-client';
 import { AuthState } from './types.js';
 import { AuthenticationMethods } from '../types.js';
+/**
+ * Transforms an EndUser object from the API into a User object for internal state.
+ * Converts the authentication methods array into a keyed object for easier access.
+ *
+ * @param endUser - The EndUser object from the API response.
+ * @returns The User object for internal state management.
+ */
 export declare const toAuthStateUser: (endUser: EndUser) => {
     userId: string;
     evmAccounts: `0x${string}`[];
@@ -13,4 +20,12 @@ export declare const toAuthStateUser: (endUser: EndUser) => {
     mfaMethods: MFAMethods | undefined;
     lastAuthenticatedAt: string | undefined;
 };
+/**
+ * Returns an AuthState object from the given inputs.
+ *
+ * @param accessToken - The access token
+ * @param expiresAt - The date and time at which the refreshed access token will expire in ISO 8601 format.
+ * @param endUser - The authenticated end user
+ * @returns The AuthState object.
+ */
 export declare const toAuthState: (accessToken: string, expiresAt: string, endUser: EndUser) => AuthState;

package/dist/native-types/auth/types.d.ts

@@ -1,40 +1,121 @@
 import { KeyPair } from '../shared/types.js';
 import { OAuthFlowState, OnAuthStateChangeFn, OnOAuthStateChangeFn, User } from '../types.js';
+/**
+ * The encapsulation of an authentication state.
+ */
 export interface AuthState {
+    /**
+     * The access token.
+     */
     accessToken: string;
+    /**
+     * The Unix timestamp, in milliseconds, of the expiration date of the access token.
+     */
     expiresAt: number;
+    /**
+     * The authenticated user.
+     */
     user: User;
 }
+/**
+ * A temporary wallet secret.
+ */
 export interface WalletSecret {
+    /** The wallet secret ID. */
     walletSecretId: string;
+    /** The underlying key pair. */
     keyPair: KeyPair;
+    /** The Unix timestamp, in milliseconds, of the expiration date of the wallet secret. */
     expiresAt: number;
 }
+/**
+ * Interface for OAuth manager implementations.
+ */
 export interface IOAuthManager {
+    /**
+     * Gets the OAuth flow state.
+     */
     getOAuthFlowState(): Promise<OAuthFlowState | null>;
+    /**
+     * Sets the OAuth flow state.
+     */
     setOAuthFlowState(oauthFlowState: OAuthFlowState): Promise<void>;
+    /**
+     * Adds a callback to be called when the OAuth state changes.
+     */
     addOAuthStateChangeCallback(callback: OnOAuthStateChangeFn): Promise<void>;
+    /**
+     * Clears the OAuth flow state.
+     */
     clearOAuthFlowState(): Promise<void>;
+    /**
+     * Awaitable method whose promise only resolves when the OAuth manager is ready to be used.
+     */
     handleOAuthCode(url?: string): Promise<void>;
 }
+/**
+ * Interface for auth manager implementations.
+ * Defines the public contract that both real and mock implementations must satisfy.
+ */
 export interface IAuthManager {
+    /**
+     * Gets the current user, or null if there is no user signed in.
+     */
     getUser(): User | null;
+    /**
+     * Returns whether the user is signed in.
+     */
     isSignedIn(): Promise<boolean>;
+    /**
+     * Signs out the user, clearing all authentication state.
+     */
     signOut(): Promise<void>;
+    /**
+     * Adds a callback to be called when the auth state changes.
+     */
     addAuthStateChangeCallback(callback: OnAuthStateChangeFn): void;
+    /**
+     * Gets the access token, refreshing if needed, or null if the user is not signed in.
+     *
+     * @param options - The options for getting the token.
+     * @param options.forceRefresh - Whether to force a refresh of the token.
+     */
     getToken(options?: {
         forceRefresh?: boolean;
     }): Promise<string | null>;
+    /**
+     * Gets the expiration time of the access token, or null if the user is not signed in.
+     */
     getTokenExpiration(): Promise<number | null>;
+    /**
+     * Gets the currently registered wallet secret ID, refreshing if needed.
+     *
+     * @returns The wallet secret ID.
+     */
     getWalletSecretId(): Promise<string>;
+    /**
+     * Gets the X-Wallet-Auth header value. Throws an error if the user is not signed in.
+     */
     getXWalletAuth(options: {
         requestMethod: string;
         requestHost: string;
         requestPath: string;
         requestData?: Record<string, unknown>;
     }): Promise<string>;
+    /**
+     * Gets the authentication state.
+     */
     getAuthState(): AuthState | null;
+    /**
+     * Sets the authentication state.
+     */
     setAuthState(authState: AuthState): Promise<void>;
+    /**
+     * Clears the authentication state.
+     */
     clearAuthState(): Promise<void>;
+    /**
+     * Awaitable method whose promise only resolves when the auth manager is ready to be used.
+     */
     ensureInitialized(): Promise<void>;
 }

package/dist/native-types/auth/withAuth.d.ts

@@ -1,10 +1,24 @@
 import { EvmAddress, SolanaAddress, User } from '../types.js';
 import { IAuthManager } from './types.js';
+/**
+ * Returns whether the user is currently signed in.
+ *
+ * @param authManager - The authentication manager.
+ * @returns Whether the user is currently signed in.
+ */
 export declare const isSignedIn: (authManager: IAuthManager) => Promise<boolean>;
 type AuthenticatedFunction<T, R> = (params: T & {
     user: User;
     walletSecretId: string;
 }) => Promise<R>;
+/**
+ * Wraps a function with authentication checks.
+ *
+ * @param options - The options for the function.
+ * @param authManager - The authentication manager.
+ * @param fn - The function to wrap.
+ * @returns The result of the function.
+ */
 export declare function withAuth<T, R>(options: T & ({
     evmAccount: EvmAddress;
 } | {

package/dist/native-types/constants.d.ts

@@ -1 +1,4 @@
+/**
+ * The URL to the Coinbase Developer Platform API error documentation page.
+ */
 export declare const ERROR_DOCS_PAGE_URL = "https://docs.cdp.coinbase.com/api-v2/docs/errors";

package/dist/native-types/core.d.ts

@@ -2,9 +2,11 @@ export { initialize } from './actions/initialize.js';
 export { signInWithEmail } from './actions/signInWithEmail.js';
 export { signInWithSms } from './actions/signInWithSms.js';
 export { signInWithOAuth } from './actions/signInWithOAuth.js';
+export { signInWithSiwe, type SignInWithSiweOptions, type SignInWithSiweResult, } from './actions/signInWithSiwe.js';
 export { verifyEmailOTP } from './actions/verifyEmailOTP.js';
 export { verifySmsOTP } from './actions/verifySmsOTP.js';
 export { verifyOAuth } from './actions/verifyOAuth.js';
+export { verifySiweSignature, type VerifySiweSignatureOptions, type VerifySiweSignatureResult, } from './actions/verifySiweSignature.js';
 export { verifyTelegramOAuth } from './actions/verifyTelegramOAuth.js';
 export { authenticateWithJWT } from './actions/authenticateWithJWT.js';
 export { getCurrentUser } from './actions/getCurrentUser.js';

package/dist/native-types/eip1193/createCDPEmbeddedWallet.d.ts

@@ -1,3 +1,78 @@
 import { Chain } from 'viem/chains';
 import { CDPEmbeddedWallet, CDPEmbeddedWalletConfig } from './types.js';
+/**
+ * Creates the CDP embedded wallet's 1193 provider.
+ *
+ * Note: The transports are currently only used for non-Base transactions. For non-Base transactions,
+ * the provider internally signs the transaction via the CDP APIs and broadcasts it via the provided
+ * transports, whereas for Base transactions the CDP API both signs and broadcasts the transaction.
+ * For more information on transports, see [Wagmi's `createConfig` setup](https://wagmi.sh/react/api/createConfig).
+ *
+ * @param _parameters - Configuration parameters for the connector - see {@link CDPEmbeddedWalletConfig}
+ * @returns A CDP embedded wallet instance
+ *
+ * @example
+ * ```typescript lines
+ * import { createCDPEmbeddedWallet, initialize } from "@coinbase/cdp-core";
+ * import { http } from "viem";
+ * import { baseSepolia, sepolia } from "viem/chains";
+ *
+ * // SDK core must be initialized before creating the wallet
+ * await initialize({
+ *   projectId: "your-project-id"
+ * })
+ *
+ * // Create a wallet with multiple chains
+ * const wallet = createCDPEmbeddedWallet({
+ *   chains: [baseSepolia, sepolia],
+ *   transports: {
+ *     [baseSepolia.id]: http(),
+ *     [sepolia.id]: http(),
+ *   },
+ *   announceProvider: true, // Announce the provider to window.ethereum
+ * });
+ *
+ * // The provider can be accessed via the provider property
+ * const provider = wallet.provider;
+ *
+ * // The provider implements the EIP-1193 interface
+ * await provider.request({ method: "eth_requestAccounts" });
+ * ```
+ * @example
+ * ```typescript lines
+ * // Basic usage with default configuration
+ * const wallet = createCDPEmbeddedWallet();
+ * const provider = wallet.provider;
+ *
+ * // Request account access
+ * const accounts = await provider.request({
+ *   method: "eth_requestAccounts"
+ * });
+ *
+ * // Sign a message
+ * const signature = await provider.request({
+ *   method: "personal_sign",
+ *   params: ["Hello, World!", accounts[0]]
+ * });
+ *
+ * // Send a transaction
+ * const txHash = await provider.request({
+ *   method: "eth_sendTransaction",
+ *   params: [{
+ *     from: accounts[0],
+ *     to: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
+ *     value: "0x1000000000000000000" // 1 ETH
+ *   }]
+ * });
+ *
+ * // Listen for connection events
+ * provider.on("connect", (connectInfo) => {
+ *   console.log("Connected to chain:", connectInfo.chainId);
+ * });
+ *
+ * provider.on("disconnect", () => {
+ *   console.log("Disconnected from wallet");
+ * });
+ * ```
+ */
 export declare function createCDPEmbeddedWallet<chains extends readonly [Chain, ...Chain[]]>(_parameters: CDPEmbeddedWalletConfig<chains>): CDPEmbeddedWallet;

package/dist/native-types/eip1193/createProvider.d.ts

@@ -1,3 +1,42 @@
 import { EventEmitter } from './eventEmitter.js';
 import { EIP1193Provider, CDPEmbeddedWalletConfig, ProviderStoreInstance } from './types.js';
+/**
+ * Creates an EIP-1193 compatible Ethereum provider for CDP embedded wallets.
+ * This provider wraps the CDP core functionality and provides a standard
+ * Ethereum wallet interface.
+ *
+ * @param eventEmitter - The event emitter to use for provider events
+ * @param store - The Zustand store to use for provider state
+ * @param config - The configuration for this instance of the Provider
+ * @param config.chains - Valid chains for this provider instance
+ * @param config.transports - The RPC transports to use for each chain
+ * @returns An EIP-1193 provider instance
+ * @example
+ * ```typescript lines
+ * import { EventEmitter } from "./eventEmitter.js";
+ * import { create } from "zustand";
+ * import { baseSepolia } from "viem/chains";
+ *
+ * // Create event emitter and store
+ * const eventEmitter = new EventEmitter();
+ * const store = create<ProviderState>()(/* store configuration *\/);
+ *
+ * // Create the provider
+ * const provider = createProvider(eventEmitter, store, {
+ *   chains: [baseSepolia],
+ * });
+ *
+ * // Use the provider
+ * await provider.request({ method: "eth_requestAccounts" });
+ *
+ * // Listen for events
+ * provider.on("connect", (connectInfo) => {
+ *   console.log("Connected to chain:", connectInfo.chainId);
+ * });
+ *
+ * provider.on("chainChanged", (chainId) => {
+ *   console.log("Chain changed to:", chainId);
+ * });
+ * ```
+ */
 export declare function createProvider(eventEmitter: EventEmitter, store: ProviderStoreInstance, config: Pick<CDPEmbeddedWalletConfig, "chains" | "transports">): EIP1193Provider;

package/dist/native-types/eip1193/errors.d.ts

@@ -1,6 +1,9 @@
 import { Chain } from 'viem';
 import { EvmAddress, User } from '../types.js';
 import * as ox_Provider from "ox/Provider";
+/**
+ * Standard error codes for EIP1193 providers and JSON-RPC methods
+ */
 export declare const STANDARD_ERROR_CODES: {
     rpc: {
         invalidInput: -32000;
@@ -24,33 +27,135 @@ export declare const STANDARD_ERROR_CODES: {
         unsupportedChain: 4902;
     };
 };
+/**
+ * Standard error codes for EIP1193 providers and JSON-RPC methods
+ */
 export type ErrorCodes = typeof STANDARD_ERROR_CODES;
+/**
+ * EIP1193-defined error codes
+ */
 export type EIP1193ErrorCode = (typeof STANDARD_ERROR_CODES)["provider"][keyof (typeof STANDARD_ERROR_CODES)["provider"]];
+/**
+ * Standard JSON-RPC error codes
+ */
 export type RPCErrorCode = (typeof STANDARD_ERROR_CODES)["rpc"][keyof (typeof STANDARD_ERROR_CODES)["rpc"]];
+/**
+ * Error values for EIP1193 and RPC error codes
+ */
 export declare const errorValues: Record<`${EIP1193ErrorCode | RPCErrorCode}`, {
     standard: string;
     message: string;
 }>;
+/**
+ * EIP-1193 provider error.
+ */
 export declare class EIP1193ProviderError extends Error {
+    /**
+     * The error code from EIP1193ErrorCode enum.
+     */
     code: EIP1193ErrorCode;
+    /**
+     * Creates a new EIP-1193 Provider error.
+     *
+     * @param code - The error code from EIP1193ErrorCode enum.
+     * @param message - The error message.
+     */
     constructor(code: EIP1193ErrorCode, message: string);
 }
+/**
+ * Invalid JSON-RPC params error
+ */
 export declare class RPCRequestError extends Error {
+    /**
+     * The error code from RPCErrorCode type.
+     */
     code: RPCErrorCode;
+    /**
+     * Creates a new RPC Invalid Params error.
+     *
+     * @param code - The error code from RPCErrorCode type.
+     * @param message - The error message.
+     */
     constructor(code: RPCErrorCode, message: string);
 }
+/**
+ * Used when a method is attempted to be used with an account type that is not supported.
+ * E.g sendTransaction with a smart account.
+ */
 export declare class AccountTypeMismatchError extends Error {
+    /**
+     * Creates a new AccountTypeMismatchError.
+     *
+     * @param message - The error message.
+     */
     constructor(message: string);
 }
+/**
+ * Validates the args passed to provider.request
+ * Returns nothing if successful, throws an error if the request is not supported or the params
+ * are malformed
+ *
+ * @param request - The request object to validate
+ * @param config - The configuration for the provider
+ * @param config.chains - The chains with which the provider is configured
+ */
 export declare function validateRequest(request: Parameters<ReturnType<typeof ox_Provider.from>["request"]>[0], { chains }: {
     chains: readonly [Chain, ...Chain[]];
 }): void;
+/**
+ * Validates that a user is connected and returns the user object.
+ * Throws an EIP1193ProviderError if the user is not connected.
+ *
+ * @returns The connected user object
+ */
 export declare function validateUserConnected(): Promise< User>;
+/**
+ * Validates that a user is connected and owns the specified address.
+ * Throws an EIP1193ProviderError if the user is not connected or doesn't own the address.
+ *
+ * @param address - The address to validate ownership for
+ * @returns The connected user object
+ */
 export declare function validateUserOwnsAddress(address: EvmAddress): Promise< User>;
+/**
+ * Validates that a user is connected and owns the specified address.
+ * Throws an EIP1193ProviderError if the user is not connected or doesn't own the address.
+ *
+ * @param address - The address to validate ownership for
+ * @returns The connected user object
+ */
 export declare function validateUserOwnsEOA(address: EvmAddress): Promise< User>;
+/**
+ * Validates that a user is connected and owns the specified smart account.
+ * Throws an EIP1193ProviderError if the user is not connected or doesn't own the address.
+ *
+ * @param address - The address to validate ownership for
+ * @returns The connected user object
+ */
 export declare function validateUserOwnsSmartAccount(address: EvmAddress): Promise< User>;
+/**
+ * Validates that a user is connected and has at least one EVM account.
+ * Throws an EIP1193ProviderError if the user is not connected or has no EVM accounts.
+ *
+ * @returns The connected user object with at least one EVM account
+ */
 export declare function validateUserHasEvmAccount(): Promise< User>;
+/**
+ * Validates that a user is connected and has at least one EVM account.
+ * Throws an EIP1193ProviderError if the user is not connected or has no EVM accounts.
+ *
+ * @returns The connected user object with at least one EVM account
+ */
 export declare function validateUserHasEvmSmartAccount(): Promise< User>;
+/**
+ * Validates that a user is using an EOA.
+ * Throws an AccountTypeMismatchError if the user is using a smart account.
+ *
+ * @param root0 - The error message to throw if the user is using a smart account.
+ * @param root0.errorMessage - The error message to throw if the user is using a smart account.
+ *
+ * @returns The connected user object
+ */
 export declare function validateIsUsingEOA({ errorMessage }?: {
     errorMessage?: string;
 }): Promise< User>;

package/dist/native-types/eip1193/eventEmitter.d.ts

@@ -1,8 +1,37 @@
+/**
+ * Events we currently support.
+ */
 export type SupportedEvent = "accountsChanged" | "chainChanged" | "connect" | "disconnect";
+/**
+ * Simple event emitter implementation.
+ */
 export declare class EventEmitter {
     private events;
+    /**
+     * Add an event listener.
+     *
+     * @param event - The name of the event to listen for.
+     * @param listener - The function to call when the event is emitted.
+     */
     on(event: SupportedEvent, listener: (...args: unknown[]) => void): void;
+    /**
+     * Remove an event listener.
+     *
+     * @param event - The name of the event to remove the listener from.
+     * @param listener - The function to remove from the event listeners.
+     */
     removeListener(event: SupportedEvent, listener: (...args: unknown[]) => void): void;
+    /**
+     * Emit an event.
+     *
+     * @param event - The name of the event to emit.
+     * @param args - The arguments to pass to the event listeners.
+     */
     emit(event: SupportedEvent, ...args: unknown[]): void;
+    /**
+     * Remove all listeners for an event.
+     *
+     * @param event - The name of the event to remove all listeners from. If not provided, removes all listeners for all events.
+     */
     removeAllListeners(event?: SupportedEvent): void;
 }

package/dist/native-types/eip1193/handlers/createEOAHandlers.d.ts

@@ -1,2 +1,8 @@
 import { ProviderHandlers } from './types.js';
+/**
+ * Creates handlers for EOA (Externally Owned Account) mode.
+ * These handlers support standard Ethereum signing and transaction operations.
+ *
+ * @returns An object containing all EOA-compatible handler functions
+ */
 export declare function createEOAHandlers(): ProviderHandlers;

package/dist/native-types/eip1193/handlers/createSmartAccountHandlers.d.ts

@@ -1,2 +1,8 @@
 import { ProviderHandlers } from './types.js';
+/**
+ * Creates handlers for Smart Account mode.
+ * These handlers support EIP-4337 user operations and batch calls.
+ *
+ * @returns An object containing all Smart Account-compatible handler functions
+ */
 export declare function createSmartAccountHandlers(): ProviderHandlers;

package/dist/native-types/eip1193/handlers/eoa/handleAccounts.d.ts

@@ -1,2 +1,8 @@
 import { Address } from 'ox/Address';
+/**
+ * Handle eth_accounts request.
+ * Returns the list of accounts the provider is managing.
+ *
+ * @returns The list of account addresses.
+ */
 export declare function handleAccounts(): Promise<Address[]>;

package/dist/native-types/eip1193/handlers/eoa/handleEthSign.d.ts

@@ -1,3 +1,10 @@
 import { EthSignRequest } from '../../types.js';
 import { Hex } from 'ox/Hex';
+/**
+ * Handle eth_sign request.
+ * Signs a hash using the user's primary account.
+ *
+ * @param params - The parameters array containing [hash, address].
+ * @returns The signature of the hash.
+ */
 export declare function handleEthSign(params: EthSignRequest["params"]): Promise<Hex>;

package/dist/native-types/eip1193/handlers/eoa/handleGetCallsStatus.d.ts

@@ -1,3 +1,11 @@
 import { GetCallsStatusRequest, ProviderStoreInstance } from '../../types.js';
 import { Capabilities, WalletGetCallsStatusReturnType } from 'viem';
+/**
+ * Handles getting the status of one or more calls
+ *
+ * @param params - provider.request params
+ * @param store - the provider store instance
+ * @returns {object} - The status of the calls
+ * @see https://eips.ethereum.org/EIPS/eip-5792#wallet_getcallsstatus
+ */
 export declare function handleGetCallsStatus(params: GetCallsStatusRequest["params"], store: ProviderStoreInstance): Promise<WalletGetCallsStatusReturnType<Capabilities, number, bigint | undefined, string | undefined>>;

package/dist/native-types/eip1193/handlers/eoa/handleGetCapabilities.d.ts

@@ -1,2 +1,8 @@
 import { WalletCapabilities } from '../../types.js';
+/**
+ * Handles getting the capabilities of the wallet
+ *
+ * @returns {WalletCapabilities} - The capabilities of the wallet by chainId
+ * @see https://eips.ethereum.org/EIPS/eip-5792#wallet_getcapabilities
+ */
 export declare function handleGetCapabilities(): Promise<WalletCapabilities>;

package/dist/native-types/eip1193/handlers/eoa/handlePersonalSign.d.ts

@@ -1,3 +1,10 @@
 import { PersonalSignRequest } from '../../types.js';
 import { Hex } from 'ox/Hex';
+/**
+ * Handle personal_sign request.
+ * Signs a message using the user's primary account.
+ *
+ * @param params - The parameters array containing [message, address].
+ * @returns The signature of the message.
+ */
 export declare function handlePersonalSign(params: PersonalSignRequest["params"]): Promise<Hex>;