@coinbase/cdp-core 0.0.98 → 0.0.99

package/dist/native-types/actions/getSwapPrice.d.ts

@@ -0,0 +1,85 @@
+import { EvmSwapsNetwork } from '@coinbase/cdp-api-client';
+import { EvmAddress, SwapFees, SwapIssuesAllowance, SwapIssuesBalance } from '../types.js';
+/**
+ * Potential issues discovered during preflight checks that could prevent the swap from being executed successfully. Null if no issues were detected.
+ */
+export type SwapIssues = {
+    /**
+     * Details of the allowance that the `taker` must set in order to execute the swap successfully. Null if no allowance is required.
+     */
+    allowance: SwapIssuesAllowance | null;
+    /**
+     * Details of the `fromToken` balance that the `taker` must hold. Null if the `taker` has a sufficient balance.
+     */
+    balance: SwapIssuesBalance | null;
+};
+/** Request parameters for getting an indicative swap price. */
+export type GetSwapPriceOptions = {
+    /** 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;
+};
+/** Returned when liquidity is available for the requested swap. */
+export type GetSwapPriceResult = {
+    /** Always true when this type is returned. */
+    liquidityAvailable: true;
+    /** The network. */
+    network: EvmSwapsNetwork;
+    /** The fromToken address. */
+    fromToken: string;
+    /** The fromAmount in atomic units. */
+    fromAmount: string;
+    /** The toToken address. */
+    toToken: string;
+    /** Expected output at current market price, in atomic units. */
+    toAmount: string;
+    /** Minimum output after slippage, in atomic units. */
+    minToAmount: string;
+    /** Fees to be deducted in this transaction, or null. */
+    fees: SwapFees | null;
+    /** Preflight issues (e.g. insufficient allowance or balance) that may prevent execution, or null. */
+    issues: SwapIssues | 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;
+};
+/** Returned when no swap route exists for the pair/amount. */
+export type SwapUnavailableResult = {
+    /** Always false when this type is returned. */
+    liquidityAvailable: false;
+};
+/**
+ * Gets a non-binding indicative price for a token swap.
+ * Read-only operation — does not modify any on-chain state.
+ *
+ * @param options - The swap price request parameters.
+ * @returns Price estimate if liquidity is available, otherwise `{ liquidityAvailable: false }`.
+ * @throws An {@link InputValidationError} if parameters are invalid.
+ * @throws An Error if the response is missing required fields when liquidity is available.
+ * @example
+ * ```typescript
+ * const price = await getSwapPrice({
+ *   network: "base",
+ *   fromToken: "0x4200000000000000000000000000000000000006",
+ *   toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+ *   fromAmount: "100000000000000000",
+ * });
+ *
+ * if (price.liquidityAvailable) {
+ *   console.log("Expected output:", price.toAmount);
+ * }
+ * ```
+ */
+export declare const getSwapPrice: (options: GetSwapPriceOptions) => Promise<GetSwapPriceResult | SwapUnavailableResult>;

package/dist/native-types/actions/getUserOperation.d.ts

@@ -1,2 +1,20 @@
 import { GetUserOperationOptions, GetUserOperationResult } from '../types.js';
+/**
+ * Gets a user operation by its hash.
+ *
+ * @param options - The options for getting the user operation.
+ * @param options.userOperationHash - The user operation hash.
+ * @param options.evmSmartAccount - The EVM Smart Account that sent the user operation.
+ * @param options.network - The network the user operation was sent on.
+ * @example
+ * ```typescript lines
+ * const result = await getUserOperation({
+ *   userOperationHash: "0x123...",
+ *   evmSmartAccount: "0xabc...",
+ *   network: "base-sepolia"
+ * });
+ * console.log("User Operation Status:", result.transactionHash);
+ * ```
+ * @returns The user operation details.
+ */
 export declare const getUserOperation: (options: GetUserOperationOptions) => Promise<GetUserOperationResult>;

package/dist/native-types/actions/initialize.d.ts

@@ -1,2 +1,13 @@
 import { Config } from '../types.js';
+/**
+ * Initializes the core package. Must be called before using any other functions.
+ *
+ * @param config - The configuration for the core package.
+ * @example
+ * ```typescript lines
+ * await initialize({
+ *   projectId: "your-project-id", // Your project ID from the CDP Portal
+ * });
+ * ```
+ */
 export declare const initialize: (config: Config) => Promise<void>;

package/dist/native-types/actions/initiateMfaEnrollment.d.ts

@@ -1,21 +1,82 @@
+/**
+ * Request parameters for initiating TOTP MFA enrollment.
+ */
 export type InitiateTotpMfaOptions = {
+    /** The MFA method to use. */
     mfaMethod: "totp";
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Request parameters for initiating SMS MFA enrollment.
+ */
 export type InitiateSmsMfaOptions = {
+    /** The MFA method to use. */
     mfaMethod: "sms";
+    /**
+     * Phone number in E.164 format (e.g., +14155552671).
+     * You can use any phone number for SMS MFA, even if it differs from your SMS authentication phone number.
+     */
     phoneNumber: string;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Request parameters for initiating MFA operations.
+ */
 export type InitiateMfaOptions = InitiateTotpMfaOptions | InitiateSmsMfaOptions;
+/**
+ * Result of TOTP MFA enrollment initiation.
+ */
 export type InitiateTotpMfaResult = {
+    /** The MFA method that was initiated. */
     method: "totp";
+    /** The otpauth:// URL for the authenticator app (for QR code generation). */
     authUrl: string;
+    /** The base32-encoded TOTP secret (for manual entry). */
     secret: string;
 };
+/**
+ * Result of SMS MFA enrollment initiation.
+ */
 export type InitiateSmsMfaResult = {
+    /** The MFA method that was initiated. */
     method: "sms";
+    /** Indicates SMS was sent successfully. */
     success: boolean;
 };
+/**
+ * Result of initiateMfaEnrollment.
+ */
 export type InitiateMfaEnrollmentResult = InitiateTotpMfaResult | InitiateSmsMfaResult;
+/**
+ * Initiates MFA enrollment for an end user.
+ *
+ * For TOTP, this generates a TOTP secret and returns an otpauth:// URL that can be scanned
+ * with an authenticator app like Google Authenticator. The secret must be verified within
+ * 5 minutes by calling submitMfaEnrollment.
+ *
+ * For SMS, this sends a 6-digit OTP code to the provided phone number. The OTP code must
+ * be verified within 5 minutes. You can use any phone number for SMS MFA, even if it differs
+ * from your SMS authentication phone number.
+ *
+ * @param options - The options for initiating MFA enrollment.
+ * @example
+ * ```typescript lines
+ * // TOTP enrollment
+ * const totpResult = await initiateMfaEnrollment({ mfaMethod: "totp" });
+ * // Display totpResult.authUrl as QR code or provide totpResult.secret for manual entry
+ * console.log("Scan this QR code:", totpResult.authUrl);
+ * console.log("Or enter this secret manually:", totpResult.secret);
+ *
+ * // SMS enrollment
+ * const smsResult = await initiateMfaEnrollment({
+ *   mfaMethod: "sms",
+ *   phoneNumber: "+14155552671"
+ * });
+ * console.log("SMS sent:", smsResult.success);
+ * // User receives SMS with 6-digit code
+ * ```
+ * @returns The result containing enrollment details specific to the method.
+ */
 export declare const initiateMfaEnrollment: (options: InitiateMfaOptions) => Promise<InitiateMfaEnrollmentResult>;

package/dist/native-types/actions/initiateMfaVerification.d.ts

@@ -1,6 +1,33 @@
 import { MfaMethod } from '@coinbase/cdp-api-client';
+/**
+ * Request parameters for initiating MFA verification.
+ */
 export type InitiateMfaVerificationOptions = {
+    /** The MFA method to verify ("totp" or "sms"). */
     mfaMethod: MfaMethod;
+    /** Optional idempotency key for safe retries. */
     idempotencyKey?: string;
 };
+/**
+ * Initiates an MFA verification flow for operations requiring MFA.
+ * This endpoint should be called when a user attempts a sensitive operation
+ * (like transaction signing) but doesn't have a valid MFA-verified session.
+ *
+ * For TOTP, this prepares a verification session.
+ * For SMS, this sends a 6-digit OTP code to the user's enrolled phone number.
+ *
+ * @param options - The options for initiating MFA verification.
+ * @param options.mfaMethod - The MFA method to verify ("totp" or "sms").
+ * @example
+ * ```typescript lines
+ * // TOTP verification
+ * await initiateMfaVerification({ mfaMethod: "totp" });
+ * // Prompt user for code from authenticator app
+ *
+ * // SMS verification
+ * await initiateMfaVerification({ mfaMethod: "sms" });
+ * // SMS sent to user's phone - prompt for code
+ * ```
+ * @returns A promise that resolves if MFA initiation is successful.
+ */
 export declare const initiateMfaVerification: (options: InitiateMfaVerificationOptions) => Promise<void>;

package/dist/native-types/actions/isSignedIn.d.ts

@@ -1 +1,13 @@
+/**
+ * Returns whether the user is currently signed in.
+ *
+ * @example
+ * ```typescript lines
+ * const signedIn = await isSignedIn();
+ * if (signedIn) {
+ *   console.log("User is signed in");
+ * }
+ * ```
+ * @returns Whether the user is currently signed in.
+ */
 export declare const isSignedIn: () => Promise<boolean>;

package/dist/native-types/actions/linkApple.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Links an Apple account to the current user.
+ *
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link Apple initiation.
+ */
 export declare function linkApple(options?: {
     idempotencyKey?: string;
 }): Promise<void>;

package/dist/native-types/actions/linkEmail.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Links an email account to the current user.
+ *
+ * @param email - The email address to link.
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link email initiation.
+ */
 export declare function linkEmail(email: string, options?: {
     idempotencyKey?: string;
 }): Promise<{

package/dist/native-types/actions/linkGoogle.d.ts

@@ -1 +1,6 @@
+/**
+ * Links a Google account to the current user.
+ *
+ * @returns The result of the link Google initiation.
+ */
 export declare function linkGoogle(): Promise<void>;

package/dist/native-types/actions/linkOAuth.d.ts

@@ -1,4 +1,12 @@
 import { OAuth2ProviderType } from '@coinbase/cdp-api-client';
+/**
+ * Links an OAuth account to the current user.
+ *
+ * @param providerType - The OAuth provider type (e.g., "google", "apple", "x", "telegram").
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link OAuth initiation.
+ */
 export declare function linkOAuth(providerType: OAuth2ProviderType, options?: {
     idempotencyKey?: string;
 }): Promise<void>;

package/dist/native-types/actions/linkSms.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Links a SMS account to the current user.
+ *
+ * @param phoneNumber - The phone number to link.
+ * @param options - Optional options for the link operation.
+ * @param options.idempotencyKey - Optional idempotency key for safe retries.
+ * @returns The result of the link SMS initiation.
+ */
 export declare function linkSms(phoneNumber: string, options?: {
     idempotencyKey?: string;
 }): Promise<{

package/dist/native-types/actions/linkTelegram.d.ts

@@ -1 +1,6 @@
+/**
+ * Links a Telegram account to the current user.
+ *
+ * @returns The result of the link Telegram initiation.
+ */
 export declare function linkTelegram(): Promise<void>;

package/dist/native-types/actions/listSpendPermissions.d.ts

@@ -1,14 +1,46 @@
 import { SpendPermissionNetwork, SpendPermissionResponseObject } from '@coinbase/cdp-api-client';
 import { EvmAddress } from '../types.js';
+/**
+ * Input for listing spend permissions.
+ */
 export type ListSpendPermissionsOptions = {
+    /** The EVM Smart Account to list spend permissions for. */
     evmSmartAccount: EvmAddress;
+    /** The network to list spend permissions from. */
     network: SpendPermissionNetwork;
+    /** The number of spend permissions to return per page. */
     pageSize?: number;
+    /** The token for the next page of spend permissions. */
     pageToken?: string;
 };
+/**
+ * Result of listSpendPermissions.
+ */
 export type ListSpendPermissionsResult = {
+    /** The list of spend permissions. */
     spendPermissions: SpendPermissionResponseObject[];
+    /** Whether there are more results available. */
     hasNextPage: boolean;
+    /** The token for the next page (if any). */
     nextPageToken?: string;
 };
+/**
+ * Lists spend permissions for the user's EVM Smart Account.
+ *
+ * @param options - The options for listing spend permissions.
+ * @example
+ * ```typescript lines
+ * const result = await listSpendPermissions({
+ *   evmSmartAccount: "0x1234...",
+ *   network: "base-sepolia",
+ *   pageSize: 10
+ * });
+ *
+ * console.log("Found", result.spendPermissions.length, "spend permissions");
+ * for (const permission of result.spendPermissions) {
+ *   console.log("Permission:", permission.permissionHash, "Revoked:", permission.revoked);
+ * }
+ * ```
+ * @returns The result of the spend permissions listing.
+ */
 export declare const listSpendPermissions: (options: ListSpendPermissionsOptions) => Promise<ListSpendPermissionsResult>;

package/dist/native-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/native-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/native-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/native-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/native-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/native-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/native-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/native-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/native-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>;