@coinbase/agentkit 0.0.0-nightly-20250717210412 → 0.0.0-nightly-20250724210458

package/dist/action-providers/weth/wethActionProvider.test.js

@@ -21,6 +21,21 @@ describe("Wrap Eth Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Unwrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.UnwrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.UnwrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
 describe("Wrap Eth Action", () => {
     let mockWallet;
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -66,6 +81,51 @@ describe("Wrap Eth Action", () => {
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
 });
+describe("Unwrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to unwrap WETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Error unwrapping WETH: ${error}`);
+    });
+});
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
     it("should return true for base-mainnet", () => {

package/dist/action-providers/x402/schemas.d.ts

@@ -15,85 +15,49 @@ export declare const HttpRequestSchema: z.ZodObject<{
     body?: any;
     headers?: Record<string, string> | null | undefined;
 }>;
-export declare const RetryWithX402Schema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const RetryWithX402Schema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;
-    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    body: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
-}, {
-    paymentOption: z.ZodObject<{
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodAny>;
+    selectedPaymentOption: z.ZodObject<{
         scheme: z.ZodString;
         network: z.ZodString;
         maxAmountRequired: z.ZodString;
-        resource: z.ZodString;
-        description: z.ZodString;
-        mimeType: z.ZodString;
-        outputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-        payTo: z.ZodString;
-        maxTimeoutSeconds: z.ZodNumber;
         asset: z.ZodString;
-        extra: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
     }, "strip", z.ZodTypeAny, {
-        description: string;
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     }, {
-        description: string;
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     }>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null;
     url: string;
-    paymentOption: {
-        description: string;
+    selectedPaymentOption: {
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     };
     body?: any;
-    headers?: Record<string, string> | null | undefined;
+    headers?: Record<string, string> | undefined;
 }, {
     url: string;
-    paymentOption: {
-        description: string;
+    selectedPaymentOption: {
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     };
     method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null | undefined;
     body?: any;
-    headers?: Record<string, string> | null | undefined;
+    headers?: Record<string, string> | undefined;
 }>;
 export declare const DirectX402RequestSchema: z.ZodObject<{
     url: z.ZodString;

package/dist/action-providers/x402/schemas.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = void 0;
 const zod_1 = require("zod");
-// Base schema for HTTP requests
-const BaseHttpRequestSchema = zod_1.z.object({
-    url: zod_1.z.string().url().describe("The URL of the API endpoint (can be localhost for development)"),
+// Schema for initial HTTP request
+exports.HttpRequestSchema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
     method: zod_1.z
         .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
         .nullable()
@@ -15,29 +19,61 @@ const BaseHttpRequestSchema = zod_1.z.object({
         .optional()
         .nullable()
         .describe("Optional headers to include in the request"),
-    body: zod_1.z.any().optional().nullable().describe("Optional request body for POST/PUT/PATCH requests"),
-});
-// Schema for initial HTTP request
-exports.HttpRequestSchema = BaseHttpRequestSchema.strip().describe("Instructions for making a basic HTTP request");
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making a basic HTTP request");
 // Schema for retrying a failed request with x402 payment
-exports.RetryWithX402Schema = BaseHttpRequestSchema.extend({
-    paymentOption: zod_1.z
+exports.RetryWithX402Schema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
+    body: zod_1.z.any().optional().describe("Optional request body for POST/PUT/PATCH requests"),
+    selectedPaymentOption: zod_1.z
         .object({
         scheme: zod_1.z.string(),
         network: zod_1.z.string(),
         maxAmountRequired: zod_1.z.string(),
-        resource: zod_1.z.string(),
-        description: zod_1.z.string(),
-        mimeType: zod_1.z.string(),
-        outputSchema: zod_1.z.record(zod_1.z.any()),
-        payTo: zod_1.z.string(),
-        maxTimeoutSeconds: zod_1.z.number(),
         asset: zod_1.z.string(),
-        extra: zod_1.z.record(zod_1.z.any()).optional().nullable(),
     })
         .describe("The payment option to use for this request"),
 })
     .strip()
     .describe("Instructions for retrying a request with x402 payment after receiving a 402 response");
 // Schema for direct x402 payment request (with warning)
-exports.DirectX402RequestSchema = BaseHttpRequestSchema.strip().describe("Instructions for making an HTTP request with automatic x402 payment handling. WARNING: This bypasses user confirmation - only use when explicitly told to skip confirmation!");
+exports.DirectX402RequestSchema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z
+        .record(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe("Optional headers to include in the request"),
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making an HTTP request with automatic x402 payment handling. WARNING: This bypasses user confirmation - only use when explicitly told to skip confirmation!");

package/dist/action-providers/x402/x402ActionProvider.js

@@ -20,7 +20,6 @@ const schemas_1 = require("./schemas");
 const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402_axios_1 = require("x402-axios");
-const types_1 = require("x402/types");
 const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
@@ -65,13 +64,12 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     data: response.data,
                 }, null, 2);
             }
-            const paymentRequirements = response.data.accepts.map(accept => types_1.PaymentRequirementsSchema.parse(accept));
             return JSON.stringify({
                 status: "error_402_payment_required",
-                acceptablePaymentOptions: paymentRequirements,
+                acceptablePaymentOptions: response.data.accepts,
                 nextSteps: [
                     "Inform the user that the requested server replied with a 402 Payment Required response.",
-                    `The payment options are: ${paymentRequirements.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
+                    `The payment options are: ${response.data.accepts.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
                     "Ask the user if they want to retry the request with payment.",
                     `Use retry_http_request_with_x402 to retry the request with payment.`,
                 ],
@@ -90,20 +88,27 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async retryWithX402(walletProvider, args) {
         try {
-            // Validate the payment option matches the URL
-            if (args.paymentOption.resource !== args.url) {
-                return JSON.stringify({
-                    status: "error_invalid_payment_option",
-                    message: "The payment option resource does not match the request URL",
-                    details: {
-                        expected: args.url,
-                        received: args.paymentOption.resource,
-                    },
-                });
-            }
             // Make the request with payment handling
             const account = walletProvider.toSigner();
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account);
+            const paymentSelector = (accepts) => {
+                const { scheme, network, maxAmountRequired, asset } = args.selectedPaymentOption;
+                let paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
+                    accept.network === network &&
+                    accept.maxAmountRequired <= maxAmountRequired &&
+                    accept.asset === asset);
+                if (paymentRequirements) {
+                    return paymentRequirements;
+                }
+                paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
+                    accept.network === network &&
+                    accept.maxAmountRequired <= maxAmountRequired &&
+                    accept.asset === asset);
+                if (paymentRequirements) {
+                    return paymentRequirements;
+                }
+                return accepts[0];
+            };
+            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account, paymentSelector);
             const response = await api.request({
                 url: args.url,
                 method: args.method ?? "GET",
@@ -122,9 +127,9 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     url: args.url,
                     method: args.method,
                     paymentUsed: {
-                        network: args.paymentOption.network,
-                        asset: args.paymentOption.asset,
-                        amount: args.paymentOption.maxAmountRequired,
+                        network: args.selectedPaymentOption.network,
+                        asset: args.selectedPaymentOption.asset,
+                        amount: args.selectedPaymentOption.maxAmountRequired,
                     },
                     paymentProof: paymentProof
                         ? {

package/dist/action-providers/x402/x402ActionProvider.test.js

@@ -225,20 +225,15 @@ describe("X402ActionProvider", () => {
             const result = await provider.retryWithX402(mockWalletProvider, {
                 url: "https://www.x402.org/protected",
                 method: "GET",
-                paymentOption: {
+                selectedPaymentOption: {
                     scheme: "exact",
                     network: "base-sepolia",
                     maxAmountRequired: "10000",
-                    resource: "https://www.x402.org/protected",
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
                     asset: "0x456",
-                    outputSchema: {},
                 },
             });
-            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer");
+            // Update expectation to accept the payment selector function
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer", expect.any(Function));
             const parsedResult = JSON.parse(result);
             expect(parsedResult.status).toBe("success");
             expect(parsedResult.details.paymentProof).toEqual({
@@ -247,26 +242,6 @@ describe("X402ActionProvider", () => {
                 payer: MOCK_PAYMENT_RESPONSE.payer,
             });
         });
-        it("should reject if payment option resource doesn't match URL", async () => {
-            const result = await provider.retryWithX402(mockWalletProvider, {
-                url: "https://www.x402.org/protected",
-                method: "GET",
-                paymentOption: {
-                    scheme: "exact",
-                    network: "base-sepolia",
-                    maxAmountRequired: "10000",
-                    resource: "https://different.url/protected", // Mismatched URL
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
-                    asset: "0x456",
-                    outputSchema: {},
-                },
-            });
-            const parsedResult = JSON.parse(result);
-            expect(parsedResult.status).toBe("error_invalid_payment_option");
-        });
         it("should handle network errors during payment", async () => {
             const error = new Error("Network error");
             error.isAxiosError = true;
@@ -275,17 +250,11 @@ describe("X402ActionProvider", () => {
             const result = await provider.retryWithX402(mockWalletProvider, {
                 url: "https://www.x402.org/protected",
                 method: "GET",
-                paymentOption: {
+                selectedPaymentOption: {
                     scheme: "exact",
                     network: "base-sepolia",
                     maxAmountRequired: "10000",
-                    resource: "https://www.x402.org/protected",
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
                     asset: "0x456",
-                    outputSchema: {},
                 },
             });
             const parsedResult = JSON.parse(result);

package/dist/wallet-providers/cdpEvmWalletProvider.d.ts

@@ -9,16 +9,16 @@ import { WalletProviderWithClient, CdpWalletProviderConfig } from "./cdpShared";
 export declare class CdpEvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
     /**
-     * Constructs a new CdpServerWalletProvider.
+     * Constructs a new CdpEvmWalletProvider.
      *
-     * @param config - The configuration options for the CdpServerWalletProvider.
+     * @param config - The configuration options for the CdpEvmWalletProvider.
      */
     private constructor();
     /**
-     * Configures a new CdpServerWalletProvider with a wallet.
+     * Configures a new CdpEvmWalletProvider with a wallet.
      *
      * @param config - Optional configuration parameters
-     * @returns A Promise that resolves to a new CdpServerWalletProvider instance
+     * @returns A Promise that resolves to a new CdpEvmWalletProvider instance
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
     static configureWithWallet(config?: CdpWalletProviderConfig): Promise<CdpEvmWalletProvider>;

package/dist/wallet-providers/cdpEvmWalletProvider.js

@@ -22,9 +22,9 @@ const evmWalletProvider_1 = require("./evmWalletProvider");
  */
 class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     /**
-     * Constructs a new CdpServerWalletProvider.
+     * Constructs a new CdpEvmWalletProvider.
      *
-     * @param config - The configuration options for the CdpServerWalletProvider.
+     * @param config - The configuration options for the CdpEvmWalletProvider.
      */
     constructor(config) {
         super();
@@ -39,10 +39,10 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         __classPrivateFieldSet(this, _CdpEvmWalletProvider_network, config.network, "f");
     }
     /**
-     * Configures a new CdpServerWalletProvider with a wallet.
+     * Configures a new CdpEvmWalletProvider with a wallet.
      *
      * @param config - Optional configuration parameters
-     * @returns A Promise that resolves to a new CdpServerWalletProvider instance
+     * @returns A Promise that resolves to a new CdpEvmWalletProvider instance
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
     static async configureWithWallet(config = {}) {

package/dist/wallet-providers/cdpShared.d.ts

@@ -1,5 +1,5 @@
 import { CdpClient, type EvmServerAccount } from "@coinbase/cdp-sdk";
-import type { Address, PrivateKeyAccount } from "viem";
+import type { Address, LocalAccount } from "viem";
 export interface CdpProviderConfig {
     /**
      * The CDP API Key ID.
@@ -35,7 +35,7 @@ export interface CdpSmartWalletProviderConfig extends CdpWalletProviderConfig {
     /**
      * The owner account of the smart wallet.
      */
-    owner?: EvmServerAccount | PrivateKeyAccount | Address;
+    owner?: EvmServerAccount | LocalAccount | Address;
     /**
      * The name of the smart wallet.
      */

package/dist/wallet-providers/cdpSmartWalletProvider.d.ts

@@ -35,10 +35,10 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
     /**
      * Signs a message using the owner account.
      *
-     * @param message - The message to sign.
+     * @param _message - The message to sign.
      * @returns The signed message.
      */
-    signMessage(message: string): Promise<Hex>;
+    signMessage(_message: string): Promise<Hex>;
     /**
      * Signs a typed data object using the owner account.
      *

package/dist/wallet-providers/cdpSmartWalletProvider.js

@@ -117,11 +117,11 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     /**
      * Signs a message using the owner account.
      *
-     * @param message - The message to sign.
+     * @param _message - The message to sign.
      * @returns The signed message.
      */
-    async signMessage(message) {
-        return __classPrivateFieldGet(this, _CdpSmartWalletProvider_ownerAccount, "f").signMessage({ message });
+    async signMessage(_message) {
+        throw new Error("Direct message signing not supported for smart wallets. Use sendTransaction instead.");
     }
     /**
      * Signs a typed data object using the owner account.
@@ -131,7 +131,14 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async signTypedData(typedData) {
-        return __classPrivateFieldGet(this, _CdpSmartWalletProvider_ownerAccount, "f").signTypedData(typedData);
+        const { domain, types, primaryType, message } = typedData;
+        return await __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").signTypedData({
+            domain,
+            types,
+            primaryType,
+            message,
+            network: __classPrivateFieldGet(this, _CdpSmartWalletProvider_instances, "m", _CdpSmartWalletProvider_getCdpSdkNetwork).call(this),
+        });
     }
     /**
      * Signs a transaction using the owner account.

package/dist/wallet-providers/cdpSmartWalletProvider.test.js

@@ -188,20 +188,40 @@ describe("CdpSmartWalletProvider", () => {
     // signing operation tests
     // =========================================================
     describe("signing operations", () => {
-        it("should sign messages using owner account", async () => {
-            const signature = await provider.signMessage("Hello, world!");
-            expect(mockOwnerAccount.signMessage).toHaveBeenCalledWith({ message: "Hello, world!" });
-            expect(signature).toBe(MOCK_SIGNATURE);
+        it("should throw error for direct message signing", async () => {
+            await expect(provider.signMessage("Hello, world!")).rejects.toThrow("Direct message signing not supported for smart wallets. Use sendTransaction instead.");
         });
-        it("should sign typed data using owner account", async () => {
+        it("should sign typed data using smart account", async () => {
             const typedData = {
-                domain: { name: "Example" },
-                types: { Test: [{ name: "test", type: "string" }] },
-                message: { test: "example" },
-                primaryType: "Test",
+                domain: {
+                    name: "Example",
+                    version: "1",
+                    chainId: 1,
+                    verifyingContract: "0x1234567890123456789012345678901234567890",
+                },
+                types: {
+                    Person: [
+                        { name: "name", type: "string" },
+                        { name: "wallet", type: "address" },
+                    ],
+                },
+                primaryType: "Person",
+                message: {
+                    name: "Bob",
+                    wallet: "0x1234567890123456789012345678901234567890",
+                },
             };
+            // Mock the smart account's signTypedData method
+            mockSmartAccount.signTypedData = jest.fn().mockResolvedValue(MOCK_SIGNATURE);
             const signature = await provider.signTypedData(typedData);
-            expect(mockOwnerAccount.signTypedData).toHaveBeenCalledWith(typedData);
+            // Verify the smart account was called with the correct parameters
+            expect(mockSmartAccount.signTypedData).toHaveBeenCalledWith({
+                domain: typedData.domain,
+                types: typedData.types,
+                primaryType: typedData.primaryType,
+                message: typedData.message,
+                network: MOCK_NETWORK.networkId,
+            });
             expect(signature).toBe(MOCK_SIGNATURE);
         });
         it("should throw error for direct transaction signing", async () => {
@@ -209,7 +229,7 @@ describe("CdpSmartWalletProvider", () => {
                 to: "0x1234567890123456789012345678901234567890",
                 value: BigInt(1000000000000000000),
             };
-            await expect(provider.signTransaction(tx)).rejects.toThrow("Direct transaction signing not supported for smart wallets");
+            await expect(provider.signTransaction(tx)).rejects.toThrow("Direct transaction signing not supported for smart wallets. Use sendTransaction instead.");
         });
     });
     // =========================================================

package/dist/wallet-providers/legacyCdpWalletProvider.d.ts

@@ -67,7 +67,7 @@ interface ConfigureLegacyCdpAgentkitWithWalletOptions extends LegacyCdpWalletPro
 /**
  * A legacy wallet provider that uses the old Coinbase SDK.
  *
- * @deprecated Use CdpServerWalletProvider or CdpSmartWalletProvider instead
+ * @deprecated Use CdpEvmWalletProvider or CdpSmartWalletProvider instead
  */
 export declare class LegacyCdpWalletProvider extends EvmWalletProvider {
     #private;

package/dist/wallet-providers/legacyCdpWalletProvider.js

@@ -23,7 +23,7 @@ const utils_1 = require("../utils");
 /**
  * A legacy wallet provider that uses the old Coinbase SDK.
  *
- * @deprecated Use CdpServerWalletProvider or CdpSmartWalletProvider instead
+ * @deprecated Use CdpEvmWalletProvider or CdpSmartWalletProvider instead
  */
 class LegacyCdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.0.0-nightly-20250717210412",
+  "version": "0.0.0-nightly-20250724210458",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
   "dependencies": {
     "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
-    "@coinbase/cdp-sdk": "^1.25.0",
+    "@coinbase/cdp-sdk": "^1.26.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/public-api": "2.18.5",

package/dist/action-providers/cdp/cdpEvmWalletActionProvider.d.ts

@@ -1,17 +0,0 @@
-import { ActionProvider } from "../actionProvider";
-import { CdpEvmWalletProvider } from "../../wallet-providers";
-import { Network } from "../../network";
-/**
- * CdpEvmWalletActionProvider is an action provider for Cdp.
- *
- * This provider is used for any action that requires a CDP Wallet.
- */
-declare class CdpEvmWalletActionProvider extends ActionProvider<CdpEvmWalletProvider> {
-    /**
-     * Constructor for the CdpEvmWalletActionProvider class.
-     */
-    constructor();
-    supportsNetwork: (network: Network) => boolean;
-}
-export declare const cdpEvmWalletActionProvider: () => CdpEvmWalletActionProvider;
-export {};

package/dist/action-providers/cdp/cdpEvmWalletActionProvider.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cdpEvmWalletActionProvider = void 0;
-const actionProvider_1 = require("../actionProvider");
-/**
- * CdpEvmWalletActionProvider is an action provider for Cdp.
- *
- * This provider is used for any action that requires a CDP Wallet.
- */
-class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
-    /**
-     * Constructor for the CdpEvmWalletActionProvider class.
-     */
-    constructor() {
-        super("cdp_evm", []);
-        this.supportsNetwork = (network) => network.protocolFamily === "evm";
-    }
-}
-const cdpEvmWalletActionProvider = () => new CdpEvmWalletActionProvider();
-exports.cdpEvmWalletActionProvider = cdpEvmWalletActionProvider;