@coinbase/cdp-sdk 1.44.0 → 1.45.0

package/openapi-client/generated/evm-accounts/evm-accounts.ts

@@ -7,8 +7,11 @@
  */
 import type {
   CreateEvmAccountBody,
+  CreateEvmEip7702Delegation201,
+  CreateEvmEip7702DelegationBody,
   EIP712Message,
   EvmAccount,
+  EvmEip7702DelegationOperation,
   ExportEvmAccount200,
   ExportEvmAccountBody,
   ExportEvmAccountByName200,
@@ -228,6 +231,46 @@ export const signEvmTypedData = (
     options,
   );
 };
+/**
+ * Creates an EIP-7702 delegation for an EVM EOA account, upgrading it with smart account capabilities.
+
+This endpoint:
+- Retrieves delegation artifacts from onchain
+- Signs the EIP-7702 authorization for delegation
+- Assembles and submits a Type 4 transaction
+- Creates an associated smart account object
+
+The delegation allows the EVM EOA to be used as a smart account, which enables batched transactions and gas sponsorship via paymaster.
+ * @summary Create EIP-7702 delegation
+ */
+export const createEvmEip7702Delegation = (
+  address: string,
+  createEvmEip7702DelegationBody: CreateEvmEip7702DelegationBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<CreateEvmEip7702Delegation201>(
+    {
+      url: `/v2/evm/accounts/${address}/eip7702/delegation`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: createEvmEip7702DelegationBody,
+    },
+    options,
+  );
+};
+/**
+ * Returns the EIP-7702 delegation operation. Use the delegationOperationId returned by the Create EIP-7702 delegation endpoint to poll for operation completion.
+ * @summary Get EIP-7702 delegation operation for an operationID
+ */
+export const getEvmEip7702DelegationOperationById = (
+  delegationOperationId: string,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<EvmEip7702DelegationOperation>(
+    { url: `/v2/evm/eip7702/delegation-operations/${delegationOperationId}`, method: "GET" },
+    options,
+  );
+};
 /**
  * Import an existing EVM account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
  * @summary Import an EVM account
@@ -296,6 +339,12 @@ export type SignEvmTransactionResult = NonNullable<Awaited<ReturnType<typeof sig
 export type SignEvmHashResult = NonNullable<Awaited<ReturnType<typeof signEvmHash>>>;
 export type SignEvmMessageResult = NonNullable<Awaited<ReturnType<typeof signEvmMessage>>>;
 export type SignEvmTypedDataResult = NonNullable<Awaited<ReturnType<typeof signEvmTypedData>>>;
+export type CreateEvmEip7702DelegationResult = NonNullable<
+  Awaited<ReturnType<typeof createEvmEip7702Delegation>>
+>;
+export type GetEvmEip7702DelegationOperationByIdResult = NonNullable<
+  Awaited<ReturnType<typeof getEvmEip7702DelegationOperationById>>
+>;
 export type ImportEvmAccountResult = NonNullable<Awaited<ReturnType<typeof importEvmAccount>>>;
 export type ExportEvmAccountResult = NonNullable<Awaited<ReturnType<typeof exportEvmAccount>>>;
 export type ExportEvmAccountByNameResult = NonNullable<

package/openapi-client/generated/onramp/onramp.ts

@@ -11,6 +11,8 @@ import type {
   CreateOnrampSession201,
   CreateOnrampSessionBody,
   GetOnrampOrderById200,
+  GetOnrampUserLimits200,
+  GetOnrampUserLimitsBody,
 } from "../coinbaseDeveloperPlatformAPIs.schemas.js";
 
 import { cdpApiClient } from "../../cdpApiClient.js";
@@ -87,8 +89,30 @@ export const createOnrampSession = (
     options,
   );
 };
+/**
+ * Returns the transaction limits for an onramp user based on their payment method and user identifier. Use this API to show users their remaining purchase capacity before initiating an onramp transaction.
+Currently supports `GUEST_CHECKOUT_APPLE_PAY` payment method with phone number identification. The phone number must have been previously verified via OTP.
+ * @summary Get onramp user limits
+ */
+export const getOnrampUserLimits = (
+  getOnrampUserLimitsBody: GetOnrampUserLimitsBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<GetOnrampUserLimits200>(
+    {
+      url: `/v2/onramp/limits`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: getOnrampUserLimitsBody,
+    },
+    options,
+  );
+};
 export type CreateOnrampOrderResult = NonNullable<Awaited<ReturnType<typeof createOnrampOrder>>>;
 export type GetOnrampOrderByIdResult = NonNullable<Awaited<ReturnType<typeof getOnrampOrderById>>>;
 export type CreateOnrampSessionResult = NonNullable<
   Awaited<ReturnType<typeof createOnrampSession>>
 >;
+export type GetOnrampUserLimitsResult = NonNullable<
+  Awaited<ReturnType<typeof getOnrampUserLimits>>
+>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.44.0",
+  "version": "1.45.0",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/policies/evmSchema.ts

