@coinbase/cdp-sdk 1.12.0 → 1.14.0

package/_types/policies/schema.d.ts

@@ -121,6 +121,25 @@ export declare const EvmNetworkCriterionSchema: z.ZodObject<{
     networks: ("base-sepolia" | "base")[];
 }>;
 export type EvmNetworkCriterion = z.infer<typeof EvmNetworkCriterionSchema>;
+/**
+ * Schema for EVM message criterions
+ */
+export declare const EvmMessageCriterionSchema: z.ZodObject<{
+    /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+    type: z.ZodLiteral<"evmMessage">;
+    /**
+     * A regular expression the message is matched against.
+     * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+     */
+    match: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "evmMessage";
+    match: string;
+}, {
+    type: "evmMessage";
+    match: string;
+}>;
+export type EvmMessageCriterion = z.infer<typeof EvmMessageCriterionSchema>;
 /**
  * Schema for Solana address criterions
  */
@@ -198,6 +217,29 @@ export declare const SignEvmTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
  * Can contain up to 10 individual criterion objects of ETH value or EVM address types.
  */
 export type SignEvmTransactionCriteria = z.infer<typeof SignEvmTransactionCriteriaSchema>;
+/**
+ * Schema for criteria used in SignEvmMessage operations
+ */
+export declare const SignEvmMessageCriteriaSchema: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+    type: z.ZodLiteral<"evmMessage">;
+    /**
+     * A regular expression the message is matched against.
+     * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+     */
+    match: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "evmMessage";
+    match: string;
+}, {
+    type: "evmMessage";
+    match: string;
+}>]>, "many">;
+/**
+ * Type representing a set of criteria for the signEvmMessage operation.
+ * Can contain up to 10 individual EVM message criterion objects.
+ */
+export type SignEvmMessageCriteria = z.infer<typeof SignEvmMessageCriteriaSchema>;
 /**
  * Schema for criteria used in SendEvmTransaction operations
  */
@@ -415,6 +457,79 @@ export declare const SignEvmTransactionRuleSchema: z.ZodObject<{
     })[];
 }>;
 export type SignEvmTransactionRule = z.infer<typeof SignEvmTransactionRuleSchema>;
