@coinbase/agentkit 0.8.2 → 0.9.0

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

@@ -1,27 +1,19 @@
 import { z } from "zod";
-import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { CdpProviderConfig, WalletProvider } from "../../wallet-providers";
-import { AddressReputationSchema, RequestFaucetFundsSchema } from "./schemas";
+import { WalletProvider } from "../../wallet-providers";
+import { ActionProvider } from "../actionProvider";
+import { RequestFaucetFundsV2Schema, SwapSchema } from "./schemas";
 /**
  * CdpApiActionProvider is an action provider for CDP API.
  *
  * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
  */
 export declare class CdpApiActionProvider extends ActionProvider<WalletProvider> {
+    #private;
     /**
      * Constructor for the CdpApiActionProvider class.
-     *
-     * @param config - The configuration options for the CdpApiActionProvider.
-     */
-    constructor(config?: CdpProviderConfig);
-    /**
-     * 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>;
+    constructor();
     /**
      * Requests test tokens from the faucet for the default address in the wallet.
      *
@@ -29,7 +21,15 @@ export declare class CdpApiActionProvider extends ActionProvider<WalletProvider>
      * @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>;
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
+    /**
+     * Swaps tokens using the CDP client.
+     *
+     * @param walletProvider - The wallet provider to perform the swap with.
+     * @param args - The input arguments for the swap action.
+     * @returns A confirmation message with transaction details.
+     */
+    swap(walletProvider: WalletProvider, args: z.infer<typeof SwapSchema>): Promise<string>;
     /**
      * Checks if the Cdp action provider supports the given network.
      *
@@ -40,4 +40,4 @@ export declare class CdpApiActionProvider extends ActionProvider<WalletProvider>
      */
     supportsNetwork: (_: Network) => boolean;
 }
-export declare const cdpApiActionProvider: (config?: CdpProviderConfig) => CdpApiActionProvider;
+export declare const cdpApiActionProvider: () => CdpApiActionProvider;

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

@@ -8,14 +8,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CdpApiActionProvider_instances, _CdpApiActionProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiActionProvider = exports.CdpApiActionProvider = void 0;
-const package_json_1 = require("../../../package.json");
-const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
 const zod_1 = require("zod");
+const wallet_providers_1 = require("../../wallet-providers");
+const cdpShared_1 = require("../../wallet-providers/cdpShared");
 const actionDecorator_1 = require("../actionDecorator");
 const actionProvider_1 = require("../actionProvider");
-const wallet_providers_1 = require("../../wallet-providers");
 const schemas_1 = require("./schemas");
 /**
  * CdpApiActionProvider is an action provider for CDP API.
@@ -25,11 +30,10 @@ const schemas_1 = require("./schemas");
 class CdpApiActionProvider extends actionProvider_1.ActionProvider {
     /**
      * Constructor for the CdpApiActionProvider class.
-     *
-     * @param config - The configuration options for the CdpApiActionProvider.
      */