@@ -508,6 +508,78 @@ export const SendUserOperationCriteriaSchema = z
  */
 export type SendUserOperationCriteria = z.infer<typeof SendUserOperationCriteriaSchema>;
 
+/**
+ * Schema for criteria used in SignEndUserEvmTransaction operations
+ */
+export const SignEndUserEvmTransactionCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      EthValueCriterionSchema,
+      EvmAddressCriterionSchema,
+      EvmDataCriterionSchema,
+      NetUSDChangeCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the signEndUserEvmTransaction operation.
+ */
+export type SignEndUserEvmTransactionCriteria = z.infer<
+  typeof SignEndUserEvmTransactionCriteriaSchema
+>;
+
+/**
+ * Schema for criteria used in SendEndUserEvmTransaction operations
+ */
+export const SendEndUserEvmTransactionCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      EthValueCriterionSchema,
+      EvmAddressCriterionSchema,
+      PrepareUserOperationEvmNetworkCriterionSchema,
+      EvmDataCriterionSchema,
+      NetUSDChangeCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the sendEndUserEvmTransaction operation.
+ */
+export type SendEndUserEvmTransactionCriteria = z.infer<
+  typeof SendEndUserEvmTransactionCriteriaSchema
+>;
+
+/**
+ * Schema for criteria used in SignEndUserEvmMessage operations
+ */
+export const SignEndUserEvmMessageCriteriaSchema = z
+  .array(z.discriminatedUnion("type", [EvmMessageCriterionSchema]))
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the signEndUserEvmMessage operation.
+ */
+export type SignEndUserEvmMessageCriteria = z.infer<typeof SignEndUserEvmMessageCriteriaSchema>;
+
+/**
+ * Schema for criteria used in SignEndUserEvmTypedData operations
+ */
+export const SignEndUserEvmTypedDataCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      SignEvmTypedDataFieldCriterionSchema,
+      SignEvmTypedDataVerifyingContractCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the signEndUserEvmTypedData operation.
+ */
+export type SignEndUserEvmTypedDataCriteria = z.infer<typeof SignEndUserEvmTypedDataCriteriaSchema>;
+
 /**
  * Enum for Evm Operation types
  */
@@ -691,3 +763,95 @@ export const SendUserOperationRuleSchema = z.object({
   criteria: SendUserOperationCriteriaSchema,
 });
 export type SendUserOperationRule = z.infer<typeof SendUserOperationRuleSchema>;
+
+/**
+ * Type representing a 'signEndUserEvmTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SignEndUserEvmTransactionRuleSchema = 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 "signEndUserEvmTransaction".
+   */
+  operation: z.literal("signEndUserEvmTransaction"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SignEndUserEvmTransactionCriteriaSchema,
+});
+export type SignEndUserEvmTransactionRule = z.infer<typeof SignEndUserEvmTransactionRuleSchema>;
+
+/**
+ * Type representing a 'sendEndUserEvmTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SendEndUserEvmTransactionRuleSchema = 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 "sendEndUserEvmTransaction".
+   */
+  operation: z.literal("sendEndUserEvmTransaction"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SendEndUserEvmTransactionCriteriaSchema,
+});
+export type SendEndUserEvmTransactionRule = z.infer<typeof SendEndUserEvmTransactionRuleSchema>;
+
+/**
+ * Type representing a 'signEndUserEvmMessage' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SignEndUserEvmMessageRuleSchema = z.object({
+  /**
+   * Determines whether matching the rule will cause a request to be rejected or accepted.
+   * "accept" will allow the signing, "reject" will block it.
+   */
+  action: ActionEnum,
+  /**
+   * The operation to which this rule applies.
+   * Must be "signEndUserEvmMessage".
+   */
+  operation: z.literal("signEndUserEvmMessage"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SignEndUserEvmMessageCriteriaSchema,
+});
+export type SignEndUserEvmMessageRule = z.infer<typeof SignEndUserEvmMessageRuleSchema>;
+
+/**
+ * Type representing a 'signEndUserEvmTypedData' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SignEndUserEvmTypedDataRuleSchema = z.object({
+  /**
+   * Determines whether matching the rule will cause a request to be rejected or accepted.
+   * "accept" will allow the signing, "reject" will block it.
+   */
+  action: ActionEnum,
+  /**
+   * The operation to which this rule applies.
+   * Must be "signEndUserEvmTypedData".
+   */
+  operation: z.literal("signEndUserEvmTypedData"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SignEndUserEvmTypedDataCriteriaSchema,
+});
+export type SignEndUserEvmTypedDataRule = z.infer<typeof SignEndUserEvmTypedDataRuleSchema>;

package/policies/solanaSchema.ts

@@ -378,6 +378,67 @@ export const SendSolTransactionCriteriaSchema = z
  */
 export type SendSolTransactionCriteria = z.infer<typeof SendSolTransactionCriteriaSchema>;
 
