@coinbase/cdp-sdk 1.8.0 → 1.10.0

package/openapi-client/generated/policy-engine/policy-engine.msw.ts

@@ -12,6 +12,7 @@ import { HttpResponse, delay, http } from "msw";
 import type {
   EthValueCriterion,
   EvmAddressCriterion,
+  EvmNetworkCriterion,
   ListPolicies200,
   Policy,
   SolAddressCriterion,
@@ -41,6 +42,17 @@ export const getListPoliciesResponseEvmAddressCriterionMock = (
   ...overrideResponse,
 });
 
+export const getListPoliciesResponseEvmNetworkCriterionMock = (
+  overrideResponse: Partial<EvmNetworkCriterion> = {},
+): EvmNetworkCriterion => ({
+  ...{
+    type: faker.helpers.arrayElement(["evmNetwork"] as const),
+    networks: faker.helpers.arrayElements(["base-sepolia", "base"] as const),
+    operator: faker.helpers.arrayElement(["in", "not in"] as const),
+  },
+  ...overrideResponse,
+});
+
 export const getListPoliciesResponseSolAddressCriterionMock = (
   overrideResponse: Partial<SolAddressCriterion> = {},
 ): SolAddressCriterion => ({
@@ -67,28 +79,48 @@ export const getListPoliciesResponseMock = (): ListPolicies200 => ({
         ]),
         scope: faker.helpers.arrayElement(["project", "account"] as const),
         rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
-          () => ({
-            action: faker.helpers.arrayElement(["reject", "accept"] as const),
-            operation: faker.helpers.arrayElement([
-              "signEvmTransaction",
-              "signSolTransaction",
-            ] as const),
-            criteria: faker.helpers.arrayElement([
-              Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
-                () =>
+          () =>
+            faker.helpers.arrayElement([
+              {
+                action: faker.helpers.arrayElement(["reject", "accept"] as const),
+                operation: faker.helpers.arrayElement(["signEvmTransaction"] as const),
+                criteria: Array.from(
+                  { length: faker.number.int({ min: 1, max: 10 }) },
+                  (_, i) => i + 1,
+                ).map(() =>
                   faker.helpers.arrayElement([
                     { ...getListPoliciesResponseEthValueCriterionMock() },
                     { ...getListPoliciesResponseEvmAddressCriterionMock() },
                   ]),
-              ),
-              Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
-                () =>
+                ),
+              },
+              {
+                action: faker.helpers.arrayElement(["reject", "accept"] as const),
+                operation: faker.helpers.arrayElement(["sendEvmTransaction"] as const),
+                criteria: Array.from(
+                  { length: faker.number.int({ min: 1, max: 10 }) },
+                  (_, i) => i + 1,
+                ).map(() =>
+                  faker.helpers.arrayElement([
+                    { ...getListPoliciesResponseEthValueCriterionMock() },
+                    { ...getListPoliciesResponseEvmAddressCriterionMock() },
+                    { ...getListPoliciesResponseEvmNetworkCriterionMock() },
+                  ]),
+                ),
+              },
+              {
+                action: faker.helpers.arrayElement(["reject", "accept"] as const),
+                operation: faker.helpers.arrayElement(["signSolTransaction"] as const),
+                criteria: Array.from(
+                  { length: faker.number.int({ min: 1, max: 10 }) },
+                  (_, i) => i + 1,
+                ).map(() =>
                   faker.helpers.arrayElement([
                     { ...getListPoliciesResponseSolAddressCriterionMock() },
                   ]),
-              ),
+                ),
+              },
             ]),
-          }),
         ),
         createdAt: faker.string.alpha(20),
         updatedAt: faker.string.alpha(20),
@@ -122,6 +154,17 @@ export const getCreatePolicyResponseEvmAddressCriterionMock = (
   ...overrideResponse,
 });
 
+export const getCreatePolicyResponseEvmNetworkCriterionMock = (
+  overrideResponse: Partial<EvmNetworkCriterion> = {},
+): EvmNetworkCriterion => ({
+  ...{
+    type: faker.helpers.arrayElement(["evmNetwork"] as const),
+    networks: faker.helpers.arrayElements(["base-sepolia", "base"] as const),
+    operator: faker.helpers.arrayElement(["in", "not in"] as const),
+  },
+  ...overrideResponse,
+});
+
 export const getCreatePolicyResponseSolAddressCriterionMock = (
   overrideResponse: Partial<SolAddressCriterion> = {},
 ): SolAddressCriterion => ({
@@ -144,21 +187,47 @@ export const getCreatePolicyResponseMock = (overrideResponse: Partial<Policy> =
     undefined,
   ]),
   scope: faker.helpers.arrayElement(["project", "account"] as const),
-  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-    action: faker.helpers.arrayElement(["reject", "accept"] as const),
-    operation: faker.helpers.arrayElement(["signEvmTransaction", "signSolTransaction"] as const),
-    criteria: faker.helpers.arrayElement([
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([
-          { ...getCreatePolicyResponseEthValueCriterionMock() },
-          { ...getCreatePolicyResponseEvmAddressCriterionMock() },
-        ]),
-      ),
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([{ ...getCreatePolicyResponseSolAddressCriterionMock() }]),
-      ),
+  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    faker.helpers.arrayElement([
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getCreatePolicyResponseEthValueCriterionMock() },
+            { ...getCreatePolicyResponseEvmAddressCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["sendEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getCreatePolicyResponseEthValueCriterionMock() },
+            { ...getCreatePolicyResponseEvmAddressCriterionMock() },
+            { ...getCreatePolicyResponseEvmNetworkCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signSolTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([{ ...getCreatePolicyResponseSolAddressCriterionMock() }]),
+        ),
+      },
     ]),
-  })),
+  ),
   createdAt: faker.string.alpha(20),
   updatedAt: faker.string.alpha(20),
   ...overrideResponse,
