@coinbase/cdp-sdk 1.46.1 → 1.48.0

package/client/end-user/toEndUserAccount.ts

@@ -6,7 +6,6 @@ import type {
   AddEndUserEvmSmartAccountResult,
   AddEndUserSolanaAccountResult,
   AddEvmSmartAccountOptions,
-  SignEvmHashResult,
   SignEvmTransactionResult,
   SignEvmMessageResult,
   SignEvmTypedDataResult,
@@ -14,12 +13,10 @@ import type {
   SendEvmAssetResult,
   SendUserOperationResult,
   CreateEvmEip7702DelegationForEndUserResult,
-  SignSolanaHashResult,
   SignSolanaMessageResult,
   SignSolanaTransactionResult,
   SendSolanaTransactionResult,
   SendSolanaAssetResult,
-  AccountSignEvmHashOptions,
   AccountSignEvmTransactionOptions,
   AccountSignEvmMessageOptions,
   AccountSignEvmTypedDataOptions,
@@ -27,7 +24,6 @@ import type {
   AccountSendEvmAssetOptions,
   AccountSendUserOperationOptions,
   AccountCreateEvmEip7702DelegationOptions,
-  AccountSignSolanaHashOptions,
   AccountSignSolanaMessageOptions,
   AccountSignSolanaTransactionOptions,
   AccountSendSolanaTransactionOptions,
@@ -44,28 +40,8 @@ import type {
 export type ToEndUserAccountOptions = {
   /** The end user from the API response. */
   endUser: OpenAPIEndUser;
-  /** The CDP project ID. Required for delegation operations (signing, sending). */
-  projectId?: string;
 };
 
-/**
- * Returns the project ID or throws if not configured.
- * Used by delegation operations that require a project ID.
- *
- * @param projectId - The project ID to validate.
- * @returns The validated project ID.
- */
-function requireProjectId(projectId: string | undefined): string {
-  if (!projectId) {
-    throw new Error(
-      "Missing required project ID for delegation operation. " +
-        "Set the CDP_PROJECT_ID environment variable or pass projectId to the CdpClient constructor.",
-    );
-  }
-
-  return projectId;
-}
-
 /**
  * Resolves the first EVM EOA address for this end user, or throws if none exist and no override was provided.
  *
@@ -131,7 +107,7 @@ export function toEndUserAccount(
   apiClient: CdpOpenApiClientType,
   options: ToEndUserAccountOptions,
 ): EndUserAccount {
-  const { endUser, projectId } = options;
+  const { endUser } = options;
 
   const endUserAccount: EndUserAccount = {
     // Pass through all properties from the OpenAPI EndUser
@@ -169,59 +145,38 @@ export function toEndUserAccount(
 
     async revokeDelegation(): Promise<void> {
       Analytics.trackAction({ action: "end_user_revoke_delegation" });
-      await apiClient.revokeDelegationForEndUser(requireProjectId(projectId), endUser.userId, {});
+      await apiClient.revokeDelegationForEndUser(endUser.userId, {});
     },
 
     // ─── Delegated EVM Sign Methods ───
 
-    async signEvmHash(opts: AccountSignEvmHashOptions): Promise<SignEvmHashResult> {
-      Analytics.trackAction({ action: "end_user_sign_evm_hash" });
-      const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.signEvmHashWithEndUserAccount(requireProjectId(projectId), endUser.userId, {
-        hash: opts.hash,
-        address,
-      });
-    },
-
     async signEvmTransaction(
       opts: AccountSignEvmTransactionOptions,
     ): Promise<SignEvmTransactionResult> {
       Analytics.trackAction({ action: "end_user_sign_evm_transaction" });
       const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.signEvmTransactionWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          transaction: opts.transaction,
-        },
-      );
+      return apiClient.signEvmTransactionWithEndUserAccount(endUser.userId, {
+        address,
+        transaction: opts.transaction,
+      });
     },
 
     async signEvmMessage(opts: AccountSignEvmMessageOptions): Promise<SignEvmMessageResult> {
       Analytics.trackAction({ action: "end_user_sign_evm_message" });
       const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.signEvmMessageWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          message: opts.message,
-        },
-      );
+      return apiClient.signEvmMessageWithEndUserAccount(endUser.userId, {
+        address,
+        message: opts.message,
+      });
     },
 
     async signEvmTypedData(opts: AccountSignEvmTypedDataOptions): Promise<SignEvmTypedDataResult> {
       Analytics.trackAction({ action: "end_user_sign_evm_typed_data" });
       const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.signEvmTypedDataWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          typedData: opts.typedData,
-        },
-      );
+      return apiClient.signEvmTypedDataWithEndUserAccount(endUser.userId, {
+        address,
+        typedData: opts.typedData,
+      });
     },
 
     // ─── Delegated EVM Send Methods ───
@@ -231,34 +186,24 @@ export function toEndUserAccount(
     ): Promise<SendEvmTransactionResult> {
       Analytics.trackAction({ action: "end_user_send_evm_transaction" });
       const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.sendEvmTransactionWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          transaction: opts.transaction,
-          network: opts.network,
-        },
-      );
+      return apiClient.sendEvmTransactionWithEndUserAccount(endUser.userId, {
+        address,
+        transaction: opts.transaction,
+        network: opts.network,
+      });
     },
 
     async sendEvmAsset(opts: AccountSendEvmAssetOptions): Promise<SendEvmAssetResult> {
       Analytics.trackAction({ action: "end_user_send_evm_asset" });
       const address = resolveEvmAddress(endUser, opts.address);
       const asset = opts.asset ?? "usdc";
-      return apiClient.sendEvmAssetWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        address,
-        asset,
-        {
-          to: opts.to,
-          amount: opts.amount,
-          network: opts.network,
-          useCdpPaymaster: opts.useCdpPaymaster,
-          paymasterUrl: opts.paymasterUrl,
-        },
-      );
+      return apiClient.sendEvmAssetWithEndUserAccount(endUser.userId, address, asset, {
+        to: opts.to,
+        amount: opts.amount,
+        network: opts.network,
+        useCdpPaymaster: opts.useCdpPaymaster,
+        paymasterUrl: opts.paymasterUrl,
+      });
     },
 
     async sendUserOperation(
@@ -266,18 +211,13 @@ export function toEndUserAccount(
     ): Promise<SendUserOperationResult> {
       Analytics.trackAction({ action: "end_user_send_user_operation" });
       const address = resolveEvmSmartAccountAddress(endUser, opts.address);
-      return apiClient.sendUserOperationWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        address,
-        {
-          network: opts.network,
-          calls: opts.calls,
-          useCdpPaymaster: opts.useCdpPaymaster,
-          paymasterUrl: opts.paymasterUrl,
-          dataSuffix: opts.dataSuffix,
-        },
-      );
+      return apiClient.sendUserOperationWithEndUserAccount(endUser.userId, address, {
+        network: opts.network,
+        calls: opts.calls,
+        useCdpPaymaster: opts.useCdpPaymaster,
+        paymasterUrl: opts.paymasterUrl,
+        dataSuffix: opts.dataSuffix,
+      });
     },
 
     // ─── Delegated EVM EIP-7702 Delegation Method ───
@@ -287,45 +227,24 @@ export function toEndUserAccount(
     ): Promise<CreateEvmEip7702DelegationForEndUserResult> {
       Analytics.trackAction({ action: "end_user_create_evm_eip7702_delegation" });
       const address = resolveEvmAddress(endUser, opts.address);
-      return apiClient.createEvmEip7702DelegationWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          network: opts.network,
-          enableSpendPermissions: opts.enableSpendPermissions,
-        },
-      );
+      return apiClient.createEvmEip7702DelegationWithEndUserAccount(endUser.userId, {
+        address,
+        network: opts.network,
+        enableSpendPermissions: opts.enableSpendPermissions,
+      });
     },
 
     // ─── Delegated Solana Sign Methods ───
 
-    async signSolanaHash(opts: AccountSignSolanaHashOptions): Promise<SignSolanaHashResult> {
-      Analytics.trackAction({ action: "end_user_sign_solana_hash" });
-      const address = resolveSolanaAddress(endUser, opts.address);
-      return apiClient.signSolanaHashWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          hash: opts.hash,
-          address,
-        },
-      );
-    },
-
     async signSolanaMessage(
       opts: AccountSignSolanaMessageOptions,
     ): Promise<SignSolanaMessageResult> {
       Analytics.trackAction({ action: "end_user_sign_solana_message" });
       const address = resolveSolanaAddress(endUser, opts.address);
-      return apiClient.signSolanaMessageWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          message: opts.message,
-        },
-      );
+      return apiClient.signSolanaMessageWithEndUserAccount(endUser.userId, {
+        address,
+        message: opts.message,
+      });
     },
 
     async signSolanaTransaction(
@@ -333,14 +252,10 @@ export function toEndUserAccount(
     ): Promise<SignSolanaTransactionResult> {
       Analytics.trackAction({ action: "end_user_sign_solana_transaction" });
       const address = resolveSolanaAddress(endUser, opts.address);
-      return apiClient.signSolanaTransactionWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          transaction: opts.transaction,
-        },
-      );
+      return apiClient.signSolanaTransactionWithEndUserAccount(endUser.userId, {
+        address,
+        transaction: opts.transaction,
+      });
     },
 
     // ─── Delegated Solana Send Methods ───
@@ -350,33 +265,23 @@ export function toEndUserAccount(
     ): Promise<SendSolanaTransactionResult> {
       Analytics.trackAction({ action: "end_user_send_solana_transaction" });
       const address = resolveSolanaAddress(endUser, opts.address);
-      return apiClient.sendSolanaTransactionWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        {
-          address,
-          transaction: opts.transaction,
-          network: opts.network,
-        },
-      );
+      return apiClient.sendSolanaTransactionWithEndUserAccount(endUser.userId, {
+        address,
+        transaction: opts.transaction,
+        network: opts.network,
+      });
     },
 
     async sendSolanaAsset(opts: AccountSendSolanaAssetOptions): Promise<SendSolanaAssetResult> {
       Analytics.trackAction({ action: "end_user_send_solana_asset" });
       const address = resolveSolanaAddress(endUser, opts.address);
       const asset = opts.asset ?? "usdc";
-      return apiClient.sendSolanaAssetWithEndUserAccount(
-        requireProjectId(projectId),
-        endUser.userId,
-        address,
-        asset,
-        {
-          to: opts.to,
-          amount: opts.amount,
-          network: opts.network,
-          createRecipientAta: opts.createRecipientAta,
-        },
-      );
+      return apiClient.sendSolanaAssetWithEndUserAccount(endUser.userId, address, asset, {
+        to: opts.to,
+        amount: opts.amount,
+        network: opts.network,
+        createRecipientAta: opts.createRecipientAta,
+      });
     },
   };
 

package/client/solana/solana.ts

@@ -613,6 +613,7 @@ export class SolanaClient implements SolanaClientInterface {
    * @param {SendTransactionOptions} options - Parameters for sending the Solana transaction.
    * @param {string} options.network - The network to send the transaction to.
    * @param {string} options.transaction - The base64 encoded transaction to send.
+   * @param {boolean} [options.useCdpSponsor] - Whether CDP should sponsor the transaction fees.
    * @param {string} [options.idempotencyKey] - An idempotency key.
    *
    * @returns A promise that resolves to the transaction result.
@@ -622,6 +623,7 @@ export class SolanaClient implements SolanaClientInterface {
    * const signature = await cdp.solana.sendTransaction({
    *   network: "solana-devnet",
    *   transaction: "...",
+   *   useCdpSponsor: true,
    * });
    * ```
    */

package/client/solana/solana.types.ts

@@ -201,6 +201,8 @@ export interface SendTransactionOptions {
   network: SendSolanaTransactionBodyNetwork;
   /** The base64 encoded transaction to send. */
   transaction: string;
+  /** Whether CDP should sponsor the transaction fees. */
+  useCdpSponsor?: boolean;
   /** The idempotency key. */
   idempotencyKey?: string;
 }

package/client/webhooks/webhooks.ts

@@ -0,0 +1,61 @@
+/**
+ * @module Client
+ */
+
+import {
+  createWebhookSubscription,
+  CreateWebhookSubscriptionOptions,
+  CreateWebhookSubscriptionResult,
+} from "../../actions/webhooks/createWebhookSubscription.js";
+import { Analytics } from "../../analytics.js";
+import { CdpOpenApiClient } from "../../openapi-client/index.js";
+
+/**
+ * The namespace containing all webhook methods.
+ */
+export class WebhooksClient {
+  /**
+   * Creates a webhook subscription for wallet transaction events.
+   *
+   * @param {CreateWebhookSubscriptionOptions} options - Parameters for creating the webhook subscription.
+   * @param {string} [options.description] - A description of the webhook subscription.
+   * @param {WebhookEventType[]} options.eventTypes - The event types to subscribe to.
+   * @param {string} options.targetUrl - The URL to deliver webhook events to.
+   * @param {Record<string, string>} [options.targetHeaders] - Additional headers to include in webhook requests.
+   * @param {boolean} [options.isEnabled] - Whether the subscription is enabled. Defaults to `true`.
+   * @param {Record<string, string>} [options.metadata] - Additional metadata for the subscription.
+   *
+   * @returns A promise that resolves to the created webhook subscription.
+   *
+   * @example
+   * ```ts
+   * const subscription = await cdp.webhooks.createSubscription({
+   *   description: "Monitor wallet transactions",
+   *   eventTypes: [
+   *     "wallet.transaction.pending",
+   *     "wallet.transaction.confirmed",
+   *     "wallet.transaction.failed",
+   *   ],
+   *   targetUrl: "https://example.com/webhook",
+   *   isEnabled: true,
+   * });
+   *
+   * console.log("Subscription ID:", subscription.subscriptionId);
+   * console.log("Secret:", subscription.secret);
+   * ```
+   */
+  async createSubscription(
+    options: CreateWebhookSubscriptionOptions,
+  ): Promise<CreateWebhookSubscriptionResult> {
+    Analytics.trackAction({
+      action: "create_webhook_subscription",
+    });
+
+    try {
+      return await createWebhookSubscription(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "createWebhookSubscription");
+      throw error;
+    }
+  }
+}

package/index.ts

@@ -19,8 +19,6 @@ export type {
   ListEndUsersOptions,
   EndUserAccount,
   RevokeDelegationForEndUserOptions,
-  SignEvmHashOptions,
-  SignEvmHashResult,
   SignEvmTransactionOptions,
   SignEvmTransactionResult,
   SignEvmMessageOptions,
@@ -35,8 +33,6 @@ export type {
   SendUserOperationResult,
   CreateEvmEip7702DelegationOptions as CreateEvmEip7702DelegationForEndUserOptions,
   CreateEvmEip7702DelegationForEndUserResult,
-  SignSolanaHashOptions,
-  SignSolanaHashResult,
   SignSolanaMessageOptions,
   SignSolanaMessageResult,
   SignSolanaTransactionOptions,
@@ -51,4 +47,10 @@ export {
   SPEND_PERMISSION_MANAGER_ADDRESS as spendPermissionManagerAddress,
 } from "./spend-permissions/constants.js";
 
+export type {
+  CreateWebhookSubscriptionOptions,
+  CreateWebhookSubscriptionResult,
+  WebhookEventType,
+} from "./actions/webhooks/index.js";
+
 export { parseEther, parseUnits } from "viem";

package/openapi-client/cdpApiClient.ts

@@ -85,26 +85,6 @@ export const configure = (options: CdpOptions) => {
     expiresIn: options.expiresIn,
     debug: options.debugging,
   });
-
-  /*
-   * Delegated routing interceptor.
-   * Embedded Wallet API's are exposed to the developer for delegated signing
-   * via the /delegated path, which properly forwards the Authorization and
-   * X-Wallet-Auth headers from the edge.
-   *
-   * Registered after withAuth so it runs BEFORE the auth interceptor (LIFO order).
-   * This rewrites the URL first, then the auth interceptor computes JWT headers
-   * (Authorization and X-Wallet-Auth) against the rewritten URL path, ensuring
-   * the `uris` claim matches the actual request URL.
-   * The API gateway validates the JWT, strips the /delegated prefix, and forwards
-   * to the backend.
-   */
-  axiosInstance.interceptors.request.use(config => {
-    if (config.url && isDelegatedEndUserPath(config.url)) {
-      config.url = `/delegated${config.url}`;
-    }
-    return config;
-  });
 };
 
 /**
@@ -327,20 +307,6 @@ export const cdpApiClient = async <T>(
   }
 };
 
-/**
- * Checks if the given request URL is a delegated end-user operation that should
- * be routed through the /platform/delegated gateway prefix.
- *
- * These endpoints require both Authorization and X-Wallet-Auth headers to be
- * forwarded by the API gateway, which the /delegated prefix enables.
- *
- * @param url - The request URL (relative, without base path).
- * @returns True if the path should be routed through /platform/delegated.
- */
-const isDelegatedEndUserPath = (url: string): boolean => {
-  return /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/end-users\//.test(url);
-};
-
 /**
  * Validates the call to the cdpApiClient.
  *