+/**
+ * Type representing a 'signEvmHash' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmHashRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmHash".
+     */
+    operation: z.ZodLiteral<"signEvmHash">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}>;
+export type SignEvmHashRule = z.infer<typeof SignEvmHashRuleSchema>;
+/**
+ * Type representing a 'signEvmMessage' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export declare const SignEvmMessageRuleSchema: z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmMessage".
+     */
+    operation: z.ZodLiteral<"signEvmMessage">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+        type: z.ZodLiteral<"evmMessage">;
+        /**
+         * A regular expression the message is matched against.
+         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         */
+        match: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmMessage";
+        match: string;
+    }, {
+        type: "evmMessage";
+        match: string;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        type: "evmMessage";
+        match: string;
+    }[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        type: "evmMessage";
+        match: string;
+    }[];
+}>;
+export type SignEvmMessageRule = z.infer<typeof SignEvmMessageRuleSchema>;
 /**
  * Type representing a 'sendEvmTransaction' policy rule that can accept or reject specific operations
  * based on a set of criteria.
@@ -676,6 +791,67 @@ export declare const RuleSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObje
         operator: "in" | "not in";
         addresses: string[];
     })[];
+}>, z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmHash".
+     */
+    operation: z.ZodLiteral<"signEvmHash">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmHash";
+}>, z.ZodObject<{
+    /**
+     * Determines whether matching the rule will cause a request to be rejected or accepted.
+     * "accept" will allow the signing, "reject" will block it.
+     */
+    action: z.ZodEnum<["reject", "accept"]>;
+    /**
+     * The operation to which this rule applies.
+     * Must be "signEvmMessage".
+     */
+    operation: z.ZodLiteral<"signEvmMessage">;
+    /**
+     * The set of criteria that must be matched for this rule to apply.
+     * Must be compatible with the specified operation type.
+     */
+    criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+        type: z.ZodLiteral<"evmMessage">;
+        /**
+         * A regular expression the message is matched against.
+         * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+         */
+        match: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "evmMessage";
+        match: string;
+    }, {
+        type: "evmMessage";
+        match: string;
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        type: "evmMessage";
+        match: string;
+    }[];
+}, {
+    action: "reject" | "accept";
+    operation: "signEvmMessage";
+    criteria: {
+        type: "evmMessage";
+        match: string;
+    }[];
 }>, z.ZodObject<{
     /**
      * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -955,6 +1131,67 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: string[];
         })[];
+    }>, z.ZodObject<{
+        /**
+         * Determines whether matching the rule will cause a request to be rejected or accepted.
+         * "accept" will allow the signing, "reject" will block it.
+         */
+        action: z.ZodEnum<["reject", "accept"]>;
+        /**
+         * The operation to which this rule applies.
+         * Must be "signEvmHash".
+         */
+        operation: z.ZodLiteral<"signEvmHash">;
+    }, "strip", z.ZodTypeAny, {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    }, {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    }>, z.ZodObject<{
+        /**
+         * Determines whether matching the rule will cause a request to be rejected or accepted.
+         * "accept" will allow the signing, "reject" will block it.
+         */
+        action: z.ZodEnum<["reject", "accept"]>;
+        /**
+         * The operation to which this rule applies.
+         * Must be "signEvmMessage".
+         */
+        operation: z.ZodLiteral<"signEvmMessage">;
+        /**
+         * The set of criteria that must be matched for this rule to apply.
+         * Must be compatible with the specified operation type.
+         */
+        criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+            type: z.ZodLiteral<"evmMessage">;
+            /**
+             * A regular expression the message is matched against.
+             * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+             */
+            match: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmMessage";
+            match: string;
+        }, {
+            type: "evmMessage";
+            match: string;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
+    }, {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     }>, z.ZodObject<{
         /**
          * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -1135,6 +1372,16 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: `0x${string}`[];
         })[];
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";
@@ -1175,6 +1422,16 @@ export declare const CreatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: string[];
         })[];
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";
@@ -1298,6 +1555,67 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: string[];
         })[];
+    }>, z.ZodObject<{
+        /**
+         * Determines whether matching the rule will cause a request to be rejected or accepted.
+         * "accept" will allow the signing, "reject" will block it.
+         */
+        action: z.ZodEnum<["reject", "accept"]>;
+        /**
+         * The operation to which this rule applies.
+         * Must be "signEvmHash".
+         */
+        operation: z.ZodLiteral<"signEvmHash">;
+    }, "strip", z.ZodTypeAny, {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    }, {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    }>, z.ZodObject<{
+        /**
+         * Determines whether matching the rule will cause a request to be rejected or accepted.
+         * "accept" will allow the signing, "reject" will block it.
+         */
+        action: z.ZodEnum<["reject", "accept"]>;
+        /**
+         * The operation to which this rule applies.
+         * Must be "signEvmMessage".
+         */
+        operation: z.ZodLiteral<"signEvmMessage">;
+        /**
+         * The set of criteria that must be matched for this rule to apply.
+         * Must be compatible with the specified operation type.
+         */
+        criteria: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            /** The type of criterion, must be "evmMessage" for EVM message-based rules. */
+            type: z.ZodLiteral<"evmMessage">;
+            /**
+             * A regular expression the message is matched against.
+             * Accepts valid regular expression syntax described by [RE2](https://github.com/google/re2/wiki/Syntax).
+             */
+            match: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "evmMessage";
+            match: string;
+        }, {
+            type: "evmMessage";
+            match: string;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
+    }, {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     }>, z.ZodObject<{
         /**
          * Determines whether matching the rule will cause a request to be rejected or accepted.
@@ -1477,6 +1795,16 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: `0x${string}`[];
         })[];
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";
@@ -1516,6 +1844,16 @@ export declare const UpdatePolicyBodySchema: z.ZodObject<{
             operator: "in" | "not in";
             addresses: string[];
         })[];
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmHash";
+    } | {
+        action: "reject" | "accept";
+        operation: "signEvmMessage";
+        criteria: {
+            type: "evmMessage";
+            match: string;
+        }[];
     } | {
         action: "reject" | "accept";
         operation: "sendEvmTransaction";

package/_types/policies/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../policies/schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../policies/schema.ts"],"names":[],"mappings":"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"}

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.12.0";
+export declare const version = "1.14.0";
 //# sourceMappingURL=version.d.ts.map

package/accounts/evm/toEvmServerAccount.ts

@@ -1,4 +1,4 @@
-import { type TransactionSerializable, serializeTransaction } from "viem";
+import { type TransactionSerializable, getTypesForEIP712Domain, serializeTransaction } from "viem";
 
 import { FundOptions, fund } from "../../actions/evm/fund/fund.js";
 import { Quote } from "../../actions/evm/fund/Quote.js";
@@ -31,7 +31,6 @@ import type {
   TransactionResult,
 } from "../../actions/evm/sendTransaction.js";
 import type {
-  SendSwapTransactionOptions,
   SwapOptions,
   SwapResult,
   QuoteSwapOptions,
@@ -85,6 +84,11 @@ export function toEvmServerAccount(
     },
 
     async signTypedData(message: EIP712Message) {
+      if (!message.types.EIP712Domain) {
+        message.types.EIP712Domain = getTypesForEIP712Domain({
+          domain: message.domain,
+        });
+      }
       const result = await apiClient.signEvmTypedData(options.account.address, message);
       return result.signature as Hex;
     },
@@ -140,7 +144,8 @@ export function toEvmServerAccount(
       return sendSwapTransaction(apiClient, {
         ...options,
         address: this.address,
-      } as SendSwapTransactionOptions);
+        taker: this.address, // Always use account's address as taker
+      });
     },
     name: options.account.name,
     type: "evm-server",

package/actions/evm/listTokenBalances.ts

@@ -32,7 +32,7 @@ export interface EvmTokenAmount {
   /** The amount of the token in the smallest indivisible unit of the token. */
   amount: bigint;
   /** The number of decimals in the token. */
-  decimals: bigint;
+  decimals: number;
 }
 /**
  * An EVM token balance.
@@ -95,7 +95,7 @@ export async function listTokenBalances(
       },
       amount: {
         amount: BigInt(balance.amount.amount),
-        decimals: BigInt(balance.amount.decimals),
+        decimals: balance.amount.decimals,
       },
     };
   });

package/actions/evm/swap/types.ts

@@ -83,10 +83,53 @@ export type QuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker">;
  */
 export type QuoteSwapResult = CreateSwapQuoteResult | SwapUnavailableResult;
 
