@coinbase/agentkit 0.8.1 → 0.9.0

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

@@ -1,72 +1,8 @@
 import { z } from "zod";
-/**
- * Input schema for address reputation check.
- */
-export declare const AddressReputationSchema: z.ZodObject<{
-    address: z.ZodString;
-    network: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    address: string;
-    network: string;
-}, {
-    address: string;
-    network: string;
-}>;
-/**
- * Input schema for deploy contract action.
- */
-export declare const DeployContractSchema: z.ZodObject<{
-    solidityVersion: z.ZodEnum<[string, ...string[]]>;
-    solidityInputJson: z.ZodString;
-    contractName: z.ZodString;
-    constructorArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, "strip", z.ZodTypeAny, {
-    solidityVersion: string;
-    solidityInputJson: string;
-    contractName: string;
-    constructorArgs?: Record<string, any> | undefined;
-}, {
-    solidityVersion: string;
-    solidityInputJson: string;
-    contractName: string;
-    constructorArgs?: Record<string, any> | undefined;
-}>;
-/**
- * Input schema for deploy NFT action
- */
-export declare const DeployNftSchema: z.ZodObject<{
-    name: z.ZodString;
-    symbol: z.ZodString;
-    baseURI: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    symbol: string;
-    name: string;
-    baseURI: string;
-}, {
-    symbol: string;
-    name: string;
-    baseURI: string;
-}>;
-/**
- * Input schema for deploy token action.
- */
-export declare const DeployTokenSchema: z.ZodObject<{
-    name: z.ZodString;
-    symbol: z.ZodString;
-    totalSupply: z.ZodType<bigint, z.ZodTypeDef, bigint>;
-}, "strip", z.ZodTypeAny, {
-    symbol: string;
-    name: string;
-    totalSupply: bigint;
-}, {
-    symbol: string;
-    name: string;
-    totalSupply: bigint;
-}>;
 /**
  * Input schema for request faucet funds action.
  */
-export declare const RequestFaucetFundsSchema: z.ZodObject<{
+export declare const RequestFaucetFundsV2Schema: z.ZodObject<{
     assetId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     assetId?: string | undefined;
@@ -74,18 +10,21 @@ export declare const RequestFaucetFundsSchema: z.ZodObject<{
     assetId?: string | undefined;
 }>;
 /**
- * Input schema for trade action.
+ * Input schema for swap tokens action.
  */
-export declare const TradeSchema: z.ZodObject<{
-    amount: z.ZodType<bigint, z.ZodTypeDef, bigint>;
+export declare const SwapSchema: z.ZodObject<{
     fromAssetId: z.ZodString;
     toAssetId: z.ZodString;
+    amount: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    amount: bigint;
+    amount: string;
     fromAssetId: string;
     toAssetId: string;
+    network?: string | undefined;
 }, {
-    amount: bigint;
+    amount: string;
     fromAssetId: string;
     toAssetId: string;
+    network?: string | undefined;
 }>;

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

@@ -1,77 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSchema = exports.RequestFaucetFundsSchema = exports.DeployTokenSchema = exports.DeployNftSchema = exports.DeployContractSchema = exports.AddressReputationSchema = void 0;
+exports.SwapSchema = exports.RequestFaucetFundsV2Schema = void 0;
 const zod_1 = require("zod");
-const constants_1 = require("./constants");
-/**
- * Input schema for address reputation check.
- */
-exports.AddressReputationSchema = zod_1.z
-    .object({
-    address: zod_1.z
-        .string()
-        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
-        .describe("The Ethereum address to check"),
-    network: zod_1.z.string().describe("The network to check the address on"),
-})
-    .strip()
-    .describe("Input schema for address reputation check");
-/**
- * Input schema for deploy contract action.
- */
-exports.DeployContractSchema = zod_1.z
-    .object({
-    solidityVersion: zod_1.z
-        .enum(Object.keys(constants_1.SolidityVersions))
-        .describe("The solidity compiler version"),
-    solidityInputJson: zod_1.z.string().describe("The input json for the solidity compiler"),
-    contractName: zod_1.z.string().describe("The name of the contract class to be deployed"),
-    constructorArgs: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.any())
-        .describe("The constructor arguments for the contract")
-        .optional(),
-})
-    .strip()
-    .describe("Instructions for deploying an arbitrary contract");
-/**
- * Input schema for deploy NFT action
- */
-exports.DeployNftSchema = zod_1.z
-    .object({
-    name: zod_1.z.string().describe("The name of the NFT collection"),
-    symbol: zod_1.z.string().describe("The symbol of the NFT collection"),
-    baseURI: zod_1.z.string().describe("The base URI for the token metadata"),
-})
-    .strip()
-    .describe("Instructions for deploying an NFT collection");
-/**
- * Input schema for deploy token action.
- */
-exports.DeployTokenSchema = zod_1.z
-    .object({
-    name: zod_1.z.string().describe("The name of the token"),
-    symbol: zod_1.z.string().describe("The token symbol"),
-    totalSupply: zod_1.z.custom().describe("The total supply of tokens to mint"),
-})
-    .strip()
-    .describe("Instructions for deploying a token");
 /**
  * Input schema for request faucet funds action.
  */
-exports.RequestFaucetFundsSchema = zod_1.z
+exports.RequestFaucetFundsV2Schema = zod_1.z
     .object({
     assetId: zod_1.z.string().optional().describe("The optional asset ID to request from faucet"),
 })
     .strip()
     .describe("Instructions for requesting faucet funds");
 /**
- * Input schema for trade action.
+ * Input schema for swap tokens action.
  */
-exports.TradeSchema = zod_1.z
+exports.SwapSchema = zod_1.z
     .object({
-    amount: zod_1.z.custom().describe("The amount of the from asset to trade"),
-    fromAssetId: zod_1.z.string().describe("The from asset ID to trade"),
-    toAssetId: zod_1.z.string().describe("The to asset ID to receive from the trade"),
+    fromAssetId: zod_1.z.string().describe("The asset ID to swap from (e.g., 'eth', 'usdc')"),
+    toAssetId: zod_1.z.string().describe("The asset ID to swap to (e.g., 'eth', 'usdc')"),
+    amount: zod_1.z.string().describe("The amount to swap (in the from asset's units)"),
+    network: zod_1.z
+        .string()
+        .optional()
+        .describe("The network to perform the swap on (defaults to wallet's network)"),
 })
     .strip()
-    .describe("Instructions for trading assets");
+    .describe("Instructions for swapping tokens");

package/dist/action-providers/cdp-legacy/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./schemas";
+export * from "./legacyCdpApiActionProvider";
+export * from "./legacyCdpWalletActionProvider";

package/dist/action-providers/cdp-legacy/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./legacyCdpApiActionProvider"), exports);
+__exportStar(require("./legacyCdpWalletActionProvider"), exports);

package/dist/action-providers/cdp-legacy/legacyCdpApiActionProvider.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { LegacyCdpProviderConfig, WalletProvider } from "../../wallet-providers";
+import { AddressReputationSchema, RequestFaucetFundsSchema } from "./schemas";
+/**
+ * LegacyCdpApiActionProvider is a legacy action provider for CDP API using the old Coinbase SDK.
+ *
+ * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
+ *
+ * @deprecated Use CdpApiActionProvider instead
+ */
+export declare class LegacyCdpApiActionProvider extends ActionProvider<WalletProvider> {
+    /**
+     * Constructor for the LegacyCdpApiActionProvider class.
+     *
+     * @param config - The configuration options for the LegacyCdpApiActionProvider.
+     */
+    constructor(config?: LegacyCdpProviderConfig);
+    /**
+     * Check the reputation of an address.
+     *
+     * @param args - The input arguments for the action
+     * @returns A string containing reputation data or error message
+     */
+    addressReputation(args: z.infer<typeof AddressReputationSchema>): Promise<string>;
+    /**
+     * Requests test tokens from the faucet for the default address in the wallet.
+     *
+     * @param walletProvider - The wallet provider to request funds from.
+     * @param args - The input arguments for the action.
+     * @returns A confirmation message with transaction details.
+     */
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsSchema>): Promise<string>;
+    /**
+     * Checks if the Cdp action provider supports the given network.
+     *
+     * NOTE: Network scoping is done at the action implementation level
+     *
+     * @param _ - The network to check.
+     * @returns True if the Cdp action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+export declare const legacyCdpApiActionProvider: (config?: LegacyCdpProviderConfig) => LegacyCdpApiActionProvider;

package/dist/action-providers/cdp-legacy/legacyCdpApiActionProvider.js

@@ -0,0 +1,130 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCdpApiActionProvider = exports.LegacyCdpApiActionProvider = void 0;
+const package_json_1 = require("../../../package.json");
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const schemas_1 = require("./schemas");
+/**
+ * LegacyCdpApiActionProvider is a legacy action provider for CDP API using the old Coinbase SDK.
+ *
+ * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
+ *
+ * @deprecated Use CdpApiActionProvider instead
+ */
+class LegacyCdpApiActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the LegacyCdpApiActionProvider class.
+     *
+     * @param config - The configuration options for the LegacyCdpApiActionProvider.
+     */
+    constructor(config = {}) {
+        super("legacy_cdp_api", []);
+        /**
+         * Checks if the Cdp action provider supports the given network.
+         *
+         * NOTE: Network scoping is done at the action implementation level
+         *
+         * @param _ - The network to check.
+         * @returns True if the Cdp action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (_) => true;
+        if (config.apiKeyId && config.apiKeySecret) {
+            coinbase_sdk_1.Coinbase.configure({
+                apiKeyName: config.apiKeyId,
+                privateKey: config.apiKeySecret?.replace(/\\n/g, "\n"),
+                source: "agentkit",
+                sourceVersion: package_json_1.version,
+            });
+        }
+        else {
+            coinbase_sdk_1.Coinbase.configureFromJson({ source: "agentkit", sourceVersion: package_json_1.version });
+        }
+    }
+    /**
+     * Check the reputation of an address.
+     *
+     * @param args - The input arguments for the action
+     * @returns A string containing reputation data or error message
+     */
+    async addressReputation(args) {
+        if (args.network.includes("solana")) {
+            return "Address reputation is only supported on Ethereum networks.";
+        }
+        try {
+            const address = new coinbase_sdk_1.ExternalAddress(args.network, args.address);
+            const reputation = await address.reputation();
+            return reputation.toString();
+        }
+        catch (error) {
+            return `Error checking address reputation: ${error}`;
+        }
+    }
+    /**
+     * Requests test tokens from the faucet for the default address in the wallet.
+     *
+     * @param walletProvider - The wallet provider to request funds from.
+     * @param args - The input arguments for the action.
+     * @returns A confirmation message with transaction details.
+     */
+    async faucet(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        if (network.networkId !== "base-sepolia" && network.networkId !== "solana-devnet") {
+            return `Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.`;
+        }
+        try {
+            const address = new coinbase_sdk_1.ExternalAddress(walletProvider.getNetwork().networkId, walletProvider.getAddress());
+            const faucetTx = await address.faucet(args.assetId || undefined);
+            const result = await faucetTx.wait({ timeoutSeconds: 60 });
+            return `Received ${args.assetId || "ETH"} from the faucet. Transaction: ${result.getTransactionLink()}`;
+        }
+        catch (error) {
+            return `Error requesting faucet funds: ${error}`;
+        }
+    }
+}
+exports.LegacyCdpApiActionProvider = LegacyCdpApiActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "address_reputation",
+        description: `
+This tool checks the reputation of an address on a given network. It takes:
+
+- network: The network to check the address on (e.g. "base-mainnet")
+- address: The Ethereum address to check
+`,
+        schema: schemas_1.AddressReputationSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], LegacyCdpApiActionProvider.prototype, "addressReputation", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "request_faucet_funds",
+        description: `This tool will request test tokens from the faucet for the default address in the wallet. It takes the wallet and asset ID as input.
+Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.
+If fauceting on 'base-sepolia', user can only provide asset ID 'eth' or 'usdc', if no asset ID is provided, the faucet will default to 'eth'.
+If fauceting on 'solana-devnet', user can only provide asset ID 'sol', if no asset ID is provided, the faucet will default to 'sol'.
+You are not allowed to faucet with any other network or asset ID. If you are on another network, suggest that the user sends you some ETH
+from another wallet and provide the user with your wallet details.`,
+        schema: schemas_1.RequestFaucetFundsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], LegacyCdpApiActionProvider.prototype, "faucet", null);
+const legacyCdpApiActionProvider = (config = {}) => new LegacyCdpApiActionProvider(config);
+exports.legacyCdpApiActionProvider = legacyCdpApiActionProvider;

