@coinbase/cdp-core 0.0.98 → 0.0.100

package/dist/types/actions/onAuthStateChange.d.ts

@@ -1,2 +1,18 @@
 import { OnAuthStateChangeFn } from '../types.js';
+/**
+ * Sets a callback function to be called when the authentication state changes,
+ * i.e. when a user signs in or out.
+ *
+ * @example
+ * ```typescript lines
+ * onAuthStateChange(async (user) => {
+ *   if (user) {
+ *     console.log("User signed in:", user.userId);
+ *   } else {
+ *     console.log("User signed out");
+ *   }
+ * });
+ * ```
+ * @param callback - The callback function to be called when the authentication state changes.
+ */
 export declare const onAuthStateChange: (callback: OnAuthStateChangeFn) => void;

package/dist/types/actions/onOAuthStateChange.d.ts

@@ -1,2 +1,8 @@
 import { OnOAuthStateChangeFn } from '../types.js';
+/**
+ * Sets a callback function to be called when the OAuth flow state changes,
+ * i.e. when a user signs in with OAuth.
+ *
+ * @param callback - The callback function to be called when the OAuth flow state changes.
+ */
 export declare const onOAuthStateChange: (callback: OnOAuthStateChangeFn) => void;

package/dist/types/actions/recordMfaEnrollmentPrompted.d.ts

@@ -1,5 +1,23 @@
 import { RecordMfaEnrollmentPrompted200 } from '@coinbase/cdp-api-client';
+/**
+ * Result of recordMfaEnrollmentPrompted.
+ */
 export type RecordMfaEnrollmentPromptedResult = RecordMfaEnrollmentPrompted200;
+/**
+ * Records that the end user was prompted for MFA enrollment.
+ * This endpoint should be called when the user is shown the MFA enrollment prompt,
+ * regardless of whether they choose to enroll or skip. This helps track when users
+ * were last offered the opportunity to enroll in MFA.
+ *
+ * @example
+ * ```typescript lines
+ * const result = await recordMfaEnrollmentPrompted();
+ * console.log("MFA enrollment prompt recorded at:", result.enrollmentPromptedAt);
+ * ```
+ * @param options - Optional options for the operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result containing the timestamp when enrollment was prompted.
+ */
 export declare const recordMfaEnrollmentPrompted: (options?: {
     idempotencyKey?: string;
 }) => Promise<RecordMfaEnrollmentPromptedResult>;

package/dist/types/actions/revokeDelegation.d.ts

