@coinbase/cdp-core 0.0.97 → 0.0.99

package/dist/web-types/actions/createDelegation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Options for creating a delegation that allows a developer to sign on behalf of an end user.
+ */
+export type CreateDelegationOptions = {
+    /** The date until which the delegation is valid (ISO 8601 string). */
+    expiresAt: string;
+    /** Optional idempotency key for safe retries. */
+    idempotencyKey?: string;
+};
+/**
+ * Result of creating a delegation for an end user.
+ */
+export type CreateDelegationResult = {
+    /** The unique identifier for the delegation. */
+    delegationId: string;
+};
+/**
+ * Creates a delegation that allows a developer to sign on behalf of an end user for the specified duration.
+ * The end user must be authenticated to authorize this delegation.
+ *
+ * @param options - Options for creating the delegation.
+ * @returns The delegation ID.
+ * @throws {InputValidationError} If `expiresAt` is not a valid date or is not in the future.
+ * @throws Error if the user is not signed in.
+ */
+export declare function createDelegation(options: CreateDelegationOptions): Promise<CreateDelegationResult>;

package/dist/web-types/actions/createEvmEip7702Delegation.d.ts

@@ -1,12 +1,39 @@
 import { EvmAddress } from '../types.js';
 import { EvmEip7702DelegationNetwork } from '@coinbase/cdp-api-client';
+/**
+ * Result of creating an EIP-7702 delegation.
+ */
 export type CreateEvmEip7702DelegationResult = {
+    /** The unique identifier for the delegation operation. Use this to poll the operation status. */
     delegationOperationId: string;
 };
