@coinbase/cdp-sdk 1.8.0 → 1.9.0

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

@@ -333,6 +333,125 @@ export type SignEvmTransactionCriteriaItem = EthValueCriterion | EvmAddressCrite
  */
 export type SignEvmTransactionCriteria = SignEvmTransactionCriteriaItem[];
 
+/**
+ * Whether matching the rule will cause the request to be rejected or accepted.
+ */
+export type SignEvmTransactionRuleAction =
+  (typeof SignEvmTransactionRuleAction)[keyof typeof SignEvmTransactionRuleAction];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SignEvmTransactionRuleAction = {
+  reject: "reject",
+  accept: "accept",
+} as const;
+
+/**
+ * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
+ */
+export type SignEvmTransactionRuleOperation =
+  (typeof SignEvmTransactionRuleOperation)[keyof typeof SignEvmTransactionRuleOperation];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SignEvmTransactionRuleOperation = {
+  signEvmTransaction: "signEvmTransaction",
+} as const;
+
+export interface SignEvmTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SignEvmTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SignEvmTransactionRuleOperation;
+  criteria: SignEvmTransactionCriteria;
+}
+
+/**
+ * The type of criterion to use. This should be `evmNetwork`.
+ */
+export type EvmNetworkCriterionType =
+  (typeof EvmNetworkCriterionType)[keyof typeof EvmNetworkCriterionType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionType = {
+  evmNetwork: "evmNetwork",
+} as const;
+
+/**
+ * The network the transaction is for.
+ */
+export type EvmNetworkCriterionNetworksItem =
+  (typeof EvmNetworkCriterionNetworksItem)[keyof typeof EvmNetworkCriterionNetworksItem];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionNetworksItem = {
+  "base-sepolia": "base-sepolia",
+  base: "base",
+} as const;
+
+/**
+ * The operator to use for the comparison. The transaction's intended `network` will be on the left-hand side of the operator, and the `networks` field will be on the right-hand side.
+ */
+export type EvmNetworkCriterionOperator =
+  (typeof EvmNetworkCriterionOperator)[keyof typeof EvmNetworkCriterionOperator];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionOperator = {
+  in: "in",
+  not_in: "not in",
+} as const;
+
+/**
+ * A schema for specifying a criterion for the intended `network` of an EVM transaction.
+ */
+export interface EvmNetworkCriterion {
+  /** The type of criterion to use. This should be `evmNetwork`. */
+  type: EvmNetworkCriterionType;
+  /** A list of EVM network identifiers that the transaction's intended `network` should be compared to. */
+  networks: EvmNetworkCriterionNetworksItem[];
+  /** The operator to use for the comparison. The transaction's intended `network` will be on the left-hand side of the operator, and the `networks` field will be on the right-hand side. */
+  operator: EvmNetworkCriterionOperator;
+}
+
+export type SendEvmTransactionCriteriaItem =
+  | EthValueCriterion
+  | EvmAddressCriterion
+  | EvmNetworkCriterion;
+
+/**
+ * A schema for specifying the rejection criteria for the SignEvmTransaction operation.
+ */
+export type SendEvmTransactionCriteria = SendEvmTransactionCriteriaItem[];
+
+/**
+ * Whether matching the rule will cause the request to be rejected or accepted.
+ */
+export type SendEvmTransactionRuleAction =
+  (typeof SendEvmTransactionRuleAction)[keyof typeof SendEvmTransactionRuleAction];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SendEvmTransactionRuleAction = {
+  reject: "reject",
+  accept: "accept",
+} as const;
+
+/**
+ * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
+ */
+export type SendEvmTransactionRuleOperation =
+  (typeof SendEvmTransactionRuleOperation)[keyof typeof SendEvmTransactionRuleOperation];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SendEvmTransactionRuleOperation = {
+  sendEvmTransaction: "sendEvmTransaction",
+} as const;
+
+export interface SendEvmTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SendEvmTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SendEvmTransactionRuleOperation;
+  criteria: SendEvmTransactionCriteria;
+}
+
 /**
  * The type of criterion to use. This should be `solAddress`.
  */
@@ -376,10 +495,11 @@ export type SignSolTransactionCriteria = SolAddressCriterion[];
 /**
  * Whether matching the rule will cause the request to be rejected or accepted.
  */
-export type RuleAction = (typeof RuleAction)[keyof typeof RuleAction];
+export type SignSolTransactionRuleAction =
+  (typeof SignSolTransactionRuleAction)[keyof typeof SignSolTransactionRuleAction];
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-export const RuleAction = {
+export const SignSolTransactionRuleAction = {
   reject: "reject",
   accept: "accept",
 } as const;
@@ -387,30 +507,26 @@ export const RuleAction = {
 /**
  * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
  */
-export type RuleOperation = (typeof RuleOperation)[keyof typeof RuleOperation];
+export type SignSolTransactionRuleOperation =
+  (typeof SignSolTransactionRuleOperation)[keyof typeof SignSolTransactionRuleOperation];
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-export const RuleOperation = {
-  signEvmTransaction: "signEvmTransaction",
+export const SignSolTransactionRuleOperation = {
   signSolTransaction: "signSolTransaction",
 } as const;
 
-/**
- * The set of criteria for the rule. There is a limit of 10 criteria per rule.
- */
-export type RuleCriteria = SignEvmTransactionCriteria | SignSolTransactionCriteria;
+export interface SignSolTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SignSolTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SignSolTransactionRuleOperation;
+  criteria: SignSolTransactionCriteria;
+}
 
 /**
  * A rule that limits the behavior of an account.
  */
-export interface Rule {
-  /** Whether matching the rule will cause the request to be rejected or accepted. */
-  action: RuleAction;
-  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
-  operation: RuleOperation;
-  /** The set of criteria for the rule. There is a limit of 10 criteria per rule. */
-  criteria: RuleCriteria;
-}
+export type Rule = SignEvmTransactionRule | SendEvmTransactionRule | SignSolTransactionRule;
 
 /**
  * The scope of the policy. Only one project-level policy can exist at any time.
@@ -430,7 +546,7 @@ export interface Policy {
    */
   id: string;
   /**
-   * An optional human-readable description of the policy. 
+   * An optional human-readable description of the policy.
 Policy descriptions can consist of alphanumeric characters, spaces, commas, and periods, and be 50 characters or less.
    * @pattern ^[A-Za-z0-9 ,.]{1,50}$
    */

package/openapi-client/generated/index.msw.ts

@@ -1,6 +1,6 @@
-export * from "./evm-accounts/evm-accounts.msw.js";
-export * from "./evm-token-balances/evm-token-balances.msw.js";
-export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
 export * from "./faucets/faucets.msw.js";
 export * from "./policy-engine/policy-engine.msw.js";
+export * from "./evm-accounts/evm-accounts.msw.js";
+export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
+export * from "./evm-token-balances/evm-token-balances.msw.js";
 export * from "./solana-accounts/solana-accounts.msw.js";

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.9.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.9.0";