+/**
+ * Schema for criteria used in SignEndUserSolTransaction operations
+ */
+export const SignEndUserSolTransactionCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      SolAddressCriterionSchema,
+      SolValueCriterionSchema,
+      SplAddressCriterionSchema,
+      SplValueCriterionSchema,
+      MintAddressCriterionSchema,
+      SolDataCriterionSchema,
+      ProgramIdCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the signEndUserSolTransaction operation.
+ */
+export type SignEndUserSolTransactionCriteria = z.infer<
+  typeof SignEndUserSolTransactionCriteriaSchema
+>;
+
+/**
+ * Schema for criteria used in SendEndUserSolTransaction operations
+ */
+export const SendEndUserSolTransactionCriteriaSchema = z
+  .array(
+    z.discriminatedUnion("type", [
+      SolAddressCriterionSchema,
+      SolValueCriterionSchema,
+      SplAddressCriterionSchema,
+      SplValueCriterionSchema,
+      MintAddressCriterionSchema,
+      SolDataCriterionSchema,
+      ProgramIdCriterionSchema,
+      SolNetworkCriterionSchema,
+    ]),
+  )
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the sendEndUserSolTransaction operation.
+ */
+export type SendEndUserSolTransactionCriteria = z.infer<
+  typeof SendEndUserSolTransactionCriteriaSchema
+>;
+
+/**
+ * Schema for criteria used in SignEndUserSolMessage operations
+ */
+export const SignEndUserSolMessageCriteriaSchema = z
+  .array(SolMessageCriterionSchema)
+  .max(10)
+  .min(1);
+/**
+ * Type representing a set of criteria for the signEndUserSolMessage operation.
+ */
+export type SignEndUserSolMessageCriteria = z.infer<typeof SignEndUserSolMessageCriteriaSchema>;
+
 /**
  * Enum for Solana Operation types
  */
@@ -470,3 +531,72 @@ export const SignSolMessageRuleSchema = z.object({
   criteria: SignSolMessageCriteriaSchema,
 });
 export type SignSolMessageRule = z.infer<typeof SignSolMessageRuleSchema>;
+
+/**
+ * Type representing a 'signEndUserSolTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SignEndUserSolTransactionRuleSchema = 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 "signEndUserSolTransaction".
+   */
+  operation: z.literal("signEndUserSolTransaction"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SignEndUserSolTransactionCriteriaSchema,
+});
+export type SignEndUserSolTransactionRule = z.infer<typeof SignEndUserSolTransactionRuleSchema>;
+
+/**
+ * Type representing a 'sendEndUserSolTransaction' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SendEndUserSolTransactionRuleSchema = 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 "sendEndUserSolTransaction".
+   */
+  operation: z.literal("sendEndUserSolTransaction"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SendEndUserSolTransactionCriteriaSchema,
+});
+export type SendEndUserSolTransactionRule = z.infer<typeof SendEndUserSolTransactionRuleSchema>;
+
+/**
+ * Type representing a 'signEndUserSolMessage' policy rule that can accept or reject specific operations
+ * based on a set of criteria.
+ */
+export const SignEndUserSolMessageRuleSchema = z.object({
+  /**
+   * Determines whether matching the rule will cause a request to be rejected or accepted.
+   * "accept" will allow the message signing, "reject" will block it.
+   */
+  action: ActionEnum,
+  /**
+   * The operation to which this rule applies.
+   * Must be "signEndUserSolMessage".
+   */
+  operation: z.literal("signEndUserSolMessage"),
+  /**
+   * The set of criteria that must be matched for this rule to apply.
+   * Must be compatible with the specified operation type.
+   */
+  criteria: SignEndUserSolMessageCriteriaSchema,
+});
+export type SignEndUserSolMessageRule = z.infer<typeof SignEndUserSolMessageRuleSchema>;

package/policies/types.ts

@@ -8,11 +8,18 @@ import {
   SignEvmTransactionRuleSchema,
   SignEvmTypedDataRuleSchema,
   SendUserOperationRuleSchema,
+  SignEndUserEvmTransactionRuleSchema,
+  SendEndUserEvmTransactionRuleSchema,
+  SignEndUserEvmMessageRuleSchema,
+  SignEndUserEvmTypedDataRuleSchema,
 } from "./evmSchema.js";
 import {
   SendSolTransactionRuleSchema,
   SignSolTransactionRuleSchema,
   SignSolMessageRuleSchema,
+  SignEndUserSolTransactionRuleSchema,
+  SendEndUserSolTransactionRuleSchema,
+  SignEndUserSolMessageRuleSchema,
 } from "./solanaSchema.js";
 
 /**
@@ -57,6 +64,13 @@ export const RuleSchema = z.discriminatedUnion("operation", [
   SignSolMessageRuleSchema,
   PrepareUserOperationRuleSchema,
   SendUserOperationRuleSchema,
+  SignEndUserEvmTransactionRuleSchema,
+  SendEndUserEvmTransactionRuleSchema,
+  SignEndUserEvmMessageRuleSchema,
+  SignEndUserEvmTypedDataRuleSchema,
+  SignEndUserSolTransactionRuleSchema,
+  SendEndUserSolTransactionRuleSchema,
+  SignEndUserSolMessageRuleSchema,
 ]);
 
 /**

package/version.ts

@@ -1 +1 @@
-export const version = "1.44.0";
+export const version = "1.45.0";