@@ -188,6 +257,17 @@ export const getGetPolicyByIdResponseEvmAddressCriterionMock = (
   ...overrideResponse,
 });
 
+export const getGetPolicyByIdResponseEvmNetworkCriterionMock = (
+  overrideResponse: Partial<EvmNetworkCriterion> = {},
+): EvmNetworkCriterion => ({
+  ...{
+    type: faker.helpers.arrayElement(["evmNetwork"] as const),
+    networks: faker.helpers.arrayElements(["base-sepolia", "base"] as const),
+    operator: faker.helpers.arrayElement(["in", "not in"] as const),
+  },
+  ...overrideResponse,
+});
+
 export const getGetPolicyByIdResponseSolAddressCriterionMock = (
   overrideResponse: Partial<SolAddressCriterion> = {},
 ): SolAddressCriterion => ({
@@ -210,21 +290,47 @@ export const getGetPolicyByIdResponseMock = (overrideResponse: Partial<Policy> =
     undefined,
   ]),
   scope: faker.helpers.arrayElement(["project", "account"] as const),
-  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-    action: faker.helpers.arrayElement(["reject", "accept"] as const),
-    operation: faker.helpers.arrayElement(["signEvmTransaction", "signSolTransaction"] as const),
-    criteria: faker.helpers.arrayElement([
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([
-          { ...getGetPolicyByIdResponseEthValueCriterionMock() },
-          { ...getGetPolicyByIdResponseEvmAddressCriterionMock() },
-        ]),
-      ),
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([{ ...getGetPolicyByIdResponseSolAddressCriterionMock() }]),
-      ),
+  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    faker.helpers.arrayElement([
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getGetPolicyByIdResponseEthValueCriterionMock() },
+            { ...getGetPolicyByIdResponseEvmAddressCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["sendEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getGetPolicyByIdResponseEthValueCriterionMock() },
+            { ...getGetPolicyByIdResponseEvmAddressCriterionMock() },
+            { ...getGetPolicyByIdResponseEvmNetworkCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signSolTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([{ ...getGetPolicyByIdResponseSolAddressCriterionMock() }]),
+        ),
+      },
     ]),
-  })),
+  ),
   createdAt: faker.string.alpha(20),
   updatedAt: faker.string.alpha(20),
   ...overrideResponse,
@@ -254,6 +360,17 @@ export const getUpdatePolicyResponseEvmAddressCriterionMock = (
   ...overrideResponse,
 });
 
+export const getUpdatePolicyResponseEvmNetworkCriterionMock = (
+  overrideResponse: Partial<EvmNetworkCriterion> = {},
+): EvmNetworkCriterion => ({
+  ...{
+    type: faker.helpers.arrayElement(["evmNetwork"] as const),
+    networks: faker.helpers.arrayElements(["base-sepolia", "base"] as const),
+    operator: faker.helpers.arrayElement(["in", "not in"] as const),
+  },
+  ...overrideResponse,
+});
+
 export const getUpdatePolicyResponseSolAddressCriterionMock = (
   overrideResponse: Partial<SolAddressCriterion> = {},
 ): SolAddressCriterion => ({
@@ -276,21 +393,47 @@ export const getUpdatePolicyResponseMock = (overrideResponse: Partial<Policy> =
     undefined,
   ]),
   scope: faker.helpers.arrayElement(["project", "account"] as const),
-  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
-    action: faker.helpers.arrayElement(["reject", "accept"] as const),
-    operation: faker.helpers.arrayElement(["signEvmTransaction", "signSolTransaction"] as const),
-    criteria: faker.helpers.arrayElement([
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([
-          { ...getUpdatePolicyResponseEthValueCriterionMock() },
-          { ...getUpdatePolicyResponseEvmAddressCriterionMock() },
-        ]),
-      ),
-      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
-        faker.helpers.arrayElement([{ ...getUpdatePolicyResponseSolAddressCriterionMock() }]),
-      ),
+  rules: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    faker.helpers.arrayElement([
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getUpdatePolicyResponseEthValueCriterionMock() },
+            { ...getUpdatePolicyResponseEvmAddressCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["sendEvmTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([
+            { ...getUpdatePolicyResponseEthValueCriterionMock() },
+            { ...getUpdatePolicyResponseEvmAddressCriterionMock() },
+            { ...getUpdatePolicyResponseEvmNetworkCriterionMock() },
+          ]),
+        ),
+      },
+      {
+        action: faker.helpers.arrayElement(["reject", "accept"] as const),
+        operation: faker.helpers.arrayElement(["signSolTransaction"] as const),
+        criteria: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() =>
+          faker.helpers.arrayElement([{ ...getUpdatePolicyResponseSolAddressCriterionMock() }]),
+        ),
+      },
     ]),