package/dist/action-providers/cdp-legacy/legacyCdpApiActionProvider.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const legacyCdpApiActionProvider_1 = require("./legacyCdpApiActionProvider");
+const schemas_1 = require("./schemas");
+jest.mock("@coinbase/coinbase-sdk");
+const { ExternalAddress } = jest.requireMock("@coinbase/coinbase-sdk");
+describe("CDP API Action Provider Input Schemas", () => {
+    describe("Address Reputation Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            const result = schemas_1.AddressReputationSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid address", () => {
+            const invalidInput = {
+                address: "invalid-address",
+                network: "base-mainnet",
+            };
+            const result = schemas_1.AddressReputationSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("Request Faucet Funds Schema", () => {
+        it("should successfully parse with optional assetId", () => {
+            const validInput = {
+                assetId: "eth",
+            };
+            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should successfully parse without assetId", () => {
+            const validInput = {};
+            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+    });
+});
+describe("CDP API Action Provider", () => {
+    let actionProvider;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mockExternalAddressInstance;
+    let mockWallet;
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new legacyCdpApiActionProvider_1.LegacyCdpApiActionProvider();
+        mockExternalAddressInstance = {
+            reputation: jest.fn(),
+            faucet: jest.fn(),
+        };
+        // Mock the constructor to return our mock instance
+        ExternalAddress.mockImplementation(() => mockExternalAddressInstance);
+        mockWallet = {
+            deployToken: jest.fn(),
+            deployContract: jest.fn(),
+            getAddress: jest.fn().mockReturnValue("0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83"),
+            getNetwork: jest.fn().mockReturnValue({ networkId: "base-sepolia" }),
+        };
+    });
+    describe("addressReputation", () => {
+        it("should successfully check address reputation", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            mockExternalAddressInstance.reputation.mockResolvedValue("Good reputation");
+            const result = await actionProvider.addressReputation(args);
+            expect(ExternalAddress).toHaveBeenCalledWith(args.network, args.address);
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalled();
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalledTimes(1);
+            expect(result).toBe("Good reputation");
+        });
+        it("should handle errors when checking reputation", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            const error = new Error("Reputation check failed");
+            mockExternalAddressInstance.reputation.mockRejectedValue(error);
+            const result = await actionProvider.addressReputation(args);
+            expect(ExternalAddress).toHaveBeenCalledWith(args.network, args.address);
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalled();
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalledTimes(1);
+            expect(result).toBe(`Error checking address reputation: ${error}`);
+        });
+        it("should return error if not on Ethereum network", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "solana-devnet",
+            };
+            const result = await actionProvider.addressReputation(args);
+            expect(result).toBe("Address reputation is only supported on Ethereum networks.");
+        });
+    });
+    describe("faucet", () => {
+        beforeEach(() => {
+            mockExternalAddressInstance.faucet.mockResolvedValue({
+                wait: jest.fn().mockResolvedValue({
+                    getTransactionLink: jest.fn().mockReturnValue("tx-link"),
+                }),
+            });
+        });
+        it("should successfully request faucet funds with assetId", async () => {
+            const args = {
+                assetId: "eth",
+            };
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(ExternalAddress).toHaveBeenCalledWith("base-sepolia", mockWallet.getAddress());
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledWith("eth");
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Received eth from the faucet");
+            expect(result).toContain("tx-link");
+        });
+        it("should successfully request faucet funds without assetId", async () => {
+            const args = {};
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(ExternalAddress).toHaveBeenCalledWith("base-sepolia", mockWallet.getAddress());
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledWith(undefined);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Received ETH from the faucet");
+        });
+        it("should handle faucet errors", async () => {
+            const args = {};
+            const error = new Error("Faucet request failed");
+            mockExternalAddressInstance.faucet.mockRejectedValue(error);
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(result).toBe(`Error requesting faucet funds: ${error}`);
+        });
+        it("should return error if not on base-sepolia or solana-devnet", async () => {
+            mockWallet.getNetwork.mockReturnValue({ networkId: "solana-mainnet", protocolFamily: "svm" });
+            const args = {};
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(result).toBe("Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.");
+        });
+    });
+});