+/**
+ * Options when providing an already created swap quote (account-level).
+ */
+interface AccountQuoteBasedSwapOptions {
+  /**
+   * The swap quote returned by the createSwapQuote method.
+   */
+  swapQuote: CreateSwapQuoteResult;
+
+  /**
+   * Optional idempotency key for the request.
+   */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options when creating a swap quote inline (account-level).
+ */
+interface AccountInlineSwapOptions {
+  /**
+   * The network to execute the swap on (e.g., "ethereum", "base").
+   */
+  network: SendEvmTransactionBodyNetwork;
+  /** The token to receive (destination token). */
+  toToken: Address;
+  /** The token to send (source token). */
+  fromToken: Address;
+  /** The amount to send in atomic units of the token. */
+  fromAmount: bigint;
+  /** The signer address (only needed if taker is a smart contract). */
+  signerAddress?: Address;
+  /** The gas price in Wei. */
+  gasPrice?: bigint;
+  /** The slippage tolerance in basis points (0-10000). */
+  slippageBps?: number;
+
+  /**
+   * Optional idempotency key for the request.
+   */
+  idempotencyKey?: string;
+}
+
 /**
  * Options for executing a token swap (account-level).
+ * The taker is automatically set to the account's address.
  */
-export type SwapOptions = Omit<SendSwapTransactionOptions, "address">;
+export type SwapOptions = AccountQuoteBasedSwapOptions | AccountInlineSwapOptions;
 
 /**
  * Result of executing a token swap (account-level).

package/analytics.ts

@@ -1,6 +1,6 @@
 import md5 from "md5";
 
-import { APIError } from "./openapi-client/errors.js";
+import { APIError, HttpErrorType } from "./openapi-client/errors.js";
 import { version } from "./version.js";
 
 /**
@@ -184,7 +184,7 @@ function shouldTrackError(error: unknown): boolean {
     return false;
   }
 
-  if (error instanceof APIError) {
+  if (error instanceof APIError && error.errorType !== HttpErrorType.unexpected_error) {
     return false;
   }
 

package/client/evm/evm.ts

@@ -32,6 +32,7 @@ import {
   GetSwapPriceResult,
   CreateSwapQuoteResult,
   SwapUnavailableResult,
+  GetOrCreateSmartAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
@@ -261,6 +262,7 @@ export class EvmClient implements EvmClientInterface {
     const openApiSmartAccount = await CdpOpenApiClient.createEvmSmartAccount(
       {
         owners: [options.owner.address],
+        name: options.name,
       },
       options.idempotencyKey,
     );
@@ -326,7 +328,10 @@ export class EvmClient implements EvmClientInterface {
    * Gets a CDP EVM smart account.
    *
    * @param {GetSmartAccountOptions} options - Parameters for getting the smart account.
-   * @param {string} options.address - The address of the smart account to get.
+   * Either `address` or `name` must be provided.
+   * If both are provided, lookup will be done by `address` and `name` will be ignored.
+   * @param {string} [options.address] - The address of the smart account to get.
+   * @param {string} [options.name] - The name of the smart account to get.
    * @param {Account} options.owner - The owner of the smart account.
    * You must pass the signing-capable owner of the smart account so that the returned smart account
    * can be functional.
@@ -342,7 +347,14 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async getSmartAccount(options: GetSmartAccountOptions): Promise<SmartAccount> {
-    const openApiSmartAccount = await CdpOpenApiClient.getEvmSmartAccount(options.address);
+    const openApiSmartAccount = await (async () => {
+      if (options.address) {
+        return CdpOpenApiClient.getEvmSmartAccount(options.address);
+      } else if (options.name) {
+        return CdpOpenApiClient.getEvmSmartAccountByName(options.name);
+      }
+      throw new Error("Either address or name must be provided");
+    })();
 
     const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
       smartAccount: openApiSmartAccount,
@@ -395,6 +407,51 @@ export class EvmClient implements EvmClientInterface {
     }
   }
 
+  /**
+   * Gets a CDP EVM smart account, or creates one if it doesn't exist.
+   * This method first attempts to retrieve an existing smart account with the given parameters.
+   * If no account exists, it creates a new one with the specified owner.
+   *
+   * @param {GetOrCreateSmartAccountOptions} options - Configuration options for getting or creating the smart account.
+   * @param {string} [options.name] - The name of the smart account to get or create.
+   * @param {Account} options.owner - The owner of the smart account.
+   *
+   * @returns {Promise<SmartAccount>} A promise that resolves to the retrieved or newly created smart account.
+   *
+   * @example
+   * ```ts
+   * const smartAccount = await cdp.evm.getOrCreateSmartAccount({
+   *   name: "MySmartAccount",
+   *   owner: account,
+   * });
+   * ```
+   */
+  async getOrCreateSmartAccount(options: GetOrCreateSmartAccountOptions): Promise<SmartAccount> {
+    try {
+      const account = await this.getSmartAccount(options);
+      return account;
+    } catch (error) {
+      // If it failed because the account doesn't exist, create it
+      const doesAccountNotExist = error instanceof APIError && error.statusCode === 404;
+      if (doesAccountNotExist) {
+        try {
+          const account = await this.createSmartAccount(options);
+          return account;
+        } catch (error) {
+          // If it failed because the account already exists, throw an error
+          const doesAccountAlreadyExist = error instanceof APIError && error.statusCode === 409;
+          if (doesAccountAlreadyExist) {
+            const account = await this.getSmartAccount(options);
+            return account;
+          }
+          throw error;
+        }
+      }
+
+      throw error;
+    }
+  }
+
   /**
    * Gets the price for a swap between two tokens on an EVM network.
    *