@coinbase/cdp-sdk 1.15.0 → 1.17.0

package/actions/evm/types.ts

@@ -13,7 +13,16 @@ import { Hex } from "../../types/misc.js";
 import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
 import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
 import type { SendTransactionOptions, TransactionResult } from "./sendTransaction.js";
-import type { SwapOptions, SwapResult, QuoteSwapOptions, QuoteSwapResult } from "./swap/types.js";
+import type {
+  AccountSwapOptions,
+  AccountSwapResult,
+  AccountQuoteSwapOptions,
+  AccountQuoteSwapResult,
+  SmartAccountSwapOptions,
+  SmartAccountSwapResult,
+  SmartAccountQuoteSwapOptions,
+  SmartAccountQuoteSwapResult,
+} from "./swap/types.js";
 import type { TransferOptions } from "./transfer/types.js";
 import type {
   WaitForUserOperationOptions,
@@ -256,11 +265,11 @@ export type AccountActions = Actions & {
    * This is useful when you need to get swap details before executing the swap.
    * The taker is automatically set to the account's address.
    *
-   * @param {QuoteSwapOptions} options - Configuration options for creating the swap quote.
+   * @param {AccountQuoteSwapOptions} options - Configuration options for creating the swap quote.
    * @param {string} options.network - The network to create the quote on
-   * @param {string} options.fromToken - The token address to sell
-   * @param {string} options.toToken - The token address to buy
-   * @param {bigint} options.fromAmount - The amount of fromToken to sell
+   * @param {string} options.fromToken - The token address to send
+   * @param {string} options.toToken - The token address to receive
+   * @param {bigint} options.fromAmount - The amount of fromToken to send
    * @param {string} [options.signerAddress] - The signer address (only needed if taker is a smart contract)
    * @param {bigint} [options.gasPrice] - The gas price in Wei
    * @param {number} [options.slippageBps] - The slippage tolerance in basis points (0-10000)
@@ -281,30 +290,33 @@ export type AccountActions = Actions & {
    * }
    * ```
    */
-  quoteSwap: (options: QuoteSwapOptions) => Promise<QuoteSwapResult>;
+  quoteSwap: (options: AccountQuoteSwapOptions) => Promise<AccountQuoteSwapResult>;
 
   /**
    * Executes a token swap on the specified network.
    * This method handles all the steps required for a swap, including Permit2 signatures if needed.
+   * The taker is automatically set to the account's address.
    *
-   * @param {SwapOptions} options - Configuration options for the swap.
-   * @param {string} [options.network] - The network to execute the swap on
-   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method.
-   * @param {CreateSwapQuoteOptions} [options.swapOptions] - Options to create a swap quote. The function will call createSwapQuote internally.
-   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request.
+   * @param {AccountSwapOptions} options - Configuration options for the swap.
+   * @param {string} [options.network] - The network to execute the swap on (required for inline swaps)
+   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method
+   * @param {string} [options.fromToken] - The token address to send (required for inline swaps)
+   * @param {string} [options.toToken] - The token address to receive (required for inline swaps)
+   * @param {bigint} [options.fromAmount] - The amount of fromToken to send (required for inline swaps)
+   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request
    *
    * @returns A promise that resolves to the transaction hash.
    *
-   * @throws {Error} If liquidity is not available when using swapOptions.
+   * @throws {Error} If liquidity is not available when using inline options.
    *
    * @example **Using a pre-created swap quote**
    * ```ts
    * // First create a swap quote
    * const swapQuote = await cdp.evm.createSwapQuote({
    *   network: "base",
-   *   buyToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
-   *   sellToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-   *   sellAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
    *   taker: account.address
    * });
    *
@@ -322,21 +334,20 @@ export type AccountActions = Actions & {
    * console.log(`Swap executed with transaction hash: ${transactionHash}`);
    * ```
    *
-   * @example **Using swap options (all-in-one)**
+   * @example **Using inline options (all-in-one)**
    * ```ts
    * // Create and execute swap in one call
    * const { transactionHash } = await account.swap({
    *   network: "base",
-   *   buyToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
-   *   sellToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-   *   sellAmount: BigInt("1000000000000000000"), // 1 WETH in wei
-   *   taker: account.address
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
    * });
    *
    * console.log(`Swap executed with transaction hash: ${transactionHash}`);
    * ```
    */
-  swap: (options: SwapOptions) => Promise<SwapResult>;
+  swap: (options: AccountSwapOptions) => Promise<AccountSwapResult>;
 };
 
 export type SmartAccountActions = Actions & {
@@ -499,4 +510,95 @@ export type SmartAccountActions = Actions & {
   getUserOperation: (
     options: Omit<GetUserOperationOptions, "smartAccount">,
   ) => Promise<UserOperation>;
+
+  /**
+   * Creates a swap quote without executing the transaction.
+   * This is useful when you need to get swap details before executing the swap.
+   * The taker is automatically set to the smart account's address.
+   *
+   * @param {SmartAccountQuoteSwapOptions} options - Configuration options for creating the swap quote.
+   * @param {string} options.network - The network to create the quote on
+   * @param {string} options.fromToken - The token address to send
+   * @param {string} options.toToken - The token address to receive
+   * @param {bigint} options.fromAmount - The amount of fromToken to send
+   * @param {string} [options.signerAddress] - The signer address (only needed if taker is a smart contract)
+   * @param {bigint} [options.gasPrice] - The gas price in Wei
+   * @param {number} [options.slippageBps] - The slippage tolerance in basis points (0-10000)
+   *
+   * @returns A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
+   *
+   * @example
+   * ```ts
+   * const swapQuote = await smartAccount.quoteSwap({
+   *   network: "base",
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   * });
+   *
+   * if (swapQuote.liquidityAvailable) {
+   *   console.log(`Can swap for ${swapQuote.toAmount} USDC`);
+   * }
+   * ```
+   */
+  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
+
+  /**
+   * Executes a token swap on the specified network via a user operation.
+   * This method handles all the steps required for a swap, including Permit2 signatures if needed.
+   * The taker is automatically set to the smart account's address.
+   *
+   * @param {SmartAccountSwapOptions} options - Configuration options for the swap.
+   * @param {string} [options.network] - The network to execute the swap on (required for inline swaps)
+   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method
+   * @param {string} [options.fromToken] - The token address to send (required for inline swaps)
+   * @param {string} [options.toToken] - The token address to receive (required for inline swaps)
+   * @param {bigint} [options.fromAmount] - The amount of fromToken to send (required for inline swaps)
+   * @param {string} [options.paymasterUrl] - Optional paymaster URL for gas sponsorship
+   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request
+   *
+   * @returns A promise that resolves to the user operation result.
+   *
+   * @throws {Error} If liquidity is not available when using inline options.
+   *
+   * @example **Using a pre-created swap quote**
+   * ```ts
+   * // First create a swap quote
+   * const swapQuote = await cdp.evm.createSwapQuote({
+   *   network: "base",
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   *   taker: smartAccount.address,
+   *   signerAddress: smartAccount.owners[0].address
+   * });
+   *
+   * // Check if liquidity is available
+   * if (!swapQuote.liquidityAvailable) {
+   *   console.error("Insufficient liquidity for swap");
+   *   return;
+   * }
+   *
+   * // Execute the swap
+   * const { userOpHash } = await smartAccount.swap({
+   *   swapQuote: swapQuote
+   * });
+   *
+   * console.log(`Swap executed with user op hash: ${userOpHash}`);
+   * ```
+   *
+   * @example **Using inline options (all-in-one)**
+   * ```ts
+   * // Create and execute swap in one call
+   * const { userOpHash } = await smartAccount.swap({
+   *   network: "base",
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   * });
+   *
+   * console.log(`Swap executed with user op hash: ${userOpHash}`);
+   * ```
+   */
+  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
 };

package/client/evm/evm.ts

@@ -1,6 +1,6 @@
 import { constants, publicEncrypt } from "crypto";
 
-import { Address } from "viem";
+import { type Address, getTypesForEIP712Domain } from "viem";
 
 import { ImportEvmAccountPublicRSAKey } from "./constants.js";
 import {
@@ -62,7 +62,10 @@ import {
 } from "../../actions/evm/waitForUserOperation.js";
 import { Analytics } from "../../analytics.js";
 import { APIError } from "../../openapi-client/errors.js";
-import { CdpOpenApiClient } from "../../openapi-client/index.js";
+import {
+  CdpOpenApiClient,
+  EIP712Message as OpenAPIEIP712Message,
+} from "../../openapi-client/index.js";
 import { Hex } from "../../types/misc.js";
 import { decryptWithPrivateKey, generateExportEncryptionKeyPair } from "../../utils/export.js";
 
@@ -978,14 +981,22 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async signTypedData(options: SignTypedDataOptions): Promise<SignatureResult> {
+    const { domain, message, primaryType } = options;
+    const types = {
+      EIP712Domain: getTypesForEIP712Domain({ domain }),
+      ...options.types,
+    };
+
+    const openApiMessage: OpenAPIEIP712Message = {
+      domain,
+      types,
+      primaryType,
+      message,
+    };
+
     const signature = await CdpOpenApiClient.signEvmTypedData(
       options.address,
-      {
-        domain: options.domain,
-        types: options.types,
-        primaryType: options.primaryType,
-        message: options.message,
-      },
+      openApiMessage,
       options.idempotencyKey,
     );
 

package/client/evm/evm.types.ts

@@ -106,14 +106,18 @@ export interface CreateSwapQuoteOptions {
   fromToken: Address;
   /** The amount to send in atomic units of the token. */
   fromAmount: bigint;
-  /** The address that will perform the swap. */
-  taker?: Address;
-  /** The signer address (only needed if taker is a smart contract). */
+  /** The address receiving the output of the swap. */
+  taker: Address;
+  /** The address signing the swap (only needed if taker is a smart contract, i.e. for smart account swaps). */
   signerAddress?: Address;
-  /** The gas price in Wei. */
+  /** The smart account object (required for smart account execution context only). */
+  smartAccount?: SmartAccount;
+  /** The price per unit of gas in wei. */
   gasPrice?: bigint;
   /** The slippage tolerance in basis points (0-10000). */
   slippageBps?: number;
+  /** The idempotency key. */
+  idempotencyKey?: string;
 }
 
 /**
@@ -136,6 +140,8 @@ export interface GetSwapPriceOptions {
   gasPrice?: bigint;
   /** The slippage tolerance in basis points (0-10000). */
   slippageBps?: number;
+  /** The idempotency key. */
+  idempotencyKey?: string;
 }
 
 /**
@@ -186,8 +192,14 @@ export interface ExecuteSwapQuoteOptions {
  * Result of executing a swap quote.
  */
 export interface ExecuteSwapQuoteResult {
-  /** The transaction hash of the executed swap. */
-  transactionHash: Hex;
+  /** The transaction hash of the executed swap (for EOA swaps). */
+  transactionHash?: Hex;
+  /** The user operation hash of the executed swap (for smart account swaps). */
+  userOpHash?: Hex;
+  /** The address of the smart account (for smart account swaps). */
+  smartAccountAddress?: Address;
+  /** The status of the user operation (for smart accounts swaps). */
+  status?: typeof EvmUserOperationStatus.broadcast;
 }
 
 /**
@@ -393,7 +405,7 @@ export interface ListServerAccountsOptions {
  * A smart account that only contains the owner address.
  */
 export interface ReadonlySmartAccount
-  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions> {
+  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions | "__experimental_useNetwork"> {
   /** The owners of the smart account. */
   owners: Address[];
 }
@@ -599,3 +611,18 @@ export type GetSwapQuoteOptions = GetSwapPriceOptions;
 export type GetSwapQuoteResult = GetSwapPriceResult;
 export type SwapQuoteUnavailableResult = SwapUnavailableResult;
 export type SwapPriceUnavailableResult = SwapUnavailableResult;
+
+/**
+ * Options for signing and wrapping EIP-712 typed data with a smart account.
+ * This method handles the full smart account signature flow including replay-safe hashing.
+ */
+export interface SmartAccountSignAndWrapTypedDataOptions {
+  /** The chain ID for the signature (used for replay protection). */
+  chainId: bigint;
+  /** The EIP-712 typed data message to sign. */
+  typedData: EIP712Message;
+  /** The index of the owner to sign with (defaults to 0). */
+  ownerIndex?: bigint;
+  /** Optional idempotency key for the signing request. */
+  idempotencyKey?: string;
+}

package/client/policies/policies.ts

@@ -7,7 +7,11 @@ import {
   DeletePolicyOptions,
   UpdatePolicyOptions,
 } from "./policies.types.js";
-import { CdpOpenApiClient } from "../../openapi-client/index.js";
+import {
+  CdpOpenApiClient,
+  CreatePolicyBody,
+  UpdatePolicyBody,
+} from "../../openapi-client/index.js";
 import { CreatePolicyBodySchema, UpdatePolicyBodySchema } from "../../policies/schema.js";
 import { Policy } from "../../policies/types.js";
 
@@ -126,7 +130,11 @@ export class PoliciesClient implements PoliciesClientInterface {
    */
   async createPolicy(options: CreatePolicyOptions): Promise<Policy> {
     CreatePolicyBodySchema.parse(options.policy);
-    return CdpOpenApiClient.createPolicy(options.policy, options.idempotencyKey) as Promise<Policy>;
+    return CdpOpenApiClient.createPolicy(
+      // There are arbitrary differences between the abitype Abi and the openapi Abi
+      options.policy as CreatePolicyBody,
+      options.idempotencyKey,
+    ) as Promise<Policy>;
   }
 
   /**
@@ -239,7 +247,8 @@ export class PoliciesClient implements PoliciesClientInterface {
     UpdatePolicyBodySchema.parse(options.policy);
     return CdpOpenApiClient.updatePolicy(
       options.id,
-      options.policy,
+      // There are arbitrary differences between the abitype Abi and the openapi Abi
+      options.policy as UpdatePolicyBody,
       options.idempotencyKey,
     ) as Promise<Policy>;
   }

package/openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.ts

@@ -20,6 +20,10 @@ Account names are guaranteed to be unique across all EVM accounts in the develop
   name?: string;
   /** The list of policy IDs that apply to the account. This will include both the project-level policy and the account-level policy, if one exists. */
   policies?: string[];
+  /** The UTC ISO 8601 timestamp at which the account was created. */
+  createdAt?: string;
+  /** The UTC ISO 8601 timestamp at which the account was last updated. */
+  updatedAt?: string;
 }
 
 export interface ListResponse {
@@ -44,6 +48,7 @@ export const ErrorType = {
   invalid_signature: "invalid_signature",
   malformed_transaction: "malformed_transaction",
   not_found: "not_found",
+  payment_method_required: "payment_method_required",
   rate_limit_exceeded: "rate_limit_exceeded",
   request_canceled: "request_canceled",
   service_unavailable: "service_unavailable",
@@ -129,6 +134,10 @@ Account names are guaranteed to be unique across all Smart Accounts in the devel
    * @pattern ^[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$
    */
   name?: string;
+  /** The UTC ISO 8601 timestamp at which the account was created. */
+  createdAt?: string;
+  /** The UTC ISO 8601 timestamp at which the account was last updated. */
+  updatedAt?: string;
 }
 
 export interface EvmCall {
@@ -170,6 +179,7 @@ export const EvmUserOperationStatus = {
   signed: "signed",
   broadcast: "broadcast",
   complete: "complete",
+  dropped: "dropped",
   failed: "failed",
 } as const;
 
@@ -601,7 +611,201 @@ export interface EvmAddressCriterion {
   operator: EvmAddressCriterionOperator;
 }
 
-export type SignEvmTransactionCriteriaItem = EthValueCriterion | EvmAddressCriterion;
+/**
+ * A reference to an established EIP standard. When referencing a `KnownAbiType` within a policy rule configuring an `EvmDataCriterion`, criteria will only decode function data officially documented in the standard. For more information on supported token standards, see the links below.
+  - [erc20 - Token Standard](https://eips.ethereum.org/EIPS/eip-20).
+  - [erc721 - Non-Fungible Token Standard](https://eips.ethereum.org/EIPS/eip-721).
+  - [erc1155 - Multi Token Standard](https://eips.ethereum.org/EIPS/eip-1155).
+ */
+export type KnownAbiType = (typeof KnownAbiType)[keyof typeof KnownAbiType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const KnownAbiType = {
+  erc20: "erc20",
+  erc721: "erc721",
+  erc1155: "erc1155",
+} as const;
+
+/**
+ * Parameter definition for ABI functions, errors, and constructors.
+ */
+export interface AbiParameter {
+  /** The name of the parameter. */
+  name?: string;
+  /** The canonical type of the parameter. */
+  type: string;
+  /** The internal Solidity type used by the compiler. */
+  internalType?: string;
+  /** Used for tuple types. */
+  components?: AbiParameter[];
+}
+
+/**
+ * State mutability of a function in Solidity.
+ */
+export type AbiStateMutability = (typeof AbiStateMutability)[keyof typeof AbiStateMutability];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const AbiStateMutability = {
+  pure: "pure",
+  view: "view",
+  nonpayable: "nonpayable",
+  payable: "payable",
+} as const;
+
+/**
+ * The type of the ABI item, must be `function`.
+ */
+export type AbiFunctionType = (typeof AbiFunctionType)[keyof typeof AbiFunctionType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const AbiFunctionType = {
+  function: "function",
+} as const;
+
+/**
+ * ABI function type for contract functions.
+ */
+export interface AbiFunction {
+  /** The type of the ABI item, must be `function`. */
+  type: AbiFunctionType;
+  /** The name of the ABI function. */
+  name: string;
+  /** The list of ABI parameters used for this function. */
+  inputs: AbiParameter[];
+  /** The values returned by this function. */
+  outputs: AbiParameter[];
+  /** Deprecated. Use pure or view from stateMutability instead. */
+  constant?: boolean;
+  /** Deprecated. Use payable or nonpayable from `stateMutability` instead. */
+  payable?: boolean;
+  stateMutability: AbiStateMutability;
+  /** Deprecated. Vyper used to provide gas estimates. */
+  gas?: number;
+}
+
+/**
+ * The type of the ABI item.
+ */
+export type AbiInputType = (typeof AbiInputType)[keyof typeof AbiInputType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const AbiInputType = {
+  constructor: "constructor",
+  error: "error",
+  event: "event",
+  fallback: "fallback",
+  receive: "receive",
+} as const;
+
+/**
+ * Generic ABI item type encapsulating all other types besides `function`.
+ */
+export interface AbiInput {
+  /** The type of the ABI item. */
+  type: AbiInputType;
+  /** For additional information on the ABI JSON specification, see [the Solidity documentation](https://docs.soliditylang.org/en/latest/abi-spec.html#json). */
+  additionalProperties?: unknown;
+}
+
+export type AbiItem = AbiFunction | AbiInput;
+
+/**
+ * Contract ABI Specification following Solidity's external JSON interface format.
+ */
+export type Abi = AbiItem[];
+
+/**
+ * The operator to use for the comparison. The value resolved at the `name` will be on the left-hand side of the operator, and the `value` field will be on the right-hand side.
+ */
+export type EvmDataParameterConditionOperator =
+  (typeof EvmDataParameterConditionOperator)[keyof typeof EvmDataParameterConditionOperator];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmDataParameterConditionOperator = {
+  ">": ">",
+  ">=": ">=",
+  "<": "<",
+  "<=": "<=",
+  "==": "==",
+} as const;
+
+export interface EvmDataParameterCondition {
+  /** The name of the parameter to check against a transaction's calldata. If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter. */
+  name: string;
+  /** The operator to use for the comparison. The value resolved at the `name` will be on the left-hand side of the operator, and the `value` field will be on the right-hand side. */
+  operator: EvmDataParameterConditionOperator;
+  /** A single value to compare the value resolved at `name` to. All values are encoded as strings. Refer to the table in the documentation for how values should be encoded, and which operators are supported for each type. */
+  value: string;
+}
+
+/**
+ * The operator to use for the comparison. The value resolved at the `name` will be on the left-hand side of the operator, and the `values` field will be on the right-hand side.
+ */
+export type EvmDataParameterConditionListOperator =
+  (typeof EvmDataParameterConditionListOperator)[keyof typeof EvmDataParameterConditionListOperator];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmDataParameterConditionListOperator = {
+  in: "in",
+  not_in: "not in",
+} as const;
+
+export interface EvmDataParameterConditionList {
+  /** The name of the parameter to check against a transaction's calldata. If name is unknown, or is not named, you may supply an array index, e.g., `0` for first parameter. */
+  name: string;
+  /** The operator to use for the comparison. The value resolved at the `name` will be on the left-hand side of the operator, and the `values` field will be on the right-hand side. */
+  operator: EvmDataParameterConditionListOperator;
+  /** Values to compare against the resolved `name` value. All values are encoded as strings. Refer to the table in the documentation for how values should be encoded, and which operators are supported for each type. */
+  values: string[];
+}
+
+/**
+ * A list of parameter conditions to apply against encoded arguments in the transaction's `data` field.
+ */
+export type EvmDataConditionParamsItem = EvmDataParameterCondition | EvmDataParameterConditionList;
+
+/**
+ * A single condition to apply against the function and encoded arguments in the transaction's `data` field. Each `parameter` configuration must be successfully evaluated against the corresponding function argument in order for a policy to be accepted.
+ */
+export interface EvmDataCondition {
+  /** The name of a smart contract function being called. */
+  function: string;
+  /** An optional list of parameter conditions to apply against encoded arguments in the transaction's `data` field. */
+  params?: EvmDataConditionParamsItem[];
+}
+
+/**
+ * The type of criterion to use. This should be `evmData`.
+ */
+export type EvmDataCriterionType = (typeof EvmDataCriterionType)[keyof typeof EvmDataCriterionType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmDataCriterionType = {
+  evmData: "evmData",
+} as const;
+
+/**
+ * The ABI of the smart contract being called. This can be a partial structure with only specific functions.
+ */
+export type EvmDataCriterionAbi = KnownAbiType | Abi;
+
+/**
+ * A schema for specifying a criterion for the `data` field of an EVM transaction.
+ */
+export interface EvmDataCriterion {
+  /** The type of criterion to use. This should be `evmData`. */
+  type: EvmDataCriterionType;
+  /** The ABI of the smart contract being called. This can be a partial structure with only specific functions. */
+  abi: EvmDataCriterionAbi;
+  /** A list of conditions to apply against the function and encoded arguments in the transaction's `data` field. Each condition must be met in order for this policy to be accepted or rejected. */
+  conditions: EvmDataCondition[];
+}
+
+export type SignEvmTransactionCriteriaItem =
+  | EthValueCriterion
+  | EvmAddressCriterion
+  | EvmDataCriterion;
 
 /**
  * A schema for specifying criteria for the SignEvmTransaction operation.
@@ -689,7 +893,8 @@ export interface EvmNetworkCriterion {
 export type SendEvmTransactionCriteriaItem =
   | EthValueCriterion
   | EvmAddressCriterion
-  | EvmNetworkCriterion;
+  | EvmNetworkCriterion
+  | EvmDataCriterion;
 
 /**
  * A schema for specifying criteria for the SignEvmTransaction operation.
@@ -943,6 +1148,10 @@ Account names are guaranteed to be unique across all Solana accounts in the deve
   name?: string;
   /** The list of policy IDs that apply to the account. This will include both the project-level policy and the account-level policy, if one exists. */
   policies?: string[];
+  /** The ISO 8601 UTC timestamp at which the account was created. */
+  createdAt?: string;
+  /** The ISO 8601 UTC timestamp at which the account was last updated. */
+  updatedAt?: string;
 }
 
 /**
@@ -1190,6 +1399,11 @@ export type BadGatewayErrorResponse = Error;
  */
 export type ServiceUnavailableErrorResponse = Error;
 
+/**
+ * A payment method is required to complete this operation.
+ */
+export type PaymentMethodRequiredErrorResponse = Error;
+
 /**
  * Idempotency key conflict.
  */
@@ -1363,6 +1577,11 @@ Account names must be unique across all EVM accounts in the developer's CDP Proj
    * @pattern ^[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$
    */
   name?: string;
+  /**
+   * The ID of the account-level policy to apply to the account.
+   * @pattern ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$
+   */
+  accountPolicy?: string;
 };
 
 export type ExportEvmAccountBody = {