-    constructor(config = {}) {
+    constructor() {
         super("cdp_api", []);
+        _CdpApiActionProvider_instances.add(this);
         /**
          * Checks if the Cdp action provider supports the given network.
          *
@@ -39,90 +43,133 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
          * @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.
+     * Requests test tokens from the faucet for the default address in the wallet.
      *
-     * @param args - The input arguments for the action
-     * @returns A string containing reputation data or error message
+     * @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 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();
+    async faucet(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const networkId = network.networkId;
+        if ((0, cdpShared_1.isWalletProviderWithClient)(walletProvider)) {
+            if (network.protocolFamily === "evm") {
+                if (networkId !== "base-sepolia" && networkId !== "ethereum-sepolia") {
+                    throw new Error("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks.");
+                }
+                const faucetTx = await walletProvider.getClient().evm.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "eth"),
+                    network: networkId,
+                });
+                return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
+            }
+            else if (network.protocolFamily === "svm") {
+                if (networkId !== "solana-devnet") {
+                    throw new Error("Faucet is only supported on 'solana-devnet' solana networks.");
+                }
+                const faucetTx = await walletProvider.getClient().solana.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "sol"),
+                });
+                return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
+            }
+            else {
+                throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
+            }
         }
-        catch (error) {
-            return `Error checking address reputation: ${error}`;
+        else {
+            throw new Error("Wallet provider is not a CDP Wallet Provider.");
         }
     }
     /**
-     * Requests test tokens from the faucet for the default address in the wallet.
+     * Swaps tokens using the CDP client.
      *
-     * @param walletProvider - The wallet provider to request funds from.
-     * @param args - The input arguments for the action.
+     * @param walletProvider - The wallet provider to perform the swap with.
+     * @param args - The input arguments for the swap action.
      * @returns A confirmation message with transaction details.
      */
-    async faucet(walletProvider, args) {
+    async swap(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()}`;
+        const networkId = network.networkId;
+        if ((0, cdpShared_1.isWalletProviderWithClient)(walletProvider)) {
+            if (network.protocolFamily === "evm") {
+                try {
+                    const cdpNetwork = __classPrivateFieldGet(this, _CdpApiActionProvider_instances, "m", _CdpApiActionProvider_getCdpSdkNetwork).call(this, networkId);
+                    // Get the account for the wallet address
+                    const account = await walletProvider.getClient().evm.getAccount({
+                        address: walletProvider.getAddress(),
+                    });
+                    // Execute swap using the all-in-one pattern
+                    const swapResult = await account.swap({
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        network: cdpNetwork,
+                        from: args.fromAssetId,
+                        to: args.toAssetId,
+                        amount: args.amount,
+                        slippageBps: 100, // 1% slippage tolerance
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    });
+                    return `Successfully swapped ${args.amount} ${args.fromAssetId.toUpperCase()} to ${args.toAssetId.toUpperCase()}. Transaction hash: ${swapResult.transactionHash}`;
+                }
+                catch (error) {
+                    throw new Error(`Swap failed: ${error}`);
+                }
+            }
+            else {
+                throw new Error("Swap is currently only supported on EVM networks.");
+            }
         }
-        catch (error) {
-            return `Error requesting faucet funds: ${error}`;
+        else {
+            throw new Error("Wallet provider is not a CDP Wallet Provider.");
         }
     }
 }
 exports.CdpApiActionProvider = CdpApiActionProvider;
-__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)
-], CdpApiActionProvider.prototype, "addressReputation", null);
+_CdpApiActionProvider_instances = new WeakSet(), _CdpApiActionProvider_getCdpSdkNetwork = function _CdpApiActionProvider_getCdpSdkNetwork(networkId) {
+    switch (networkId) {
+        case "base-sepolia":
+            return "base-sepolia";
+        case "base-mainnet":
+            return "base";
+        case "ethereum-sepolia":
+            return "ethereum-sepolia";
+        case "ethereum-mainnet":
+            return "ethereum";
+        default:
+            return networkId; // For other networks, use as-is
+    }
+};
 __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'.
+If fauceting on 'base-sepolia', user can only provide asset ID 'eth', 'usdc', 'eurc' or 'cbbtc', if no asset ID is provided, the faucet will default to 'eth'.
+If fauceting on 'solana-devnet', user can only provide asset ID 'sol' or 'usdc', 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,
+        schema: schemas_1.RequestFaucetFundsV2Schema,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpApiActionProvider.prototype, "faucet", null);
-const cdpApiActionProvider = (config = {}) => new CdpApiActionProvider(config);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "swap",
+        description: `This tool swaps tokens using the CDP API. It takes the wallet, from asset ID, to asset ID, and amount as input.
+Swaps are currently supported on EVM networks like Base and Ethereum.
+Example usage:
+- Swap 0.1 ETH to USDC: { fromAssetId: "eth", toAssetId: "usdc", amount: "0.1" }
+- Swap 100 USDC to ETH: { fromAssetId: "usdc", toAssetId: "eth", amount: "100" }`,
+        schema: schemas_1.SwapSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpApiActionProvider.prototype, "swap", null);
+const cdpApiActionProvider = () => new CdpApiActionProvider();
 exports.cdpApiActionProvider = cdpApiActionProvider;

package/dist/action-providers/cdp/cdpApiActionProvider.test.js

@@ -2,145 +2,226 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const cdpApiActionProvider_1 = require("./cdpApiActionProvider");
 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);
+// Mock the CDP SDK
+jest.mock("@coinbase/cdp-sdk");
+describe("CDP API Action Provider", () => {
+    let actionProvider;
+    let mockWalletProvider;
+    let mockCdpClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        const mockAccount = {
+            swap: jest.fn(),
+        };
+        mockCdpClient = {
+            evm: {
+                requestFaucet: jest.fn(),
+                getAccount: jest.fn(),
+            },
+            solana: {
+                requestFaucet: jest.fn(),
+            },
+        };
+        // Set up default mock behavior
+        mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+        mockWalletProvider = {
+            getNetwork: jest.fn(),
+            getAddress: jest.fn(),
+            getClient: jest.fn(),
+        };
+        actionProvider = new cdpApiActionProvider_1.CdpApiActionProvider();
+    });
+    describe("initialization", () => {
+        it("should initialize with correct provider name", () => {
+            expect(actionProvider.name).toBe("cdp_api");
         });
-        it("should fail parsing invalid address", () => {
-            const invalidInput = {
-                address: "invalid-address",
-                network: "base-mainnet",
+        it("should support all networks", () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            expect(actionProvider.supportsNetwork(mockNetwork)).toBe(true);
+        });
+    });
+    describe("faucet", () => {
+        it("should request faucet funds on base-sepolia", async () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getAddress.mockReturnValue("0x123456789");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockCdpClient.evm.requestFaucet.mockResolvedValue({
+                transactionHash: "0xabcdef123456",
+            });
+            const result = await actionProvider.faucet(mockWalletProvider, { assetId: "eth" });
+            expect(mockCdpClient.evm.requestFaucet).toHaveBeenCalledWith({
+                address: "0x123456789",
+                token: "eth",
+                network: "base-sepolia",
+            });
+            expect(result).toContain("Received eth from the faucet");
+            expect(result).toContain("0xabcdef123456");
+        });
+        it("should request faucet funds on solana-devnet", async () => {
+            const mockNetwork = { protocolFamily: "svm", networkId: "solana-devnet" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getAddress.mockReturnValue("address123");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockCdpClient.solana.requestFaucet.mockResolvedValue({
+                signature: "signature123",
+            });
+            const result = await actionProvider.faucet(mockWalletProvider, { assetId: "sol" });
+            expect(mockCdpClient.solana.requestFaucet).toHaveBeenCalledWith({
+                address: "address123",
+                token: "sol",
+            });
+            expect(result).toContain("Received sol from the faucet");
+            expect(result).toContain("signature123");
+        });
+        it("should throw error for unsupported EVM network", async () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "ethereum-mainnet" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            await expect(actionProvider.faucet(mockWalletProvider, { assetId: "eth" })).rejects.toThrow("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks");
+        });
+        it("should throw error for unsupported Solana network", async () => {
+            const mockNetwork = { protocolFamily: "svm", networkId: "solana-mainnet" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            await expect(actionProvider.faucet(mockWalletProvider, { assetId: "sol" })).rejects.toThrow("Faucet is only supported on 'solana-devnet' solana networks");
+        });
+        it("should throw error for wallet provider without client", async () => {
+            const mockWalletWithoutClient = {
+                getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "base-sepolia" }),
             };
-            const result = schemas_1.AddressReputationSchema.safeParse(invalidInput);
-            expect(result.success).toBe(false);
+            await expect(actionProvider.faucet(mockWalletWithoutClient, { assetId: "eth" })).rejects.toThrow("Wallet provider is not a CDP Wallet Provider");
         });
     });
-    describe("Request Faucet Funds Schema", () => {
-        it("should successfully parse with optional assetId", () => {
-            const validInput = {
-                assetId: "eth",
+    describe("swap", () => {
+        it("should perform swap on base-sepolia", async () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getAddress.mockReturnValue("0x123456789");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            const mockAccount = { swap: jest.fn() };
+            mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+            mockAccount.swap.mockResolvedValue({
+                transactionHash: "0xswap123456",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, {
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+                amount: "0.1",
+            });
+            expect(mockCdpClient.evm.getAccount).toHaveBeenCalledWith({
+                address: "0x123456789",
+            });
+            expect(mockAccount.swap).toHaveBeenCalledWith({
+                network: "base-sepolia",
+                from: "eth",
+                to: "usdc",
+                amount: "0.1",
+                slippageBps: 100,
+            });
+            expect(result).toContain("Successfully swapped 0.1 ETH to USDC");
+            expect(result).toContain("0xswap123456");
+        });
+        it("should perform swap on base-mainnet", async () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "base-mainnet" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getAddress.mockReturnValue("0x123456789");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            const mockAccount = { swap: jest.fn() };
+            mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+            mockAccount.swap.mockResolvedValue({
+                transactionHash: "0xswap789",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, {
+                fromAssetId: "usdc",
+                toAssetId: "eth",
+                amount: "100",
+            });
+            expect(mockAccount.swap).toHaveBeenCalledWith({
+                network: "base", // Should convert base-mainnet to base
+                from: "usdc",
+                to: "eth",
+                amount: "100",
+                slippageBps: 100,
+            });
+            expect(result).toContain("Successfully swapped 100 USDC to ETH");
+        });
+        it("should throw error for non-EVM networks", async () => {
+            const mockNetwork = { protocolFamily: "svm", networkId: "solana-devnet" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            await expect(actionProvider.swap(mockWalletProvider, {
+                fromAssetId: "sol",
+                toAssetId: "usdc",
+                amount: "1",
+            })).rejects.toThrow("Swap is currently only supported on EVM networks");
+        });
+        it("should throw error for wallet provider without client", async () => {
+            const mockWalletWithoutClient = {
+                getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "base-sepolia" }),
             };
-            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            await expect(actionProvider.swap(mockWalletWithoutClient, {
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+                amount: "0.1",
+            })).rejects.toThrow("Wallet provider is not a CDP Wallet Provider");
+        });
+        it("should handle swap errors", async () => {
+            const mockNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            mockWalletProvider.getNetwork.mockReturnValue(mockNetwork);
+            mockWalletProvider.getAddress.mockReturnValue("0x123456789");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            const mockAccount = { swap: jest.fn() };
+            mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+            mockAccount.swap.mockRejectedValue(new Error("Insufficient liquidity"));
+            await expect(actionProvider.swap(mockWalletProvider, {
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+                amount: "1000",
+            })).rejects.toThrow("Swap failed: Error: Insufficient liquidity");
+        });
+    });
+    describe("RequestFaucetFundsV2Schema", () => {
+        it("should validate correct input", () => {
+            const validInput = { assetId: "eth" };
+            const result = schemas_1.RequestFaucetFundsV2Schema.safeParse(validInput);
             expect(result.success).toBe(true);
-            expect(result.data).toEqual(validInput);
         });
-        it("should successfully parse without assetId", () => {
+        it("should allow missing assetId", () => {
             const validInput = {};
-            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            const result = schemas_1.RequestFaucetFundsV2Schema.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 cdpApiActionProvider_1.CdpApiActionProvider();
-        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",
+    describe("SwapSchema", () => {
+        it("should validate correct swap input", () => {
+            const validInput = {
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+                amount: "0.1",
             };
-            const result = await actionProvider.addressReputation(args);
-            expect(result).toBe("Address reputation is only supported on Ethereum networks.");
+            const result = schemas_1.SwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
         });
-    });
-    describe("faucet", () => {
-        beforeEach(() => {
-            mockExternalAddressInstance.faucet.mockResolvedValue({
-                wait: jest.fn().mockResolvedValue({
-                    getTransactionLink: jest.fn().mockReturnValue("tx-link"),
-                }),
-            });
+        it("should validate swap input with network", () => {
+            const validInput = {
+                fromAssetId: "usdc",
+                toAssetId: "eth",
+                amount: "100",
+                network: "base-sepolia",
+            };
+            const result = schemas_1.SwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
         });
-        it("should successfully request faucet funds with assetId", async () => {
-            const args = {
-                assetId: "eth",
+        it("should fail validation when missing required fields", () => {
+            const invalidInput = {
+                fromAssetId: "eth",
+                // missing toAssetId and amount
             };
-            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'.");
+            const result = schemas_1.SwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
         });
     });
 });

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

@@ -1,3 +1,2 @@
 export * from "./schemas";
 export * from "./cdpApiActionProvider";
-export * from "./cdpWalletActionProvider";

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

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./cdpApiActionProvider"), exports);
-__exportStar(require("./cdpWalletActionProvider"), exports);