@coinbase/cdp-api-client 0.0.123 → 0.0.125

package/dist/types/index.d.ts

@@ -1,5 +1,53 @@
 import { AxiosRequestConfig } from 'axios';
 
+/**
+ * A request to adjust an existing borrow position for an end user's smart account on the specified borrow product.
+ The request can supply collateral, withdraw collateral, repay debt, and/or borrow more of the loan asset, broadcasting a user operation to apply the changes onchain.
+ A single request must not combine `addCollateralAmount` with `removeCollateralAmount` or `repayLoanAmount`, and must not combine `borrowLoanAmount` with `repayLoanAmount` or `removeCollateralAmount`. Otherwise any subset of the four amount fields may be supplied; at least one is required.
+ */
+export declare interface AdjustBorrowPositionRequest {
+    borrowProductId: BorrowProductId;
+    /** The amount of collateral to add to the position, as a decimal string in standard unit denomination of the collateral token (i.e. "1" for 1 cbBTC). Must not be combined with `removeCollateralAmount` or `repayLoanAmount`. */
+    addCollateralAmount?: PositiveDecimal;
+    /** The amount of collateral to withdraw from the position, as a decimal string in standard unit denomination of the collateral token (i.e. "1" for 1 cbBTC).  Must not be combined with `addCollateralAmount` or `borrowLoanAmount`. */
+    removeCollateralAmount?: PositiveDecimal;
+    /** The amount of the loan token to repay, as a decimal string in standard unit denomination of the loan token (i.e. "100" for 100 USDC).  Must not be combined with `borrowLoanAmount` or `addCollateralAmount`. */
+    repayLoanAmount?: PositiveDecimal;
+    /** The amount of the loan token to borrow, as a decimal string in standard unit denomination of the loan token (i.e. "100" for 100 USDC).  Must not be combined with `repayLoanAmount` or `removeCollateralAmount`. */
+    borrowLoanAmount?: PositiveDecimal;
+    /**
+     * The ID of the Temporary Wallet Secret that was used to sign the X-Wallet-Auth header.
+     * @pattern ^[a-zA-Z0-9-]{1,100}$
+     */
+    walletSecretId: string;
+    /** Whether to use the CDP Paymaster for the user operation. When `true`, `paymasterUrl` must not be set. */
+    useCdpPaymaster: boolean;
+    /** Paymaster URL to use for the user operation. Must not be set when `useCdpPaymaster` is `true`.
+     If `useCdpPaymaster` is `false` and no `paymasterUrl` is set, the smart account must have sufficient funds to cover network fees. */
+    paymasterUrl?: Url;
+    /** Optional paymaster metadata forwarded to the configured paymaster service. Valid only when a paymaster is configured via `useCdpPaymaster: true` or a `paymasterUrl`. */
+    paymasterContext?: PaymasterContext;
+}
+
+/**
+ * Adjusts an existing borrow position for a specific borrow product by supplying collateral, withdrawing collateral, repaying debt, and/or borrowing more of the loan asset from an end user smart account.
+ The `borrowProductId` identifies the product whose position to adjust, and the `addCollateralAmount`, `removeCollateralAmount`, `repayLoanAmount`, and `borrowLoanAmount` fields specify the changes to apply, each expressed as a decimal string in standard unit denomination of the respective token.
+ A single request must not combine `addCollateralAmount` with `removeCollateralAmount` or `repayLoanAmount`, and must not combine `borrowLoanAmount` with `repayLoanAmount` or `removeCollateralAmount`. Otherwise any subset of the four amount fields may be supplied; at least one is required.
+ A user operation is broadcast to adjust the position onchain. Poll `getUserOperationWithEndUserAccount` with the returned `userOpHash` until it reaches a terminal state. Once the user operation succeeds onchain, use the borrow positions list endpoint to view the user's adjusted positions.
+ * @summary Adjust a borrow position for an end user smart account
+ */
+export declare const adjustBorrowPositionWithEndUserAccount: (userId: string, address: string, adjustBorrowPositionRequest: AdjustBorrowPositionRequest, params?: AdjustBorrowPositionWithEndUserAccountParams, options?: SecondParameter<typeof cdpApiClient<EvmUserOperation>>) => Promise<EvmUserOperation>;
+
+export declare type AdjustBorrowPositionWithEndUserAccountParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type AdjustBorrowPositionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof adjustBorrowPositionWithEndUserAccount>>>;
+
 /**
  * The resource already exists.
  */