-  })),
+  ),
   createdAt: faker.string.alpha(20),
   updatedAt: faker.string.alpha(20),
   ...overrideResponse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
@@ -18,6 +18,7 @@
     }
   },
   "dependencies": {
+    "@solana/spl-token": "^0.4.13",
     "@solana/web3.js": "^1.98.1",
     "abitype": "1.0.6",
     "axios": "^1.8.2",

package/policies/schema.ts

@@ -21,6 +21,16 @@ export const EvmAddressOperatorEnum = z.enum(["in", "not in"]);
  */
 export type EvmAddressOperator = z.infer<typeof EvmAddressOperatorEnum>;
 
+/**
+ * Enum for EvmNetworkOperator values
+ */
+export const EvmNetworkOperatorEnum = z.enum(["in", "not in"]);
+/**
+ * Type representing the operators that can be used for EVM network comparisons.
+ * These operators determine how the transaction's network is evaluated against a list.
+ */
+export type EvmNetworkOperator = z.infer<typeof EvmNetworkOperatorEnum>;
+
 /**
  * Enum for SolAddressOperator values
  */
@@ -68,6 +78,35 @@ export const EvmAddressCriterionSchema = z.object({
 });
 export type EvmAddressCriterion = z.infer<typeof EvmAddressCriterionSchema>;
 
+/**
+ * Enum for EVM Network values
+ */
+export const EvmNetworkEnum = z.enum(["base", "base-sepolia"]);
+/**
+ * Type representing the valid networks used with CDP transaction API's.
+ */
+export type EvmNetwork = z.infer<typeof EvmNetworkEnum>;
+
+/**
+ * Schema for EVM network criterions
+ */
+export const EvmNetworkCriterionSchema = z.object({
+  /** The type of criterion, must be "evmAddress" for EVM address-based rules. */
+  type: z.literal("evmNetwork"),
+  /**
+   * Array of EVM network identifiers to compare against.
+   * Either "base" or "base-sepolia"
+   */
+  networks: z.array(EvmNetworkEnum),
+  /**
+   * The operator to use for evaluating transaction network.
+   * "in" checks if a network is in the provided list.
+   * "not in" checks if a network is not in the provided list.
+   */
+  operator: EvmNetworkOperatorEnum,
+});
+export type EvmNetworkCriterion = z.infer<typeof EvmNetworkCriterionSchema>;
+
 /**
  * Schema for Solana address criterions
  */
@@ -101,6 +140,26 @@ export const SignEvmTransactionCriteriaSchema = z
  */
 export type SignEvmTransactionCriteria = z.infer<typeof SignEvmTransactionCriteriaSchema>;
 
+/**
+ * Schema for criteria used in SendEvmTransaction operations
+ */
+export const SendEvmTransactionCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      EthValueCriterionSchema,
+      EvmAddressCriterionSchema,
+      EvmNetworkCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+
+/**
+ * Type representing a set of criteria for the sendEvmTransaction operation.
+ * Can contain up to 10 individual criterion objects of ETH value or EVM address types.
+ */
+export type SendEvmTransactionCriteria = z.infer<typeof SendEvmTransactionCriteriaSchema>;
+
 /**
  * Schema for criteria used in SignSolTransaction operations
  */
@@ -167,6 +226,29 @@ export const SignEvmTransactionRuleSchema = z.object({
 });
 export type SignEvmTransactionRule = z.infer<typeof SignEvmTransactionRuleSchema>;
 
+/**
+ * Type representing a 'sendEvmTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SendEvmTransactionRuleSchema = z.object({
+  /**
+   * Determines whether matching the rule will cause a request to be rejected or accepted.
+   * "accept" will allow the transaction, "reject" will block it.
+   */
+  action: ActionEnum,
+  /**
+   * The operation to which this rule applies.
+   * Must be "sendEvmTransaction".
+   */
+  operation: z.literal("sendEvmTransaction"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SendEvmTransactionCriteriaSchema,
+});
+export type SendEvmTransactionRule = z.infer<typeof SendEvmTransactionRuleSchema>;
+
 /**
  * Type representing a 'signSolTransaction' policy rule that can accept or reject specific operations
  * based on a set of criteria.
@@ -195,6 +277,7 @@ export type SignSolTransactionRule = z.infer<typeof SignSolTransactionRuleSchema
  */
 export const RuleSchema = z.discriminatedUnion("operation", [
   SignEvmTransactionRuleSchema,
+  SendEvmTransactionRuleSchema,
   SignSolTransactionRuleSchema,
 ]);
 

package/version.ts

@@ -1 +1 @@
-export const version = "1.8.0";
+export const version = "1.10.0";