+/**
+ * Options for creating an EIP-7702 delegation for an EVM EOA account.
+ */
 export type CreateEvmEip7702DelegationOptions = {
+    /** The 0x-prefixed address of the EVM EOA account to delegate. Must belong to the current user. */
     address: EvmAddress;
+    /** The network to create the delegation on. */
     network: EvmEip7702DelegationNetwork;
+    /**
+     * Whether to configure spend permissions for the upgraded, delegated account.
+     * When enabled, the account can grant permissions for third parties to spend on its behalf.
+     * Defaults to false.
+     */
     enableSpendPermissions?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EIP-7702 delegation for an end user's EVM EOA account, upgrading it with smart account capabilities.
+ *
+ * This endpoint retrieves delegation artifacts from onchain, signs the EIP-7702 authorization,
+ * submits a Type 4 transaction, and creates an associated smart account object. After success,
+ * the local auth state is refreshed so the new smart account appears in the user's account list.
+ *
+ * @param options - Options for creating the EIP-7702 delegation.
+ * @returns The delegation operation ID for polling the operation status.
+ * @throws Error if the user is not signed in.
+ * @throws Error if the address does not belong to the current user.
+ */
 export declare function createEvmEip7702Delegation(options: CreateEvmEip7702DelegationOptions): Promise<CreateEvmEip7702DelegationResult>;

package/dist/web-types/actions/createEvmEoaAccount.d.ts

@@ -1,5 +1,17 @@
 import { Address } from 'viem';
+/**
+ * Options for creating an EVM EOA account.
+ */
 export type CreateEvmEoaAccountOptions = {
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EVM EOA (Externally Owned Account) for the current user.
+ * Multiple EVM EOA accounts can be created per user.
+ *
+ * @param options - Optional options for creating the account.
+ * @returns The address of the newly created EVM EOA account.
+ * @throws Error if the user is not signed in.
+ */
 export declare function createEvmEoaAccount(options?: CreateEvmEoaAccountOptions): Promise<Address>;

package/dist/web-types/actions/createEvmSmartAccount.d.ts

@@ -1,7 +1,32 @@
 import { EvmAddress } from '../types.js';
+/**
+ * Options for creating a Smart Account.
+ */
 export type CreateEvmSmartAccountOptions = {
+    /**
+     * Optional owner address for the smart account.
+     * If not provided, a new EOA will be created as the owner.
+     * If the owner already controls a smart account, an error will be thrown.
+     */
     owner?: EvmAddress;
+    /**
+     * Whether to enable spend permissions for the smart account.
+     * Setting this to true is necessary in order to create spend permissions.
+     * Only new accounts can be created with spend permissions enabled.
+     * Defaults to false.
+     */
     enableSpendPermissions?: boolean;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates an EVM Smart Account for the current user.
+ * Multiple EVM Smart Accounts can be created per user.
+ * If no owner is provided, a new EVM EOA account will be created automatically as the owner.
+ *
+ * @param options - Options for creating the EVM Smart Account.
+ * @returns The address of the newly created EVM Smart Account.
+ * @throws Error if the user is not signed in.
+ * @throws Error if the provided owner already controls a smart account.
+ */
 export declare function createEvmSmartAccount(options?: CreateEvmSmartAccountOptions): Promise<EvmAddress>;

package/dist/web-types/actions/createKeyExportIframe.d.ts

@@ -1,18 +1,166 @@
 import { SecureIframeStatus, SecureIframeTheme } from '../secureIframe/types.js';
+/**
+ * Options for setting up a key export iframe.
+ */
 export interface CreateKeyExportIframeOptions {
+    /**
+     * The address of the account to export.
+     */
     address: string;
+    /**
+     * The target element: either a CSS selector string or an HTMLElement container.
+     * An iframe will be created and appended to the target container.
+     */
     target: string | HTMLElement;
+    /**
+     * The project ID for authentication.
+     */
     projectId: string;
+    /**
+     * The label for the button displayed in the iframe.
+     */
     label?: string;
+    /**
+     * The label to display when the key is copied successfully.
+     */
     copiedLabel?: string;
+    /**
+     * Whether to show an icon in the button.
+     *
+     * @default true
+     */
     icon?: boolean;
+    /**
+     * Theme overrides for the iframe button.
+     */
     theme?: Partial<SecureIframeTheme>;
+    /**
+     * Callback invoked when the iframe status changes.
+     */
     onStatusUpdate?: (status: SecureIframeStatus, message?: string) => void;
 }
+/**
+ * Result of setting up a key export iframe.
+ */
 export interface CreateKeyExportIframeResult {
+    /**
+     * The iframe element that was set up.
+     */
     iframe: HTMLIFrameElement;
+    /**
+     * Function to clean up event listeners and remove the iframe.
+     */
     cleanup: () => void;
+    /**
+     * Function to update the theme of the iframe.
+     */
     updateTheme: (theme: Partial<SecureIframeTheme>) => void;
 }
+/**
+ * Sets up a secure iframe for exporting EVM private keys.
+ *
+ * This function handles the communication with a secure iframe that safely
+ * exports EVM private keys to the user's clipboard without exposing them to the
+ * JavaScript context.
+ *
+ * The iframe will be automatically cleaned up when the session expires (status "expired").
+ * The `cleanup` function is idempotent, so it's safe to call it in your teardown code
+ * even if the iframe has already been cleaned up due to expiration.
+ *
+ * @param {CreateKeyExportIframeOptions} options - Configuration options for the EVM key export iframe.
+ * @returns {CreateKeyExportIframeResult} An object containing the iframe element, cleanup function, and theme update function.
+ *
+ * @example
+ * ```typescript
+ * // Using a CSS selector for the container
+ * const { iframe, cleanup } = await createEvmKeyExportIframe({
+ *   address: "0x1234...",
+ *   target: "#key-export-container",
+ *   projectId: "your-project-id",
+ *   label: "Copy Private Key",
+ *   onStatusUpdate: (status, message) => {
+ *     if (status === "success") {
+ *       console.log("Key copied!");
+ *     } else if (status === "error") {
+ *       console.error("Error:", message);
+ *     }
+ *   }
+ * });
+ *
+ * // Later, clean up. Iframe will auto cleanup when it expires.
+ * cleanup();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using an HTMLElement container directly
+ * const container = document.getElementById("my-container") as HTMLElement;
+ * const { cleanup, updateTheme } = await createEvmKeyExportIframe({
+ *   address: "0x1234...",
+ *   target: container,
+ *   projectId: "your-project-id",
+ *   theme: {
+ *     buttonBg: "#0052ff",
+ *     buttonText: "#ffffff"
+ *   }
+ * });
+ *
+ * // Update theme later
+ * updateTheme({ buttonBg: "#ff0000" });
+ * ```
+ */
 export declare function createEvmKeyExportIframe(options: CreateKeyExportIframeOptions): Promise<CreateKeyExportIframeResult>;
+/**
+ * Sets up a secure iframe for exporting Solana private keys.
+ *
+ * This function handles the communication with a secure iframe that safely
+ * exports Solana private keys to the user's clipboard without exposing them to the
+ * JavaScript context.
+ *
+ * The iframe will be automatically cleaned up when the session expires (status "expired").
+ * The `cleanup` function is idempotent, so it's safe to call it in your teardown code
+ * even if the iframe has already been cleaned up due to expiration.
+ *
+ * @param {CreateKeyExportIframeOptions} options - Configuration options for the Solana key export iframe.
+ * @returns {CreateKeyExportIframeResult} An object containing the iframe element, cleanup function, and theme update function.
+ *
+ * @example
+ * ```typescript
+ * // Using a CSS selector for the container
+ * const { iframe, cleanup } = await createSolanaKeyExportIframe({
+ *   address: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+ *   target: "#key-export-container",
+ *   projectId: "your-project-id",
+ *   label: "Copy Private Key",
+ *   onStatusUpdate: (status, message) => {
+ *     if (status === "success") {
+ *       console.log("Key copied!");
+ *     } else if (status === "error") {
+ *       console.error("Error:", message);
+ *     }
+ *   }
+ * });
+ *
+ * // Later, clean up. Iframe will auto cleanup when it expires.
+ * cleanup();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using an HTMLElement container directly
+ * const container = document.getElementById("my-container") as HTMLElement;
+ * const { cleanup, updateTheme } = await createSolanaKeyExportIframe({
+ *   address: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
+ *   target: container,
+ *   projectId: "your-project-id",
+ *   theme: {
+ *     buttonBg: "#9945ff",
+ *     buttonText: "#ffffff"
+ *   }
+ * });
+ *
+ * // Update theme later
+ * updateTheme({ buttonBg: "#ff0000" });
+ * ```
+ */
 export declare function createSolanaKeyExportIframe(options: CreateKeyExportIframeOptions): Promise<CreateKeyExportIframeResult>;

package/dist/web-types/actions/createSolanaAccount.d.ts

@@ -1,5 +1,17 @@
 import { SolanaAddress } from '../types.js';
+/**
+ * Options for creating a Solana account.
+ */
 export type CreateSolanaAccountOptions = {
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Creates a Solana account for the current user.
+ * Multiple Solana accounts can be created per user.
+ *
+ * @param options - Optional options for creating the account.
+ * @returns The address of the newly created Solana account.
+ * @throws Error if the user is not signed in.
+ */
 export declare function createSolanaAccount(options?: CreateSolanaAccountOptions): Promise<SolanaAddress>;

package/dist/web-types/actions/createSpendPermission.d.ts

@@ -1,14 +1,50 @@
 import { SpendPermissionNetwork } from '@coinbase/cdp-api-client';
 import { SpendPermissionInput } from '../spend-permissions/types.js';
 import { EvmAddress, Hex } from '../types.js';
+/**
+ * Input for creating a spend permission.
+ * The permission owner is automatically detected from the current user.
+ */
 export type CreateSpendPermissionOptions = Omit<SpendPermissionInput, "account"> & {
+    /** The EVM Smart Account to create the spend permission for. */
     evmSmartAccount: EvmAddress;
+    /** The network to create the spend permission on. */
     network: SpendPermissionNetwork;
+    /**
+     * 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 createSpendPermission.
+ */
 export type CreateSpendPermissionResult = {
+    /** The user operation hash. */
     userOperationHash: Hex;
 };
+/**
+ * Creates a spend permission for the user's EVM Smart Account.
+ *
+ * @param options - The options for creating the spend permission.
+ * @example
+ * ```typescript lines
+ * const result = await createSpendPermission({
+ *   network: "base-sepolia",
+ *   spender: "0x5678...",
+ *   token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
+ *   allowance: "1000000000000000000", // 1 ETH in wei
+ *   period: 86400, // 24 hours
+ *   start: Math.floor(Date.now() / 1000),
+ *   end: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days from now
+ *   useCdpPaymaster: true
+ * });
+ * ```
+ * @returns The result of the spend permission creation.
+ */
 export declare const createSpendPermission: (options: CreateSpendPermissionOptions) => Promise<CreateSpendPermissionResult>;

package/dist/web-types/actions/executeSwap.d.ts

@@ -0,0 +1,105 @@
+import { EvmSwapsNetwork } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex, SwapFees } from '../types.js';
+/** Request parameters for executing a token swap. */
+export type ExecuteSwapOptions = {
+    /** The network on which to perform the swap. */
+    network: EvmSwapsNetwork;
+    /** The 0x-prefixed contract address of the token to sell. */
+    fromToken: EvmAddress;
+    /** The 0x-prefixed contract address of the token to buy. */
+    toToken: EvmAddress;
+    /** The amount of fromToken to sell, in atomic units. */
+    fromAmount: string;
+    /** Maximum slippage in basis points (100 = 1%). Default is 100. */
+    slippageBps?: number;
+    /** The taker account address. If omitted, auto-selected from the signed-in user's accounts. */
+    account?: EvmAddress;
+    /** Whether to use the CDP Paymaster for gas sponsorship. Only applicable for smart accounts; ignored for EOA. Cannot be used together with `paymasterUrl`. */
+    useCdpPaymaster?: boolean;
+    /** Custom paymaster URL for gas sponsorship. Only applicable for smart accounts; ignored for EOA. Cannot be used together with `useCdpPaymaster`. */
+    paymasterUrl?: string;
+    /** Optional idempotency key for safe retries. */
+    idempotencyKey?: string;
+};
+type SwapResultBase = {
+    /** The taker address. */
+    account: EvmAddress;
+    /** The network. */
+    network: EvmSwapsNetwork;
+    /** The fromToken address. */
+    fromToken: string;
+    /** The toToken address. */
+    toToken: string;
+    /** Amount of fromToken sold, in atomic units. */
+    fromAmount: string;
+    /** Expected output from the quote, in atomic units. */
+    toAmount: string;
+    /** Minimum guaranteed output, in atomic units. */
+    minToAmount: string;
+    /** Fees as quoted at execute time, or null. */
+    fees: SwapFees | null;
+    /**
+     * The estimated total network cost of the swap.
+     *
+     * On chains where there is no L1 data cost, it is calculated as gas * gasPrice. On chains where there is an L1 data cost, it is calculated as gas * gasPrice + L1 data cost.
+     */
+    totalNetworkFee: string | null;
+};
+/**
+ * Result of a successful swap execution for an EOA account.
+ *
+ * @interface
+ */
+export type ExecuteEvmEoaSwapResult = SwapResultBase & {
+    /** Always "evm-eoa". */
+    type: "evm-eoa";
+    /** The submitted transaction hash. */
+    transactionHash: Hex;
+};
+/**
+ * Result of a successful swap execution for a smart account.
+ *
+ * @interface
+ */
+export type ExecuteEvmSmartSwapResult = SwapResultBase & {
+    /** Always "evm-smart". */
+    type: "evm-smart";
+    /** The user operation hash. */
+    userOpHash: Hex;
+};
+/**
+ * Result of a successful swap execution, discriminated by account type.
+ *
+ * @see {@link ExecuteEvmEoaSwapResult}
+ * @see {@link ExecuteEvmSmartSwapResult}
+ */
+export type ExecuteSwapResult = ExecuteEvmEoaSwapResult | ExecuteEvmSmartSwapResult;
+/**
+ * Executes a token swap on behalf of the signed-in user.
+ * The backend atomically quotes, signs Permit2 (if needed), simulates, and submits the transaction.
+ * Returns immediately with a transaction hash (EOA) or user operation hash (smart account).
+ *
+ * @param options - The swap execution parameters.
+ * @returns A discriminated union result with the transaction/operation hash and swap details.
+ * @throws An {@link InputValidationError} if parameters are invalid.
+ * @throws A {@link SwapError} for known failures (insufficient liquidity/balance/allowance, simulation failure).
+ * @throws An {@link APIError} for auth, network, or server errors.
+ * @example
+ * ```typescript
+ * const result = await executeSwap({
+ *   network: "base",
+ *   fromToken: "0x4200000000000000000000000000000000000006",
+ *   toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+ *   fromAmount: "100000000000000000",
+ *   slippageBps: 100,
+ * });
+ *
+ * if (result.type === "evm-eoa") {
+ *   console.log("Transaction hash:", result.transactionHash);
+ * } else {
+ *   console.log("User operation hash:", result.userOpHash);
+ * }
+ * ```
+ */
+export declare const executeSwap: (options: ExecuteSwapOptions) => Promise<ExecuteSwapResult>;
+export {};

package/dist/web-types/actions/exportEvmAccount.d.ts

@@ -1,2 +1,20 @@
 import { ExportEvmAccountOptions, ExportEvmAccountResult } from '../types.js';
+/**
+ * Exports an EVM account's private key.
+ *
+ * @param options - The options for the exporting.
+ * @param options.evmAccount - The EVM account to export. Found on the user object of the signed in user.
+ * @example
+ * ```typescript lines
+ * const result = await exportEvmAccount({
+ *   evmAccount: "0x1234..."
+ * });
+ * ```
+ * @returns The result of the export.
+ *
+ * @deprecated This function will be removed soon. Use `createEvmKeyExportIframe` instead for a more secure key export experience
+ * that never exposes the private key to your application's JavaScript context.
+ *
+ * @see {@link createEvmKeyExportIframe}
+ */
 export declare const exportEvmAccount: (options: ExportEvmAccountOptions) => Promise<ExportEvmAccountResult>;

package/dist/web-types/actions/exportSolanaAccount.d.ts

@@ -1,2 +1,19 @@
 import { ExportSolanaAccountOptions, ExportSolanaAccountResult } from '../types.js';
+/**
+ * Exports the private key of a Solana account.
+ *
+ * @param options - The options for exporting the account.
+ * @example
+ * ```typescript lines
+ * const result = await exportSolanaAccount({
+ *   solanaAccount: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"
+ * });
+ * ```
+ * @returns The result of the export.
+ *
+ * @deprecated This function will be removed soon. Use `createSolanaKeyExportIframe` instead for a more secure key export experience
+ * that never exposes the private key to your application's JavaScript context.
+ *
+ * @see {@link createSolanaKeyExportIframe}
+ */
 export declare const exportSolanaAccount: (options: ExportSolanaAccountOptions) => Promise<ExportSolanaAccountResult>;

package/dist/web-types/actions/fetchWithX402.d.ts

@@ -1,13 +1,40 @@
 import { EvmAddress } from '../types.js';
 import { PaymentRequirementsSelector, X402Config, wrapFetchWithPayment } from 'x402-fetch';
+/**
+ * Options for the fetchWithX402 function.
+ */
 export type FetchWithX402Options = {
+    /** The address of the account to use for the fetch function. */
     address?: EvmAddress | string;
+    /** The fetch function to use for the fetch function. */
     fetch?: typeof globalThis.fetch;
+    /** The maximum allowed payment amount in base units (defaults to 0.1 USDC) */
     maxValue?: bigint;
+    /** A function that selects the payment requirements from the response */
     paymentRequirementsSelector?: PaymentRequirementsSelector;
+    /** Optional configuration for X402 operations (e.g., custom RPC URLs) */
     config?: X402Config;
 };
+/**
+ * Return type for the fetchWithX402 function.
+ */
 export type FetchWithX402ReturnType = {
+    /** The wrapped fetch function with payment handling. */
     fetchWithPayment: ReturnType<typeof wrapFetchWithPayment>;
 };
+/**
+ * Hook that provides a wrapped fetch function with payment handling.
+ *
+ * @param options - Configuration object for the fetch function
+ * @param options.address - The address to use for the fetch function
+ * @returns A wrapped fetch function with payment handling
+ *
+ * @example
+ * ```tsx lines
+ * const { fetchWithPayment } = fetchWithX402();
+ * const response = await fetchWithPayment("https://x402-resource.com", {
+ *   method: "GET",
+ * });
+ * ```
+ */
 export declare function fetchWithX402(options?: FetchWithX402Options): FetchWithX402ReturnType;

package/dist/web-types/actions/getAccessToken.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Gets the access token for the current user.
+ *
+ * @param options - The options for getting the token.
+ * @param options.forceRefresh - Whether to force a refresh of the token.
+ * @example
+ * ```typescript lines
+ * const accessToken = await getAccessToken();
+ * ```
+ * @returns The access token for the current user, or null if no user is signed in.
+ */
 export declare const getAccessToken: (options?: {
     forceRefresh: boolean;
 }) => Promise<string | null>;

package/dist/web-types/actions/getAccessTokenExpiration.d.ts

@@ -1 +1,10 @@
+/**
+ * Gets the expiration time of the access token for the current user.
+ *
+ * @example
+ * ```typescript lines
+ * const accessTokenExpiration = await getAccessTokenExpiration();
+ * ```
+ * @returns The expiration time of the access token for the current user, or null if no user is signed in.
+ */
 export declare const getAccessTokenExpiration: () => Promise<number | null>;

package/dist/web-types/actions/getCurrentUser.d.ts

@@ -1,2 +1,11 @@
 import { User } from '../types.js';
+/**
+ * Gets the currently signed-in user, if any.
+ *
+ * @example
+ * ```typescript lines
+ * const user = await getCurrentUser();
+ * ```
+ * @returns The currently signed-in user, or null if no user is signed in.
+ */
 export declare const getCurrentUser: () => Promise<User | null>;

package/dist/web-types/actions/getCurrentUserSync.d.ts

@@ -1,2 +1,11 @@
 import { User } from '../types.js';
+/**
+ * Gets the currently signed-in user, if any.
+ *
+ * @example
+ * ```typescript lines
+ * const user = getCurrentUserSync();
+ * ```
+ * @returns The currently signed-in user, or null if no user is signed in.
+ */
 export declare const getCurrentUserSync: () => User | null;

package/dist/web-types/actions/getEvmEip7702DelegationOperation.d.ts

@@ -1,5 +1,17 @@
 import { EvmEip7702DelegationOperation } from '@coinbase/cdp-api-client';
+/**
+ * Options for getting the status of an EIP-7702 delegation operation.
+ */
 export type GetEvmEip7702DelegationOperationOptions = {
+    /** The unique identifier for the delegation operation returned by createEvmEip7702Delegation. */
     delegationOperationId: string;
 };
+/**
+ * Returns the current status of an EIP-7702 delegation operation for an end user's EVM account.
+ * Use the delegationOperationId returned by createEvmEip7702Delegation to poll for operation completion.
+ *
+ * @param options - Options containing the delegation operation ID.
+ * @returns The delegation operation status (PENDING, SUBMITTED, COMPLETED, or FAILED).
+ * @throws Error if the user is not signed in.
+ */
 export declare function getEvmEip7702DelegationOperation(options: GetEvmEip7702DelegationOperationOptions): Promise<EvmEip7702DelegationOperation>;

package/dist/web-types/actions/getMfaConfig.d.ts

@@ -1,3 +1,20 @@
 import { MfaConfig } from '@coinbase/cdp-api-client';
+/**
+ * Result of getMfaConfig.
+ */
 export type GetMfaConfigResult = MfaConfig;
+/**
+ * Gets the MFA configuration for the current project.
+ * This endpoint returns information about whether MFA is enabled for the project
+ * and the configuration for TOTP authentication.
+ *
+ * @example
+ * ```typescript lines
+ * const result = await getMfaConfig();
+ * if (result?.totpConfig?.enabled) {
+ *   console.log("TOTP MFA is enabled for this project");
+ * }
+ * ```
+ * @returns The MFA configuration for the project.
+ */
 export declare const getMfaConfig: () => Promise<GetMfaConfigResult>;

package/dist/web-types/actions/getProjectConfig.d.ts

@@ -1,3 +1,16 @@
 import { ProjectConfig } from '@coinbase/cdp-api-client';
+/**
+ * Result of getProjectConfig.
+ */
 export type GetProjectConfigResult = ProjectConfig;
+/**
+ * Gets the project configuration for the current project.
+ *
+ * @example
+ * ```typescript lines
+ * const result = await getProjectConfig();
+ * console.log("Project name:", result.name);
+ * ```
+ * @returns The project configuration.
+ */
 export declare const getProjectConfig: () => Promise<GetProjectConfigResult>;