@@ -1,4 +1,16 @@
+/**
+ * Options for revoking all active delegations for an end user.
+ */
 export type RevokeDelegationOptions = {
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Revokes all active delegations for the current end user.
+ * This operation can be performed by the end user themselves or by a developer using their API key.
+ *
+ * @param options - Optional options for revoking the delegation.
+ * @returns A promise that resolves when all active delegations have been revoked.
+ * @throws Error if the user is not signed in.
+ */
 export declare function revokeDelegation(options?: RevokeDelegationOptions): Promise<void>;

package/dist/types/actions/revokeSpendPermission.d.ts

@@ -1,14 +1,48 @@
 import { SpendPermissionNetwork } from '@coinbase/cdp-api-client';
 import { EvmAddress, Hex } from '../types.js';
+/**
+ * Input for revoking a spend permission.
+ */
 export type RevokeSpendPermissionOptions = {
+    /** The EVM Smart Account to revoke the spend permission for. */
     evmSmartAccount: EvmAddress;
+    /** The network to revoke the spend permission on. */
     network: SpendPermissionNetwork;
+    /** The hash of the spend permission to revoke. */
     permissionHash: string;
+    /**
+     * Whether to use the CDP Paymaster for the user operation.
+     *
+     * Only available on Base. Enabled by default on Base Sepolia.
+     */
     useCdpPaymaster?: boolean;
+    /** The URL of the paymaster to use for the user operation. */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Result of revokeSpendPermission.
+ */
 export type RevokeSpendPermissionResult = {
+    /** The user operation hash. */
     userOperationHash: Hex;
 };
+/**
+ * Revokes a spend permission for the user's EVM Smart Account.
+ *
+ * @param options - The options for revoking the spend permission.
+ * @example
+ * ```typescript lines
+ * const result = await revokeSpendPermission({
+ *   evmSmartAccount: "0x1234...",
+ *   network: "base-sepolia",
+ *   permissionHash: "0x5678...",
+ *   useCdpPaymaster: true
+ * });
+ *
+ * console.log("User Operation Hash:", result.userOperationHash);
+ * ```
+ * @returns The result of the spend permission revocation.
+ */
 export declare const revokeSpendPermission: (options: RevokeSpendPermissionOptions) => Promise<RevokeSpendPermissionResult>;

package/dist/types/actions/sendEvmEoaUsdc.d.ts

@@ -1,13 +1,45 @@
 import { EvmAddress, SendEvmUsdcNetwork } from '../types.js';
 import { Hex } from 'viem';
+/** Request parameters for sending EVM USDC from an EOA account. */
 export type SendEvmEoaUsdcOptions = {
+    /** The EVM EOA account to send USDC from. */
     evmAccount: EvmAddress;
+    /** The recipient address. */
     to: EvmAddress;
+    /** The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC). */
     amount: string;
+    /** The network to send USDC on. */
     network: SendEvmUsdcNetwork;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendEvmEoaUsdc. */
 export type SendEvmEoaUsdcResult = {
+    /** The transaction hash. */
     transactionHash: Hex;
 };
+/**
+ * Sends USDC on an EVM network from an EOA (Externally Owned Account).
+ *
+ * @param options - The options for sending USDC.
+ * @param options.evmAccount - The EVM EOA account to send USDC from. Found on the user object of the signed in user.
+ * @param options.to - The recipient address.
+ * @param options.amount - The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC).
+ * @param options.network - The network to send USDC on.
+ * @example
+ * ```typescript
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await sendEvmEoaUsdc({
+ *   evmAccount,
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "25.50",
+ *   network: "base-sepolia",
+ * });
+ *
+ * console.log("Transaction Hash:", result.transactionHash);
+ * ```
+ * @returns The result of sending USDC.
+ */
 export declare const sendEvmEoaUsdc: (options: SendEvmEoaUsdcOptions) => Promise<SendEvmEoaUsdcResult>;

package/dist/types/actions/sendEvmSmartAccountUsdc.d.ts

@@ -1,15 +1,52 @@
 import { EvmAddress, SendEvmUsdcNetwork } from '../types.js';
 import { Hex } from 'viem';
+/** Request parameters for sending EVM USDC from a Smart Account. */
 export type SendEvmSmartAccountUsdcOptions = {
+    /** The EVM Smart Account to send USDC from. */
     evmSmartAccount: EvmAddress;
+    /** The recipient address. */
     to: EvmAddress;
+    /** The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC). */
     amount: string;
+    /** The network to send USDC on. */
     network: SendEvmUsdcNetwork;
+    /** Whether to use CDP Paymaster to sponsor gas fees. */
     useCdpPaymaster?: boolean;
+    /** Optional custom Paymaster URL to use for gas sponsorship. */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendEvmSmartAccountUsdc. */
 export type SendEvmSmartAccountUsdcResult = {
+    /** The user operation hash. */
     userOpHash: Hex;
 };
+/**
+ * Sends USDC on an EVM network from a Smart Account.
+ *
+ * @param options - The options for sending USDC.
+ * @param options.evmSmartAccount - The EVM Smart Account to send USDC from. Found on the user object of the signed in user.
+ * @param options.to - The recipient address.
+ * @param options.amount - The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC).
+ * @param options.network - The network to send USDC on.
+ * @param options.useCdpPaymaster - Whether to use CDP Paymaster to sponsor gas fees.
+ * @param options.paymasterUrl - Optional custom Paymaster URL to use for gas sponsorship.
+ * @example
+ * ```typescript
+ * const user = await getCurrentUser();
+ * const evmSmartAccount = user?.evmSmartAccountObjects[0]?.address;
+ *
+ * const result = await sendEvmSmartAccountUsdc({
+ *   evmSmartAccount,
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "10.00",
+ *   network: "base-sepolia",
+ *   useCdpPaymaster: true, // Optional: sponsor gas fees
+ * });
+ *
+ * console.log("User Operation Hash:", result.userOpHash);
+ * ```
+ * @returns The result of sending USDC.
+ */
 export declare const sendEvmSmartAccountUsdc: (options: SendEvmSmartAccountUsdcOptions) => Promise<SendEvmSmartAccountUsdcResult>;

package/dist/types/actions/sendEvmTransaction.d.ts

@@ -1,2 +1,32 @@
 import { SendEvmTransactionOptions, SendEvmTransactionResult } from '../types.js';
+/**
+ * Sends an EVM transaction.
+ *
+ * @param options - The options for the sending.
+ * @param options.evmAccount - The EVM account to send the transaction with. Found on the user object of the signed in user.
+ * @param options.network - The network to send the transaction on.
+ * @param options.transaction - The transaction to send.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await sendEvmTransaction({
+ *   evmAccount,
+ *   network: "base-sepolia",
+ *   transaction: {
+ *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *     value: 100000000000000n, // 0.0001 ETH in wei
+ *     nonce: 0,
+ *     gas: 21000n,
+ *     maxFeePerGas: 30000000000n,
+ *     maxPriorityFeePerGas: 1000000000n,
+ *     chainId: 84532, // Base Sepolia
+ *     type: "eip1559",
+ *   }
+ * });
+ *
+ * ```
+ * @returns The transaction hash of the sent transaction.
+ */
 export declare const sendEvmTransaction: (options: SendEvmTransactionOptions) => Promise<SendEvmTransactionResult>;

package/dist/types/actions/sendSolanaTransaction.d.ts

@@ -1,2 +1,8 @@
 import { SendSolanaTransactionOptions, SendSolanaTransactionResult } from '../types.js';
+/**
+ * Send a Solana transaction.
+ *
+ * @param options - The options for sending the Solana transaction.
+ * @returns The transaction signature.
+ */
 export declare const sendSolanaTransaction: (options: SendSolanaTransactionOptions) => Promise<SendSolanaTransactionResult>;

package/dist/types/actions/sendSolanaUsdc.d.ts

@@ -1,15 +1,75 @@
 import { SolanaAddress } from '../types.js';
+/**
+ * The Solana network to send USDC on.
+ */
 export type SendSolanaUsdcNetwork = "solana" | "solana-devnet";
+/** Request parameters for sending Solana USDC. */
 export type SendSolanaUsdcOptions = {
+    /** The Solana account to send USDC from. */
     solanaAccount: SolanaAddress;
+    /** The recipient address (base58 encoded). */
     to: SolanaAddress;
+    /** The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC). */
     amount: string;
+    /** The network to send USDC on. */
     network: SendSolanaUsdcNetwork;
+    /**
+     * Whether to automatically create an Associated Token Account (ATA) for the recipient if it doesn't exist.
+     *
+     * @default false
+     *
+     * **Important**: Creating an ATA requires ~0.002 SOL (~$0.20) for rent exemption, which the sender pays.
+     *
+     * - Set to `true` if you want to ensure the transaction succeeds by creating the recipient's ATA if needed
+     * - Set to `false` (default) to only send if the recipient already has a USDC token account
+     *
+     * If `false` and the recipient doesn't have an ATA, the transaction will fail with a clear error message.
+     */
     createRecipientAta?: boolean;
+    /** Whether transaction fees should be sponsored by CDP. When true, CDP sponsors the transaction fee. */
     useCdpSponsor?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendSolanaUsdc. */
 export type SendSolanaUsdcResult = {
+    /** The transaction signature. */
     transactionSignature: string;
 };
+/**
+ * Sends USDC on the Solana network.
+ *
+ * @param options - The options for sending USDC.
+ * @param options.solanaAccount - The Solana account to send USDC from. Found on the user object of the signed in user.
+ * @param options.to - The recipient address (base58 encoded).
+ * @param options.amount - The amount of USDC to send in human-readable format (e.g., "1.50" for 1.5 USDC).
+ * @param options.network - The network to send USDC on.
+ * @param options.createRecipientAta - Whether to automatically create an Associated Token Account (ATA) for the recipient if it doesn't exist. Defaults to false.
+ * @param options.useCdpSponsor - Whether transaction fees should be sponsored by CDP. When true, CDP sponsors the transaction fee.
+ * @example
+ * ```typescript
+ * const user = await getCurrentUser();
+ * const solanaAccount = user?.solanaAccountObjects[0]?.address;
+ *
+ * // Send to recipient with existing USDC account (default behavior)
+ * const result = await sendSolanaUsdc({
+ *   solanaAccount,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ * });
+ *
+ * // Or explicitly create recipient's ATA if needed (~0.002 SOL cost)
+ * const resultWithAta = await sendSolanaUsdc({
+ *   solanaAccount,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ *   createRecipientAta: true, // Sender pays for recipient's ATA creation
+ * });
+ *
+ * console.log("Transaction Signature:", result.transactionSignature);
+ * ```
+ * @returns The result of sending USDC.
+ */
 export declare const sendSolanaUsdc: (options: SendSolanaUsdcOptions) => Promise<SendSolanaUsdcResult>;

package/dist/types/actions/sendUsdc.d.ts

@@ -1,35 +1,71 @@
 import { SendSolanaUsdcNetwork } from './sendSolanaUsdc.js';
 import { EvmAddress, SolanaAddress, SendEvmUsdcNetwork, Hex } from '../types.js';
+/**
+ * The network to send USDC on - supports both EVM and Solana networks.
+ */
 export type SendUsdcNetwork = SendEvmUsdcNetwork | SendSolanaUsdcNetwork;
+/**
+ * Request parameters for sending USDC.
+ * Uses discriminated unions to prevent invalid parameter combinations at compile-time.
+ */
 export type SendUsdcOptions = {
+    /** Explicitly sending from an EVM address (EOA or Smart Account). */
     from: EvmAddress;
+    /** Recipient EVM address. */
     to: EvmAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** EVM network to send on. */
     network: SendEvmUsdcNetwork;
+    /** Whether to use CDP Paymaster to sponsor gas fees (Smart Accounts only). */
     useCdpPaymaster?: boolean;
+    /** Optional custom Paymaster URL (Smart Accounts only). */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /** Explicitly sending from a Solana address. */
     from: SolanaAddress;
+    /** Recipient Solana address. */
     to: SolanaAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** Solana network to send on. */
     network: SendSolanaUsdcNetwork;
+    /** Whether to create recipient's ATA if needed (~0.002 SOL cost). */
     createRecipientAta?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /**
+     * Auto-select mode for EVM - sender address will be automatically selected if exactly one account exists.
+     */
     to: EvmAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** EVM network to send on. */
     network: SendEvmUsdcNetwork;
+    /** Whether to use CDP Paymaster (only used if Smart Account is selected). */
     useCdpPaymaster?: boolean;
+    /** Optional custom Paymaster URL (only used if Smart Account is selected). */
     paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 } | {
+    /**
+     * Auto-select mode for Solana - sender address will be automatically selected if exactly one account exists.
+     */
     to: SolanaAddress;
+    /** The amount of USDC to send (e.g., "1.50"). */
     amount: string;
+    /** Solana network to send on. */
     network: SendSolanaUsdcNetwork;
+    /** Whether to create recipient's ATA if needed (~0.002 SOL cost). */
     createRecipientAta?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/** Result of sendUsdc - discriminated union based on account type. */
 export type SendUsdcResult = {
     type: "evm-eoa";
     transactionHash: Hex;
@@ -46,4 +82,47 @@ export type SendUsdcResult = {
     from: SolanaAddress;
     network: SendSolanaUsdcNetwork;
 };
+/**
+ * Sends USDC on EVM or Solana networks with automatic address type detection.
+ * Automatically determines if the sender is an EOA, Smart Account, or Solana account
+ * and routes to the appropriate sending function.
+ *
+ * If `from` is not provided, automatically selects the address only when there is exactly
+ * one account to avoid ambiguity. If multiple accounts exist, explicit selection is required.
+ *
+ * @param options - The options for sending USDC. See {@link SendUsdcOptions} for all available parameters.
+ *
+ * @example
+ * ```typescript
+ * // Simplest usage - auto-selects sender when user has exactly one account
+ * const result = await sendUsdc({
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "10.00",
+ *   network: "base-sepolia",
+ * });
+ *
+ * // Send from Smart Account with gas sponsorship
+ * const smartResult = await sendUsdc({
+ *   from: user.evmSmartAccountObjects[0].address,
+ *   to: "0x1234567890123456789012345678901234567890",
+ *   amount: "10.00",
+ *   network: "base",
+ *   useCdpPaymaster: true,
+ * });
+ * // Result: { type: "evm-smart", userOpHash: "0x..." }
+ *
+ * // Send from Solana account
+ * const solanaResult = await sendUsdc({
+ *   from: user.solanaAccountObjects[0].address,
+ *   to: "ExXhNkgYf6efh7YyqDRVxPZuzafobao1A74drUdp8trd",
+ *   amount: "10.00",
+ *   network: "solana-devnet",
+ *   createRecipientAta: true,
+ * });
+ * // Result: { type: "solana", transactionSignature: "..." }
+ * ```
+ *
+ * @returns A discriminated union result indicating the account type and transaction identifier.
+ * @throws If addresses are invalid, mismatched types, user doesn't own the sender account, or no accounts available.
+ */
 export declare const sendUsdc: (options: SendUsdcOptions) => Promise<SendUsdcResult>;

package/dist/types/actions/sendUserOperation.d.ts

@@ -1,2 +1,31 @@
 import { SendUserOperationOptions, SendUserOperationResult } from '../types.js';
+/**
+ * Sends a user operation from a smart account.
+ *
+ * @param options - The options for sending the user operation.
+ * @param options.evmSmartAccount - The EVM Smart Account to send the user operation with.
+ * @param options.network - The network to send the user operation on.
+ * @param options.calls - The calls to make from the user operation.
+ * @param options.paymasterUrl - The URL of the paymaster to use for the user operation.
+ * Get your free Base paymaster URL [from the CDP Portal](https://portal.cdp.coinbase.com/products/node).
+ * @param options.dataSuffix - Optional hex-encoded data suffix to append to the user operation callData for attribution (ERC-8021).
+ * @returns Promise that resolves to the user operation hash.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const smartAccount = user?.evmSmartAccountObjects[0]?.address;
+ *
+ * const result = await sendUserOperation({
+ *   evmSmartAccount: smartAccount,
+ *   network: "base-sepolia",
+ *   calls: [{
+ *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *     value: 0n,
+ *     data: "0x",
+ *   }],
+ *   dataSuffix: "0x62617365617070070080218021802180218021802180218021", // ERC-8021 attribution
+ * });
+ * console.log("User Operation Hash:", result.userOperationHash);
+ * ```
+ */
 export declare const sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationResult>;

package/dist/types/actions/signEvmHash.d.ts

@@ -1,2 +1,17 @@
 import { SignEvmHashOptions, SignEvmHashResult } from '../types.js';
+/**
+ * Signs a hash with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the hash with. Found on the user object of the signed in user.
+ * @param options.hash - The hash to sign.
+ * @example
+ * ```typescript lines
+ * const result = await signEvmHash({
+ *   evmAccount: "0x1234...",
+ *   hash: "0xabcd..." // 32-byte hex string to sign
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmHash: (options: SignEvmHashOptions) => Promise<SignEvmHashResult>;

package/dist/types/actions/signEvmMessage.d.ts

@@ -1,2 +1,21 @@
 import { SignEvmMessageOptions, SignEvmHashResult } from '../types.js';
+/**
+ * Signs an EVM message.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the message with. Found on the user object of the signed in user.
+ * @param options.message - The message to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmMessage({
+ *   evmAccount,
+ *   message: "Hello World" // Message to sign
+ * });
+ *
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmMessage: (options: SignEvmMessageOptions) => Promise<SignEvmHashResult>;

package/dist/types/actions/signEvmTransaction.d.ts

@@ -1,2 +1,29 @@
 import { SignEvmTransactionOptions, SignEvmTransactionResult } from '../types.js';
+/**
+ * Signs a hash with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the transaction with. Found on the user object of the signed in user.
+ * @param options.transaction - The transaction to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmTransaction({
+ *   evmAccount,
+ *   transaction: {
+ *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *     value: 100000000000000n, // 0.0001 ETH in wei
+ *     nonce: 0,
+ *     gas: 21000n,
+ *     maxFeePerGas: 30000000000n,
+ *     maxPriorityFeePerGas: 1000000000n,
+ *     chainId: 84532, // Base Sepolia
+ *     type: "eip1559",
+ *   }
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmTransaction: (options: SignEvmTransactionOptions) => Promise<SignEvmTransactionResult>;

package/dist/types/actions/signEvmTypedData.d.ts

@@ -1,2 +1,52 @@
 import { SignEvmTypedDataOptions, SignEvmTypedDataResult } from '../types.js';
+/**
+ * Signs EIP-712 typed data with an EVM account.
+ *
+ * @param options - The options for the signing.
+ * @param options.evmAccount - The EVM account to sign the typed data with. Found on the user object of the signed in user.
+ * @param options.typedData - The typed data to sign.
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * const evmAccount = user?.evmAccountObjects[0]?.address;
+ *
+ * const result = await signEvmTypedData({
+ *   evmAccount,
+ *   typedData: {
+ *     domain: {
+ *       name: "USDC",
+ *       version: "2",
+ *       chainId: 84532,
+ *       verifyingContract: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", // Base Sepolia USDC
+ *     },
+ *     types: {
+ *       EIP712Domain: [
+ *         { name: "name", type: "string" },
+ *         { name: "version", type: "string" },
+ *         { name: "chainId", type: "uint256" },
+ *         { name: "verifyingContract", type: "address" },
+ *       ],
+ *       TransferWithAuthorization: [
+ *         { name: "from", type: "address" },
+ *         { name: "to", type: "address" },
+ *         { name: "value", type: "uint256" },
+ *         { name: "validAfter", type: "uint256" },
+ *         { name: "validBefore", type: "uint256" },
+ *         { name: "nonce", type: "bytes32" },
+ *       ],
+ *     },
+ *     primaryType: "TransferWithAuthorization",
+ *     message: {
+ *       from: evmAccount,
+ *       to: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
+ *       value: "1000000", // 1 USDC (6 decimals)
+ *       validAfter: 0, // Valid immediately
+ *       validBefore: 2524604400, // Valid until 2050
+ *       nonce: 0
+ *     },
+ *   },
+ * });
+ * ```
+ * @returns The result of the signing.
+ */
 export declare const signEvmTypedData: (options: SignEvmTypedDataOptions) => Promise<SignEvmTypedDataResult>;

package/dist/types/actions/signInWithEmail.d.ts

@@ -1,2 +1,14 @@
 import { SignInWithEmailOptions, SignInWithEmailResult } from '../types.js';
+/**
+ * Initiates the sign in flow with an email.
+ *
+ * @param options - The options for the sign in.
+ * @example
+ * ```typescript lines
+ * const result = await signInWithEmail({
+ *   email: "user@example.com"
+ * });
+ * ```
+ * @returns The result of the sign in.
+ */
 export declare const signInWithEmail: (options: SignInWithEmailOptions) => Promise<SignInWithEmailResult>;

package/dist/types/actions/signInWithOAuth.d.ts

@@ -1,4 +1,44 @@
 import { OAuth2ProviderType } from '@coinbase/cdp-api-client';
+/**
+ * Initiates the sign in flow with an OAuth provider (Google, Apple, Telegram, and X are currently supported).
+ * In a web application, this will redirect the user to the OAuth provider's sign in page.
+ * This sign in method is not yet supported on mobile.
+ *
+ * @param providerType - The type of OAuth provider to sign in with.
+ * @param options - Optional options for the sign in.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the sign in.
+ *
+ * @example
+ * ```typescript lines
+ * // Google
+ * try {
+ *  void signInWithOAuth("google");
+ * } catch (error) {
+ *   console.error("Failed to sign in with Google:", error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // Apple
+ * try {
+ *  void signInWithOAuth("apple");
+ * } catch (error) {
+ *  console.error("Failed to sign in with Apple:", error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript lines
+ * // X
+ * try {
+ *  void signInWithOAuth("x");
+ * } catch (error) {
+ *  console.error("Failed to sign in with X:", error);
+ * }
+ * ```
+ */
 export declare const signInWithOAuth: (providerType: OAuth2ProviderType, options?: {
     idempotencyKey?: string;
 }) => Promise<void>;