package/dist/action-providers/{cdp/cdpWalletActionProvider.d.ts → cdp-legacy/legacyCdpWalletActionProvider.d.ts}

@@ -1,20 +1,20 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { CdpWalletProvider, CdpProviderConfig } from "../../wallet-providers";
+import { LegacyCdpWalletProvider, LegacyCdpProviderConfig } from "../../wallet-providers";
 import { DeployContractSchema, DeployNftSchema, DeployTokenSchema, TradeSchema } from "./schemas";
 /**
  * CdpWalletActionProvider is an action provider for Cdp.
  *
  * This provider is used for any action that requires a CDP Wallet.
  */
-export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletProvider> {
+export declare class LegacyCdpWalletActionProvider extends ActionProvider<LegacyCdpWalletProvider> {
     /**
      * Constructor for the CdpWalletActionProvider class.
      *
      * @param config - The configuration options for the CdpWalletActionProvider.
      */
-    constructor(config?: CdpProviderConfig);
+    constructor(config?: LegacyCdpProviderConfig);
     /**
      * Deploys a contract.
      *
@@ -22,7 +22,7 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
      * @param args - The input arguments for the action
      * @returns A message containing the deployed contract address and details
      */
-    deployContract(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployContractSchema>): Promise<string>;
+    deployContract(walletProvider: LegacyCdpWalletProvider, args: z.infer<typeof DeployContractSchema>): Promise<string>;
     /**
      * Deploys an NFT (ERC-721) token collection onchain from the wallet.
      *
@@ -30,7 +30,7 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
      * @param args - The input arguments for the action.
      * @returns A message containing the NFT token deployment details.
      */
-    deployNFT(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployNftSchema>): Promise<string>;
+    deployNFT(walletProvider: LegacyCdpWalletProvider, args: z.infer<typeof DeployNftSchema>): Promise<string>;
     /**
      * Deploys a token.
      *
@@ -38,7 +38,7 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
      * @param args - The arguments for the token deployment.
      * @returns The deployed token.
      */
-    deployToken(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployTokenSchema>): Promise<string>;
+    deployToken(walletProvider: LegacyCdpWalletProvider, args: z.infer<typeof DeployTokenSchema>): Promise<string>;
     /**
      * Trades a specified amount of a from asset to a to asset for the wallet.
      *
@@ -46,7 +46,7 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
      * @param args - The input arguments for the action.
      * @returns A message containing the trade details.
      */
-    trade(walletProvider: CdpWalletProvider, args: z.infer<typeof TradeSchema>): Promise<string>;
+    trade(walletProvider: LegacyCdpWalletProvider, args: z.infer<typeof TradeSchema>): Promise<string>;
     /**
      * Checks if the Cdp action provider supports the given network.
      *
@@ -55,4 +55,4 @@ export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletPro
      */
     supportsNetwork: (network: Network) => boolean;
 }
-export declare const cdpWalletActionProvider: (config?: CdpProviderConfig) => CdpWalletActionProvider;
+export declare const legacyCdpWalletActionProvider: (config?: LegacyCdpProviderConfig) => LegacyCdpWalletActionProvider;