@@ -32,6 +80,12 @@ export declare class APIError extends Error {
     errorMessage: string;
     correlationId?: string;
     errorLink?: string;
+    /**
+     * Response headers, lowercase-keyed (e.g. `x-mfa-challenge-id`). Never included in
+     * {@link toJSON}. Multi-value headers (e.g. `set-cookie`) come back as arrays; callers
+     * must guard with `Array.isArray` before treating a value as a string.
+     */
+    headers?: Record<string, string | string[]>;
     /**
      * Constructor for the APIError class
      *
@@ -41,8 +95,9 @@ export declare class APIError extends Error {
      * @param correlationId - The correlation ID
      * @param errorLink - URL to documentation about this error
      * @param cause - The cause of the error
+     * @param headers - The response headers, lowercase-keyed
      */
-    constructor(statusCode: number, errorType: APIErrorType, errorMessage: string, correlationId?: string, errorLink?: string, cause?: Error);
+    constructor(statusCode: number, errorType: APIErrorType, errorMessage: string, correlationId?: string, errorLink?: string, cause?: Error, headers?: Record<string, string | string[]>);
     /**
      * Convert the error to a JSON object, excluding undefined properties
      *
@@ -166,6 +221,203 @@ export declare type BadGatewayErrorResponse = Error_2;
  */
 export declare type BlockchainAddress = string;
 
+/**
+ * A borrow position held by a smart account in a borrow product, together with its live onchain state read at a point-in-time snapshot.
+ */
+export declare interface BorrowPosition {
+    borrowProductId: BorrowProductId;
+    /**
+     * The smart account address that owns the borrow position.
+     * @pattern ^0x[0-9a-fA-F]{40}$
+     */
+    address: string;
+    network: BorrowProductNetwork;
+    snapshot: BorrowProductSnapshot;
+    onchainState: BorrowPositionOnchainState;
+}
+
+/**
+ * The balance of either the collateral or debt token for a borrow position, as a decimal string in the token's standard unit denomination.
+ */
+export declare interface BorrowPositionAssetAmount {
+    /**
+     * The stable identifier for the asset within the borrow product, which is a UUID prefixed with the string `bp_asset_`. This matches the `assetId` of the corresponding asset on the borrow product.
+     * @pattern ^bp_asset_[a-f0-9-]{36}$
+     */
+    assetId: string;
+    /** The onchain token this balance is denominated in. */
+    token: BorrowProductToken;
+    /** The token balance as a decimal string in the token's standard unit denomination (i.e. "5000" for 5000 mGLO). */
+    amount: PositiveDecimal;
+}
+
+/**
+ * The debt balance for a borrow position, including accrued interest, plus its current borrow rate.
+ */
+export declare type BorrowPositionDebt = BorrowPositionAssetAmount & BorrowPositionDebtAllOf;
+
+export declare type BorrowPositionDebtAllOf = {
+    /**
+     * The current annualized borrow rate for the debt, expressed in basis points. For example, `525` represents a borrow APY of 5.25%. Omitted when the rate is unavailable.
+     * @minimum 0
+     */
+    borrowApyBps?: number;
+};
+
+/**
+ * The aggregate health of a borrow position.
+
+ - `no_debt`: the position has no outstanding debt.
+ - `healthy`: the position has debt and is above its liquidation threshold.
+ - `undercollateralized`: the position is at or below its liquidation threshold and may be eligible for liquidation.
+ */
+export declare type BorrowPositionHealthStatus = (typeof BorrowPositionHealthStatus)[keyof typeof BorrowPositionHealthStatus];
+
+export declare const BorrowPositionHealthStatus: {
+    readonly no_debt: "no_debt";
+    readonly healthy: "healthy";
+    readonly undercollateralized: "undercollateralized";
+};
+
+/**
+ * The live onchain state of a borrow position. The `type` field indicates which protocol-specific schema describes the state.
+ */
+export declare type BorrowPositionOnchainState = MorphoBlueOnchainState;
+
+/**
+ * A borrow product on an EVM network, operated by a lending protocol such as Morpho Blue.
+ A borrow product is a protocol-native representation of a borrowable market,  describing the venue that hosts it, the assets that are borrowed or borrowed against  in it, a point-in-time snapshot of its onchain state, and the protocol-specific  immutable parameters that uniquely define it.
+ */
+export declare interface BorrowProduct {
+    borrowProductId: BorrowProductId;
+    network: BorrowProductNetwork;
+    /** A human-readable name for the product, typically derived from its loan and collateral tokens. */
+    name: string;
+    venue: BorrowProductVenue;
+    /** The assets available to be borrowed or borrowed against in this market. */
+    assets: BorrowProductAsset[];
+    snapshot: BorrowProductSnapshot;
+    protocolDetails: BorrowProductProtocolDetails;
+}
+
+/**
+ * The assets available to be borrowed or borrowed against in this market, together with the capabilities (collateral and/or debt) they provide.
+ */
+export declare interface BorrowProductAsset {
+    /**
+     * A stable identifier for the asset within the product, which is a UUID prefixed with the string `bp_asset_`.
+     * @pattern ^bp_asset_[a-f0-9-]{36}$
+     */
+    assetId: string;
+    /** The onchain token that can be used as collateral or debt. */
+    token: BorrowProductToken;
+    /**
+     * The capabilities this asset provides within the borrow product. An asset may be used as collateral and/or debt.
+     * @minItems 1
+     */
+    capabilities: BorrowProductAssetCapability[];
+}
+
+/**
+ * A capability an asset provides within a borrow product, describing the role the asset plays, either as collateral or debt, and whether that capability is currently active.
+ */
+export declare interface BorrowProductAssetCapability {
+    /** The role the asset plays within the product. `collateral` indicates the asset can be posted as collateral, and `debt` indicates the asset can be borrowed. */
+    type: BorrowProductAssetCapabilityType;
+    /** Whether this capability is currently active. For example, an asset with a `collateral` capability and `enabled: false` cannot currently be borrowed against.
+     Some venues may temporarily disable an asset's capability, which will be  reflected in the `enabled` field. This would not affect any user's existing  borrow positions. */
+    enabled: boolean;
+}
+
+/**
+ * The role the asset plays within the product. `collateral` indicates the asset can be posted as collateral, and `debt` indicates the asset can be borrowed.
+ */
+export declare type BorrowProductAssetCapabilityType = (typeof BorrowProductAssetCapabilityType)[keyof typeof BorrowProductAssetCapabilityType];
+
+export declare const BorrowProductAssetCapabilityType: {
+    readonly collateral: "collateral";
+    readonly debt: "debt";
+};
+
+/**
+ * The globally unique ID of the borrow product, which is a UUID prefixed with the string `bp_`.
+ * @pattern ^bp_[a-f0-9-]{36}$
+ */
+export declare type BorrowProductId = string;
+
+/**
+ * The name of the EVM network that a borrow product is deployed on.
+ */
+export declare type BorrowProductNetwork = (typeof BorrowProductNetwork)[keyof typeof BorrowProductNetwork];
+
+export declare const BorrowProductNetwork: {
+    readonly base: "base";
+};
+
+/**
+ * The lending protocol that operates the borrow product.
+ */
+export declare type BorrowProductProtocol = (typeof BorrowProductProtocol)[keyof typeof BorrowProductProtocol];
+
+export declare const BorrowProductProtocol: {
+    readonly morpho_blue: "morpho_blue";
+};
+
+/**
+ * Protocol-specific immutable onchain details that uniquely define a borrow product. The `type` field indicates which protocol-specific schema describes the product's details.
+ */
+export declare type BorrowProductProtocolDetails = MorphoBlueProtocolDetails;
+
+/**
+ * The point-in-time at which onchain state, such as a borrow product or borrow position, was captured. This is when the data was last read from the chain.
+ */
+export declare interface BorrowProductSnapshot {
+    /** The block number at which the state was observed. */
+    blockNumber: number;
+    /**
+     * The hash of the block at which the state was observed.
+     * @pattern ^0x[0-9a-fA-F]{64}$
+     */
+    blockHash: string;
+    /** The onchain block timestamp at which the state was observed in Unix seconds. */
+    blockTimestamp: number;
+    /** The timestamp at which the state was observed. */
+    observedAt: string;
+}
+
+/**
+ * A token on an EVM borrow product network.
+ */
+export declare interface BorrowProductToken {
+    /**
+     * The contract address of the token.
+     * @pattern ^0x[0-9a-fA-F]{40}$
+     */
+    address: string;
+    /** The symbol of the token (e.g. USDC, WETH). */
+    symbol: string;
+    /** The number of decimal places used by the token. */
+    decimals: number;
+}
+
+/**
+ * The onchain venue that hosts a borrow product. The venue comprises the protocol and  network the product is deployed on. An example of a venue would be Morpho Blue on  Base Mainnet.
+ */
+export declare interface BorrowProductVenue {
+    /**
+     * A stable identifier for the venue, which is a UUID prefixed with the string `bp_venue_`.
+     * @pattern ^bp_venue_[a-f0-9-]{36}$
+     */
+    venueId: string;
+    /**
+     * The contract address of the venue's entrypoint.
+     * @pattern ^0x[0-9a-fA-F]{40}$
+     */
+    entrypointAddress: string;
+    /** A human-readable name for the venue. */
+    name: string;
+}
+
 /**
  * The name of a capability. Capabilities represent granular functional permissions
  that determine what actions a customer can perform. Each capability must be
@@ -175,14 +427,14 @@ export declare type BlockchainAddress = string;
 export declare type CapabilityName = (typeof CapabilityName)[keyof typeof CapabilityName];
 
 export declare const CapabilityName: {
-    readonly custodyCrypto: "custodyCrypto";
-    readonly custodyFiat: "custodyFiat";
-    readonly custodyStablecoin: "custodyStablecoin";
-    readonly tradeCrypto: "tradeCrypto";
-    readonly tradeStablecoin: "tradeStablecoin";
-    readonly transferCrypto: "transferCrypto";
-    readonly transferFiat: "transferFiat";
-    readonly transferStablecoin: "transferStablecoin";
+    readonly CustodyCrypto: "custodyCrypto";
+    readonly CustodyFiat: "custodyFiat";
+    readonly CustodyStablecoin: "custodyStablecoin";
+    readonly TradeCrypto: "tradeCrypto";
+    readonly TradeStablecoin: "tradeStablecoin";
+    readonly TransferCrypto: "transferCrypto";
+    readonly TransferFiat: "transferFiat";
+    readonly TransferStablecoin: "transferStablecoin";
 };
 
 /**
@@ -190,11 +442,26 @@ export declare const CapabilityName: {
  * to the request headers.
  *
  * @param {AxiosRequestConfig} config - The Axios request configuration.
- * @param idempotencyKey - The idempotency key.
+ * @param options - Per-request options, or a bare idempotency key string (legacy form).
  * @returns {Promise<T>} A promise that resolves to the response data.
  * @throws {APIError} If the request fails.
  */
-declare const cdpApiClient: <T>(config: AxiosRequestConfig, idempotencyKey?: string) => Promise<T>;
+declare const cdpApiClient: <T>(config: AxiosRequestConfig, options?: CdpApiClientOptions | string) => Promise<T>;
+
+/**
+ * Per-request options accepted as the second parameter of {@link cdpApiClient}
+ * (the `options` argument of every generated operation).
+ */
+export declare type CdpApiClientOptions = {
+    /** Idempotency key for safe retries, sent as the X-Idempotency-Key header. */
+    idempotencyKey?: string;
+    /**
+     * Opaque per-request MFA challenge handle, sent as the X-Mfa-Challenge-Id
+     * header on the MFA initiate and submit endpoints when the project's
+     * `verificationScope` is `request`.
+     */
+    mfaChallengeId?: string;
+};
 
 /**
  * The options for the CDP API Client.
@@ -239,6 +506,44 @@ export declare type CdpOptions = {
     platform?: string;
 };
 
+/**
+ * A request to close an end user smart account's borrow position for the specified borrow product.
+ Closing fully repays the position's outstanding loan and withdraws all remaining collateral back to the smart account, broadcasting a single user operation to settle the position onchain. There is no partial close; use `adjustBorrowPositionWithEndUserAccount` to adjust a position without closing it.
+ */
+export declare interface CloseBorrowPositionRequest {
+    borrowProductId: BorrowProductId;
+    /**
+     * The ID of the Temporary Wallet Secret that was used to sign the X-Wallet-Auth header.
+     * @pattern ^[a-zA-Z0-9-]{1,100}$
+     */
+    walletSecretId: string;
+    /** Whether to use the CDP Paymaster for the user operation. When `true`, `paymasterUrl` must not be set. */
+    useCdpPaymaster: boolean;
+    /** Paymaster URL to use for the user operation. Must not be set when `useCdpPaymaster` is `true`.
+     If `useCdpPaymaster` is `false` and no `paymasterUrl` is set, the smart account must have sufficient funds to cover network fees. */
+    paymasterUrl?: Url;
+    /** Optional paymaster metadata forwarded to the configured paymaster service. Valid only when a paymaster is configured via `useCdpPaymaster: true` or a `paymasterUrl`. */
+    paymasterContext?: PaymasterContext;
+}
+
+/**
+ * Closes an end user smart account's borrow position by fully repaying its outstanding loan and withdrawing all remaining collateral back to the smart account, in a single user operation.
+ A borrow position is identified by the smart account `address` and the `borrowProductId` in the request body, since a smart account holds at most one position per borrow product. Closing repays the entire accrued debt and withdraws the full collateral balance; there is no partial close. To adjust a position without closing it, use `adjustBorrowPositionWithEndUserAccount` instead.
+ A user operation is broadcast to close the position onchain. Poll `getUserOperationWithEndUserAccount` with the returned `userOpHash` until it reaches a terminal state. Once the user operation succeeds onchain, the position is closed and no longer appears in the borrow positions list.
+ * @summary Close a borrow position for an end user smart account
+ */
+export declare const closeBorrowPositionWithEndUserAccount: (userId: string, address: string, closeBorrowPositionRequest: CloseBorrowPositionRequest, params?: CloseBorrowPositionWithEndUserAccountParams, options?: SecondParameter<typeof cdpApiClient<EvmUserOperation>>) => Promise<EvmUserOperation>;
+
+export declare type CloseBorrowPositionWithEndUserAccountParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type CloseBorrowPositionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof closeBorrowPositionWithEndUserAccount>>>;
+
 /**
  * Configures the CDP client with the given options.
  *
@@ -246,6 +551,48 @@ export declare type CdpOptions = {
  */
 export declare const configureCdpApiClient: (options: CdpOptions) => void;
 
+/**
+ * A request to create a borrow position for an end user's smart account for the specified borrow product.
+ The smart account posts collateral and borrows against it, broadcasting a user operation  to open the position onchain.
+ */
+export declare interface CreateBorrowPositionRequest {
+    borrowProductId: BorrowProductId;
+    /** The amount of collateral to post, as a decimal string in standard unit denomination of the collateral token (i.e. "1" for 1 cbBTC). */
+    collateralAmount: PositiveDecimal;
+    /** The amount of the loan token to borrow, as a decimal string in standard unit denomination of the loan token (i.e. "100" for 100 USDC). */
+    loanAmount: PositiveDecimal;
+    /**
+     * The ID of the Temporary Wallet Secret that was used to sign the X-Wallet-Auth header.
+     * @pattern ^[a-zA-Z0-9-]{1,100}$
+     */
+    walletSecretId: string;
+    /** Whether to use the CDP Paymaster for the user operation. When `true`, `paymasterUrl` must not be set. */
+    useCdpPaymaster: boolean;
+    /** Paymaster URL to use for the user operation. Must not be set when `useCdpPaymaster` is `true`.
+     If `useCdpPaymaster` is `false` and no `paymasterUrl` is set, the smart account must have sufficient funds to cover network fees. */
+    paymasterUrl?: Url;
+    /** Optional paymaster metadata forwarded to the configured paymaster service. Valid only when a paymaster is configured via `useCdpPaymaster: true` or a `paymasterUrl`. */
+    paymasterContext?: PaymasterContext;
+}
+
+/**
+ * Creates a borrow position for a specific borrow product, by posting collateral from an end user smart account and borrowing a loan against it. One position can be opened per borrow product for a given smart account.
+ A borrow product is a protocol-native representation of a borrowable market, such as a Morpho Blue market that lends USDC against cbBTC. The `borrowProductId` identifies the product to borrow against, and the `collateralAmount` and `loanAmount` specify the collateral to post and the loan to take, both expressed as decimal strings in standard unit denomination of their respective tokens.
+ A user operation is broadcast to open the position onchain. Poll `getUserOperationWithEndUserAccount` with the returned `userOpHash` until it reaches a terminal state. Once the user operation succeeds onchain, use the borrow positions list endpoint to view the user's active positions.
+ * @summary Create a borrow position for an end user smart account
+ */
+export declare const createBorrowPositionWithEndUserAccount: (userId: string, address: string, createBorrowPositionRequest: CreateBorrowPositionRequest, params?: CreateBorrowPositionWithEndUserAccountParams, options?: SecondParameter<typeof cdpApiClient<EvmUserOperation>>) => Promise<EvmUserOperation>;
+
+export declare type CreateBorrowPositionWithEndUserAccountParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type CreateBorrowPositionWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof createBorrowPositionWithEndUserAccount>>>;
+
 /**
  * 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.
  * @summary Create delegation for end user
@@ -973,7 +1320,7 @@ export declare interface EndUserBtcAccount {
     addressType: EndUserBtcAccountAddressType;
     /** The Bitcoin network this account is associated with. */
     network: EndUserBtcAccountNetwork;
-    /** The BIP-32 extended public key (xpub) at the account derivation path, base58check encoded, used to derive child addresses. Present only when the response includes it explicitly (the `createEndUserBtcAccount` response, or `getAuthenticatedEndUser` with `includeBtcXpubs=true`); otherwise omitted. */
+    /** The BIP-32 extended public key (xpub) at the account derivation path, base58check encoded, used to derive child addresses. Present only when the response includes it explicitly (the `createEndUserBtcAccount` or `addEndUserBtcAccount` response, or `getAuthenticatedEndUser` with `includeBtcXpubs=true`); otherwise omitted. */
     xpub?: string;
     /**
      * The lowercase hex-encoded SHA-256 of the UTF-8 bytes of the `xpub` string (the base58check-encoded form exactly as returned, not the decoded key bytes). Used as a stable identifier to select the proper account during signing. This is intentionally not the BIP-32 key fingerprint: hashing the full string form avoids the fingerprint's 4-byte collision risk and yields an identifier that can be recomputed consistently without decoding the key.
@@ -1290,6 +1637,7 @@ export declare const ErrorType: {
     readonly asset_mismatch: "asset_mismatch";
     readonly mfa_already_enrolled: "mfa_already_enrolled";
     readonly mfa_invalid_code: "mfa_invalid_code";
+    readonly mfa_challenge_not_found: "mfa_challenge_not_found";
     readonly mfa_flow_expired: "mfa_flow_expired";
     readonly mfa_required: "mfa_required";
     readonly mfa_not_enrolled: "mfa_not_enrolled";
@@ -1401,6 +1749,9 @@ export declare const EvmSwapsNetwork: {
     readonly polygon: "polygon";
 };
 
+/**
+ * A smart account operation response.
+ */
 export declare interface EvmUserOperation {
     network: EvmUserOperationNetwork;
     /**
@@ -1455,6 +1806,46 @@ export declare const EvmUserOperationStatus: {
     readonly failed: "failed";
 };
 
+/**
+ * Export an existing Bitcoin HD (Hierarchical Deterministic) account's master seed as encrypted BIP39 entropy. The 32-byte entropy is encrypted in transport to the provided RSA public key and can be encoded into a BIP39 mnemonic (seed phrase) client-side to import the account into a compatible wallet. It is important to store the exported seed phrase in a secure place after it's exported.
+ * @summary Export end user Bitcoin account
+ */
+export declare const exportEndUserBtcAccount: (userId: string, exportEndUserBtcAccountBody: ExportEndUserBtcAccountBody, params?: ExportEndUserBtcAccountParams, options?: SecondParameter<typeof cdpApiClient<ExportEndUserBtcAccount200>>) => Promise<ExportEndUserBtcAccount200>;
+
+export declare type ExportEndUserBtcAccount200 = {
+    /** The base64-encoded, encrypted 32-byte BIP39 entropy of the Bitcoin HD account. This is the initial entropy (not a PBKDF2-derived BIP39 seed): it is encrypted in transport using the exportEncryptionKey in the request and is encoded into a 24-word BIP39 mnemonic (seed phrase) client-side. */
+    encryptedEntropy: string;
+};
+
+export declare type ExportEndUserBtcAccountBody = {
+    /**
+     * The ID of the Temporary Wallet Secret that was used to sign the X-Wallet-Auth Header.
+     * @pattern ^[a-zA-Z0-9-]{1,100}$
+     */
+    walletSecretId: string;
+    /**
+     * The lowercase hex-encoded SHA-256 of the UTF-8 bytes of the `xpub` string (the base58check-encoded form exactly as returned, not the decoded key bytes). Selects which of the end user's Bitcoin accounts to export. Use the `xpubHash` returned with the account when it is created or retrieved.
+     * @pattern ^[0-9a-f]{64}$
+     */
+    xpubHash: string;
+    /** The base64-encoded, public part of the RSA key in DER format used to encrypt the account entropy. */
+    exportEncryptionKey: string;
+    /** The origin of the parent site that opened the secure iframe. This origin will be validated against the project's configured allowed origins. Must be a valid origin in the format <scheme>://<host>(:<port>) (e.g., https://example.com, http://localhost:3000). */
+    parentOrigin?: Url;
+    /** If true, the account is ejected after the master seed is exported. Ejection immediately blocks all signing and sending operations on this account. The master seed can still be re-exported during the server-controlled grace period. Setting eject to false or omitting it does not cancel ejection, and re-exporting does not extend or reset the grace period. After the grace period (TTL), the HD key material is permanently deleted from Coinbase systems. This action is irreversible. Ejection is an opt-in feature. To enable it, reach out to us on Discord. */
+    eject?: boolean;
+};
+
+export declare type ExportEndUserBtcAccountParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type ExportEndUserBtcAccountResult = NonNullable<Awaited<ReturnType<typeof exportEndUserBtcAccount>>>;
+
 /**
  * Export an existing end user EVM account's private key. It is important to store the private key in a secure place after it's exported.
  * @summary Export end user EVM account
@@ -1481,7 +1872,7 @@ export declare type ExportEndUserEvmAccountBody = {
     walletSecretId: string;
     /** The origin of the parent site that opened the secure iframe. This origin will be validated against the project's configured allowed origins. Must be a valid origin in the format <scheme>://<host>(:<port>) (e.g., https://example.com, http://localhost:3000). */
     parentOrigin?: Url;
-    /** If true, the account is ejected after the private key is exported. Ejection immediately blocks all signing and sending operations on this account. The private key can still be re-exported during the grace period with eject set to false. After the configured grace period (TTL), the key material is permanently deleted from Coinbase systems. This action is irreversible. Ejection is an opt-in feature. To enable it, reach out to us on Discord. */
+    /** If true, the account is ejected after the private key is exported. Ejection immediately blocks all signing and sending operations on this account. The private key can still be re-exported during the server-controlled grace period. Setting eject to false or omitting it does not cancel ejection, and re-exporting does not extend or reset the grace period. After the grace period (TTL), the key material is permanently deleted from Coinbase systems. This action is irreversible. Ejection is an opt-in feature. To enable it, reach out to us on Discord. */
     eject?: boolean;
 };
 
@@ -1521,7 +1912,7 @@ export declare type ExportEndUserSolanaAccountBody = {
     walletSecretId: string;
     /** The origin of the parent site that opened the secure iframe. This origin will be validated against the project's configured allowed origins. Must be a valid origin in the format <scheme>://<host>(:<port>) (e.g., https://example.com, http://localhost:3000). */
     parentOrigin?: Url;
-    /** If true, the account is ejected after the private key is exported. Ejection immediately blocks all signing and sending operations on this account. The private key can still be re-exported during the grace period with eject set to false. After the configured grace period (TTL), the key material is permanently deleted from Coinbase systems. This action is irreversible. Ejection is an opt-in feature. To enable it, reach out to us on Discord. */
+    /** If true, the account is ejected after the private key is exported. Ejection immediately blocks all signing and sending operations on this account. The private key can still be re-exported during the server-controlled grace period. Setting eject to false or omitting it does not cancel ejection, and re-exporting does not extend or reset the grace period. After the grace period (TTL), the key material is permanently deleted from Coinbase systems. This action is irreversible. Ejection is an opt-in feature. To enable it, reach out to us on Discord. */
     eject?: boolean;
 };
 
@@ -1572,7 +1963,7 @@ export declare type GetAuthenticatedEndUserParams = {
     /**
      * When `true`, each Bitcoin account in `btcAccountObjects` includes its raw `xpub`. When `false` (the default), only `xpubHash` is returned.
      */
-    includeBtcXpubs?: boolean;
+    includeBtcXpubs?: IncludeBtcXpubsParameter;
 };
 
 export declare type GetAuthenticatedEndUserResult = NonNullable<Awaited<ReturnType<typeof getAuthenticatedEndUser>>>;
@@ -1802,6 +2193,23 @@ export declare type GetEndUserEvmSwapPriceParams = {
 
 export declare type GetEndUserEvmSwapPriceResult = NonNullable<Awaited<ReturnType<typeof getEndUserEvmSwapPrice>>>;
 
+/**
+ * Gets a single borrow product by its ID.
+ The ID is a stable identifier that uniquely identifies a single borrow product based on the product's onchain parameters. A borrow product is a protocol-native representation of a borrowable market, describing the venue that hosts it and the assets that participate in it together with their collateral and debt capabilities.
+ * @summary Get a borrow product
+ */
+export declare const getEvmBorrowProduct: (borrowProductId: BorrowProductId, params?: GetEvmBorrowProductParams, options?: SecondParameter<typeof cdpApiClient<BorrowProduct>>) => Promise<BorrowProduct>;
+
+export declare type GetEvmBorrowProductParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type GetEvmBorrowProductResult = NonNullable<Awaited<ReturnType<typeof getEvmBorrowProduct>>>;
+
 /**
  * Returns the EIP-7702 delegation operation for an end user's EVM account. Use the delegationOperationId returned by the Create EIP-7702 delegation endpoint to poll for operation completion.
  * @summary Get EIP-7702 delegation operation for end user EVM account
@@ -1880,6 +2288,11 @@ export declare type IdempotencyErrorResponse = Error_2;
  */
 export declare type IdempotencyKeyParameter = string;
 
+/**
+ * When `true`, each Bitcoin account in `btcAccountObjects` includes its raw `xpub`. When `false` (the default), only `xpubHash` is returned.
+ */
+export declare type IncludeBtcXpubsParameter = boolean;
+
 /**
  * Initiates the authentication flow for an end user. This is an optionally authenticated endpoint. The exact response depends on the authentication method specified in the request body. If a valid access token is included in the Authorization header, it is treated as an attempt to add an additional authentication method to the existing user associated with the token. If the authentication method already exists, an error is returned.
  * @summary Initiate end user authentication
@@ -2029,8 +2442,13 @@ export declare interface InitiateMfaEnrollmentTotpResponse {
 
 /**
  * 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 SMS, generates and sends a 6-digit OTP to the enrolled phone number. For TOTP, user generates code from their authenticator app.
+
  For passkey (WebAuthn), returns credential request options (in the response body) to pass to navigator.credentials.get() in the browser; the resulting assertion must be submitted to the submit endpoint. Only the passkey method returns a response body here; TOTP and SMS return `{}`.
+
+ When the project's `verificationScope` is `request`, the caller supplies the challenge from the `X-Mfa-Challenge-Id` header of the `403 mfa_required` response in the `X-Mfa-Challenge-Id` request header, which binds the ceremony to that request. A missing header is rejected. When the project's `verificationScope` is `session`, the caller doesn't need to supply the header.
+
  Passkey requests must carry an `Origin` header that is one of the project's configured CORS origins and is either `https://` or `http://localhost`; otherwise the request is rejected with a 400. Only passkeys enrolled from that exact host are offered, so a user with passkeys on other hosts only receives a 404 here and must enroll a passkey for this origin.
  * @summary Initiate MFA verification
  */
@@ -2369,6 +2787,84 @@ export declare const isRefreshTokenUnavailableError: (error: unknown) => error i
  */
 export declare const isTransientTokenReadError: (error: RefreshTokenUnavailableError) => boolean;
 
+/**
+ * Lists the borrow positions held by an end user smart account, with the live onchain state of each position read at a point-in-time snapshot.
+ A borrow position represents collateral posted and a loan borrowed against it in a borrow product, such as a Morpho Blue market that lends USDC against cbBTC. Each position reports its current collateral and debt balances, its health factor, and its health status. Returns an empty list if the smart account has no borrow positions.
+ * @summary List borrow positions for an end user smart account
+ */
+export declare const listBorrowPositionsWithEndUserAccount: (userId: string, address: string, params?: ListBorrowPositionsWithEndUserAccountParams, options?: SecondParameter<typeof cdpApiClient<ListBorrowPositionsWithEndUserAccount200>>) => Promise<ListBorrowPositionsWithEndUserAccount200>;
+
+export declare type ListBorrowPositionsWithEndUserAccount200 = ListBorrowPositionsWithEndUserAccount200AllOf & ListResponse;
+
+/**
+ * Response containing a list of borrow positions.
+ */
+export declare type ListBorrowPositionsWithEndUserAccount200AllOf = {
+    /** The borrow positions held by the smart account. */
+    borrowPositions: BorrowPosition[];
+};
+
+export declare type ListBorrowPositionsWithEndUserAccountParams = {
+    /**
+     * The number of resources to return per page.
+     */
+    pageSize?: PageSizeParameter;
+    /**
+     * The token for the next page of resources, if any.
+     */
+    pageToken?: PageTokenParameter;
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+};
+
+export declare type ListBorrowPositionsWithEndUserAccountResult = NonNullable<Awaited<ReturnType<typeof listBorrowPositionsWithEndUserAccount>>>;
+
+/**
+ * Lists the borrow products available across all supported networks and protocols. If a network and/or protocol query parameter is supplied, then borrow products are filtered and returned accordingly.
+ A borrow product is a protocol-native representation of a borrowable market, describing the venue that hosts it, the assets that can be borrowed or posted as collateral, and their collateral and debt capabilities. For example, a Morpho Blue market that lends USDC against cbBTC.
+ * @summary List borrow products
+ */
+export declare const listEvmBorrowProducts: (params?: ListEvmBorrowProductsParams, options?: SecondParameter<typeof cdpApiClient<ListEvmBorrowProducts200>>) => Promise<ListEvmBorrowProducts200>;
+
+export declare type ListEvmBorrowProducts200 = ListEvmBorrowProducts200AllOf & ListResponse;
+
+/**
+ * Response containing a list of borrow products.
+ */
+export declare type ListEvmBorrowProducts200AllOf = {
+    /** The list of borrow products, optionally filtered by the supplied network and/or protocol. */
+    borrowProducts: BorrowProduct[];
+};
+
+export declare type ListEvmBorrowProductsParams = {
+    /**
+     * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
+     * @pattern ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+     */
+    projectID?: ProjectIDOptionalParameter;
+    /**
+     * The EVM network name to list borrow products for.
+     */
+    network?: BorrowProductNetwork;
+    /**
+     * The lending protocol whose borrow products to list.
+     */
+    protocol?: BorrowProductProtocol;
+    /**
+     * The number of resources to return per page.
+     */
+    pageSize?: PageSizeParameter;
+    /**
+     * The token for the next page of resources, if any.
+     */
+    pageToken?: PageTokenParameter;
+};
+
+export declare type ListEvmBorrowProductsResult = NonNullable<Awaited<ReturnType<typeof listEvmBorrowProducts>>>;
+
 /**
  * Lists the passkey (WebAuthn) credentials enrolled by the end user. Never returns the COSE public key or other sensitive credential material.
  * @summary List passkeys
@@ -2439,6 +2935,18 @@ export declare type LogOutEndUserResult = NonNullable<Awaited<ReturnType<typeof
  */
 export declare type MfaAlreadyEnrolledErrorResponse = Error_2;
 
+/**
+ * The challenge returned via the `X-Mfa-Challenge-Id` response header when the server rejected an mfa-required operation with `403 mfa_required`. Include as the `X-Mfa-Challenge-Id` request header of the MFA initiate and submit endpoints so the ceremony binds to that specific request. Required when the project's `verificationScope` is `request`; ignored under `session`.
+ For passkey, this ID keys the pending WebAuthn ceremony; the authenticator signs the ceremony's own WebAuthn challenge (returned by `initiateMfaVerification`) via `clientDataJSON`. For TOTP and SMS, this ID is the per-request binding — the 6-digit code signs nothing, so phishing resistance under `request` scope requires passkey.
+ * @pattern ^mfa_challenge_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
+ */
+export declare type MfaChallengeId = string;
+
+/**
+ * Sent as the `X-Mfa-Challenge-Id` request header on the MFA initiate and submit endpoints. See the `MfaChallengeId` schema for value semantics.
+ */
+export declare type MfaChallengeIdParameterParameter = string;
+
 /**
  * MFA configuration for a project.
  */
@@ -2449,7 +2957,9 @@ export declare interface MfaConfig {
     totpConfig: TotpConfig;
     smsConfig?: SmsConfig;
     passkeyConfig?: PasskeyConfig;
-    /** The duration in seconds for which a single MFA verification remains valid. After this period, the user must re-authenticate with MFA. */
+    verificationScope: MfaVerificationScope;
+    /** The duration in seconds for which a single MFA verification remains valid. After this period, the user must re-authenticate with MFA. Only applies when `verificationScope` is `session`; ignored under `request`, where each verification authorizes exactly one operation.
+     Read-only: the window is set server-side, 300 seconds by default, and is not writable through `updateMfaConfig`. */
     verificationWindowSeconds: number;
     /** Whether applications should prompt users for MFA enrollment during the login flow if they are not already enrolled. */
     promptEnrollmentOnLogin: boolean;
@@ -2510,6 +3020,95 @@ export declare type MFAMethodsTotp = {
     enrolledAt: string;
 };
 
+/**
+ * The configuration defining how a project enforces MFA. A project that has  never set one behaves as `session`.
+ Under `session` scope, one verification opens the project's verification window (`verificationWindowSeconds`, 300 by default), and any MFA-required operation inside that window is authorized.
+ Under `request` scope, one verification authorizes one sign/send request, bound to the pending challenge identified by `X-Mfa-Challenge-Id`. A failed submit consumes that challenge. The next attempt must re-initiate the flow; for SMS, that sends a new OTP. Under `session` scope, `mfa_invalid_code` leaves the retry loop open instead.
+ */
+export declare type MfaVerificationScope = (typeof MfaVerificationScope)[keyof typeof MfaVerificationScope];
+
+export declare const MfaVerificationScope: {
+    readonly MfaVerificationScopeSession: "session";
+    readonly MfaVerificationScopeRequest: "request";
+};
+
+/**
+ * Morpho Blue's immutable onchain market parameters that uniquely define a borrow product.
+ */
+export declare interface MorphoBlueMarketParams {
+    /**
+     * The Morpho Blue native bytes32 market ID that uniquely identifies  the underlying market onchain.
+     * @pattern ^0x[0-9a-fA-F]{64}$
+     */
+    onchainMarketId: string;
+    /** The token that is borrowed in the product. */
+    loanToken: BorrowProductToken;
+    /** The token posted as collateral in the product. */
+    collateralToken: BorrowProductToken;
+    /**
+     * The contract address of the oracle used to price the collateral token against the loan token.
+     * @pattern ^0x[0-9a-fA-F]{40}$
+     */
+    oracleAddress: string;
+    /**
+     * The contract address of the interest rate model that governs the product's borrow rate.
+     * @pattern ^0x[0-9a-fA-F]{40}$
+     */
+    interestRateModelAddress: string;
+    /**
+     * The liquidation loan-to-value of the product, expressed in basis points. For example, `9150` represents an LLTV of 91.5%.
+     * @minimum 0
+     * @maximum 10000
+     */
+    lltvBps: number;
+}
+
+/**
+ * The live onchain state of a Morpho Blue borrow position, read at the block described by the position's snapshot.
+ */
+export declare interface MorphoBlueOnchainState {
+    type: MorphoBlueOnchainStateType;
+    /** The non-zero collateral balances securing the position. */
+    collateral: BorrowPositionAssetAmount[];
+    /** The non-zero debt balances owed by the position. */
+    debt: BorrowPositionDebt[];
+    /** The position's liquidation headroom as a decimal string, where `1.0` is the liquidation boundary and higher is safer. For example, `1.79` means the position's weighted collateral is 1.79x its debt. Omitted when the position has no debt. */
+    healthFactor?: string;
+    /**
+     * The position's current loan-to-value, expressed in basis points. For example, `5000` represents a current LTV of 50%. Omitted when the position has no debt.
+     * @minimum 0
+     */
+    currentLtvBps?: number;
+    /**
+     * The loan-to-value at which the position becomes eligible for liquidation, expressed in basis points. For example, `8250` represents 82.5%. Omitted when the position has no debt.
+     * @minimum 0
+     * @maximum 10000
+     */
+    liquidationThresholdBps?: number;
+    healthStatus: BorrowPositionHealthStatus;
+}
+
+export declare type MorphoBlueOnchainStateType = (typeof MorphoBlueOnchainStateType)[keyof typeof MorphoBlueOnchainStateType];
+
+export declare const MorphoBlueOnchainStateType: {
+    readonly morpho_blue: "morpho_blue";
+};
+
+/**
+ * Morpho Blue-specific immutable onchain protocol details that uniquely define a borrow product.
+ */
+export declare interface MorphoBlueProtocolDetails {
+    type: MorphoBlueProtocolDetailsType;
+    /** The Morpho Blue market parameters that uniquely define the product onchain. */
+    marketParams: MorphoBlueMarketParams;
+}
+
+export declare type MorphoBlueProtocolDetailsType = (typeof MorphoBlueProtocolDetailsType)[keyof typeof MorphoBlueProtocolDetailsType];
+
+export declare const MorphoBlueProtocolDetailsType: {
+    readonly morpho_blue: "morpho_blue";
+};
+
 /**
  * The blockchain network for the payment. Supported networks depend on the account type.
  */
@@ -2641,6 +3240,23 @@ export declare interface OnrampSessionRequest {
     partnerUserRef?: string;
 }
 
+/**
+ * Borrow origination-fee configuration for a project.
+ */
+export declare interface OriginationFeeProjectConfig {
+    /**
+     * The EVM address that receives borrow origination fees.
+     * @pattern ^0x[a-fA-F0-9]{40}$
+     */
+    recipientAddress: string;
+    /**
+     * The customer-provided borrow origination-fee rate, in basis points.
+     * @minimum 0
+     * @maximum 1000
+     */
+    feeBps: number;
+}
+
 /**
  * An OTP email logo upload and its moderation state.
  */
@@ -2774,6 +3390,12 @@ export declare type PaymentMethodRequiredErrorResponse = Error_2;
  */
 export declare type PhoneNumber = string;
 
+/**
+ * A positive decimal string without scientific notation or whitespace.
+ * @pattern ^\+?(?:(?:0*[1-9]\d*)(?:\.\d*)?|0*\.\d*[1-9]\d*)$
+ */
+export declare type PositiveDecimal = string;
+
 /**
  * Configuration for a project.
  */
@@ -2791,10 +3413,13 @@ export declare interface ProjectConfig {
     iCloudAutoLinkingEnabled?: boolean;
     /** Whether delegated signing is enabled for this project. When enabled, end users can delegate transaction signing to the project. */
     delegatedSigningEnabled?: boolean;
+    /** The OAuth client ID attributed as the manager of this project. This field is informational only and must not be used for authorization. Omitted for projects not managed by an OAuth client. */
+    readonly managingOAuthClientId?: string;
     /** The verified cookie domain for this project, if one is active. When present, the SDK should route all auth requests through https://{activeCookieDomain}/v2/embedded-wallet-api/... so that first-party HttpOnly session cookies are scoped to the developer's domain. Absent when no cookie domain is registered or the registered domain is not yet active. */
     activeCookieDomain?: string;
     appAttestation?: AppAttestationProjectConfig;
     passkey?: PasskeyProjectConfig;
+    originationFee?: OriginationFeeProjectConfig;
     /** The project's OTP email logos, sorted by upload time from oldest to newest. When the latest upload is approved, only that logo is returned. When the latest upload is pending or rejected, the previously approved logo is also returned when one exists.
      */
     logos?: OtpEmailLogo[];
@@ -3863,6 +4488,8 @@ export declare type SignSolanaTransactionWithEndUserAccountBody = {
      * @pattern ^[1-9A-HJ-NP-Za-km-z]{32,44}$
      */
     address: string;
+    /** The Solana network the transaction targets. Required when using versioned transactions that reference address lookup tables, since resolving those tables requires querying a specific network. Optional otherwise. */
+    network?: SignSolanaTransactionWithEndUserAccountBodyNetwork;
     /** The base64 encoded transaction to sign. */
     transaction: string;
     /**
@@ -3872,6 +4499,16 @@ export declare type SignSolanaTransactionWithEndUserAccountBody = {
     walletSecretId?: string;
 };
 
+/**
+ * The Solana network the transaction targets. Required when using versioned transactions that reference address lookup tables, since resolving those tables requires querying a specific network. Optional otherwise.
+ */
+export declare type SignSolanaTransactionWithEndUserAccountBodyNetwork = (typeof SignSolanaTransactionWithEndUserAccountBodyNetwork)[keyof typeof SignSolanaTransactionWithEndUserAccountBodyNetwork];
+
+export declare const SignSolanaTransactionWithEndUserAccountBodyNetwork: {
+    readonly solana: "solana";
+    readonly "solana-devnet": "solana-devnet";
+};
+
 export declare type SignSolanaTransactionWithEndUserAccountParams = {
     /**
      * The ID of the CDP Project. Required for end users authenticated using custom auth (i.e. a non-CDP JWT provider).
@@ -4077,6 +4714,7 @@ export declare type SubmitMfaEnrollmentResult = NonNullable<Awaited<ReturnType<t
 /**
  * Submits an MFA code to complete the verification process.
  For passkey, the request must carry the same `Origin` header the verification was initiated from — the ceremony is bound to that exact origin (scheme, host, and port). A missing, disallowed, or differing `Origin` restarts the ceremony rather than silently changing the Relying Party ID.
+ When the project's `verificationScope` is `request`, the caller supplies the same `X-Mfa-Challenge-Id` request header that was passed to `initiateMfaVerification`. A mismatched or missing header is rejected. When the project's `verificationScope` is `session`, the caller doesn't need to supply the header.
  * @summary Submit MFA verification
  */
 export declare const submitMfaVerification: (userId: string, mfaMethod: "totp" | "sms" | "passkey", submitMfaVerificationRequest: SubmitMfaVerificationRequest, params?: SubmitMfaVerificationParams, options?: SecondParameter<typeof cdpApiClient<void>>) => Promise<void>;
@@ -4964,6 +5602,50 @@ export declare type X402UptoEvmPermit2PayloadPermit2AuthorizationWitness = {
     validAfter: string;
 };
 
+/**
+ * The x402 protocol upto scheme payload for Solana networks. The `upto` scheme authorizes a maximum amount and lets the resource server settle for the actual amount used.
+
+ A Solana transfer commits to an exact amount once signed, so this scheme escrows the ceiling in an onchain payment channel instead: the client signs an `open` transaction that deposits `maxAmount`, the facilitator co-signs it as fee payer and channel rent payer and broadcasts it before the resource runs, and the resource server later authorizes the metered charge with an Ed25519 voucher signed by the `receiverAuthorizer` key it advertised in the payment requirements `extra`. The facilitator seals and distributes the channel for that amount and refunds the remainder to the client.
+
+ The payment requirements `extra` for this scheme carries `feePayer` (from the facilitator `/supported` response), `receiverAuthorizer`, `withdrawDelay`, and `tokenProgram`. For more details, see [Solana Upto Scheme Details](https://github.com/x402-foundation/x402/blob/main/specs/schemes/upto/scheme_upto_svm.md).
+ */
+export declare interface X402UptoSolanaPayload {
+    /** The base58-encoded Solana address of the payer that funds the channel deposit. */
+    from: BlockchainAddress;
+    /**
+     * The maximum amount the client authorizes in atomic units of the payment asset. Equals the verification-phase `amount` of the payment requirements.
+     * @pattern ^[0-9]+$
+     */
+    maxAmount: string;
+    /**
+     * The amount escrowed in the payment channel by the `open` transaction, in atomic units. Must equal `maxAmount`.
+     * @pattern ^[0-9]+$
+     */
+    deposit: string;
+    /** The unix timestamp in seconds after which the settlement voucher is no longer valid. Must be nonzero. */
+    expiresAt: number;
+    /** The unix timestamp in seconds after which the payment is valid. */
+    validAfter: number;
+    /**
+     * The unique unsigned 64-bit salt, as a decimal string, encoded in the `open` instruction and used as a channel PDA seed.
+     * @pattern ^[0-9]+$
+     */
+    nonce: string;
+    /**
+     * The Solana slot, an unsigned 64-bit integer as a decimal string, encoded in the `open` instruction and used as a channel PDA seed.
+     * @pattern ^[0-9]+$
+     */
+    openSlot: string;
+    /** The base58-encoded program-derived address of the payment channel, derived from `from`, the fee payer, the asset, the authorized signer, `nonce`, and `openSlot`. */
+    channelId: BlockchainAddress;
+    /** The base58-encoded Solana address authorized to sign settlement vouchers for this channel. Must equal the `receiverAuthorizer` advertised in the payment requirements `extra` field. */
+    authorizedSigner: BlockchainAddress;
+    /** The base64-encoded channel `open` transaction, signed by the payer. The facilitator adds its fee payer signature before broadcasting it. */
+    openTransaction: string;
+    /** The base58-encoded Ed25519 signature by `authorizedSigner` over the settlement voucher, which commits to `channelId`, the settled amount, and `expiresAt`. Added by the resource server on the settle request that claims the metered charge, and required there even when the settled amount is `0`. It is owned by the resource server, so verify and the deposit settle reject any client-supplied value. */
+    voucherSignature?: string;
+}
+
 /**
  * The x402 v1 network identifier. x402 v1 uses human-readable network names. Supported networks: Base mainnet and testnet, Solana mainnet and devnet.
  */
@@ -5103,7 +5785,7 @@ export declare type X402V2PaymentPayloadExtensions = {
 /**
  * The payload of the payment depending on the x402Version, scheme, and network. Discriminated by scheme-specific fields: exact-EVM/upto-EVM payloads carry a `signature`; exact-Solana carries a `transaction`; batch-settlement carries a `type` discriminator. See `x402BatchSettlementEvmPayload` for the documented batch-settlement variants.
  */
-export declare type X402V2PaymentPayloadPayload = X402ExactEvmPayload | X402ExactEvmPermit2Payload | X402ExactSolanaPayload | X402UptoEvmPermit2Payload | X402BatchSettlementEvmPayload;
+export declare type X402V2PaymentPayloadPayload = X402ExactEvmPayload | X402ExactEvmPermit2Payload | X402ExactSolanaPayload | X402UptoEvmPermit2Payload | X402UptoSolanaPayload | X402BatchSettlementEvmPayload;
 
 /**
  * The x402 v2 payment requirements. Uses CAIP-2 network identifiers and supports `exact`, `upto`, and `batch-settlement` schemes. Carries only the payment fields (no resource metadata — that is in the enclosing `x402V2PaymentPayload.resource`).