@coinbase/agentkit 0.10.0 → 0.10.1

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

@@ -8,21 +8,18 @@ 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 _CdpEvmWalletActionProvider_instances, _CdpEvmWalletActionProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpEvmWalletActionProvider = exports.CdpEvmWalletActionProvider = void 0;
 const zod_1 = require("zod");
 const wallet_providers_1 = require("../../wallet-providers");
 const cdpShared_1 = require("../../wallet-providers/cdpShared");
+const cdpEvmWalletProvider_1 = require("../../wallet-providers/cdpEvmWalletProvider");
 const actionDecorator_1 = require("../actionDecorator");
 const actionProvider_1 = require("../actionProvider");
 const schemas_1 = require("./schemas");
 const spendPermissionUtils_1 = require("./spendPermissionUtils");
+const swapUtils_1 = require("./swapUtils");
+const viem_1 = require("viem");
 /**
  * CdpEvmWalletActionProvider is an action provider for CDP EVM Wallet specific actions.
  *
@@ -35,7 +32,6 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     constructor() {
         super("cdp_evm_wallet", []);
-        _CdpEvmWalletActionProvider_instances.add(this);
         /**
          * Checks if the EVM wallet action provider supports the given network.
          *
@@ -77,7 +73,7 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     async useSpendPermission(walletProvider, args) {
         const network = walletProvider.getNetwork();
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, network.networkId);
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
         if ((0, cdpShared_1.isWalletProviderWithClient)(walletProvider)) {
             if (network.protocolFamily === "evm") {
                 try {
@@ -105,22 +101,183 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
             return "Wallet provider is not a CDP Wallet Provider.";
         }
     }
+    /**
+     * Gets a price quote for swapping tokens using the CDP Swap API.
+     *
+     * @param walletProvider - The EVM wallet provider to get the quote for.
+     * @param args - The input arguments for the swap price action.
+     * @returns A JSON string with detailed swap price quote information.
+     */
+    async getSwapPrice(walletProvider, args) {
+        // Get CDP SDK network
+        const network = walletProvider.getNetwork();
+        const networkId = network.networkId;
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
+        // Check if the network is supported
+        if (networkId !== "base-mainnet" && networkId !== "ethereum-mainnet")
+            return JSON.stringify({
+                success: false,
+                error: "CDP Swap API is currently only supported on 'base-mainnet' or 'ethereum-mainnet'.",
+            });
+        try {
+            // Get token details
+            const { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName } = await (0, swapUtils_1.getTokenDetails)(walletProvider, args.fromToken, args.toToken);
+            // Get swap price quote
+            const swapPrice = (await walletProvider.getClient().evm.getSwapPrice({
+                fromToken: args.fromToken,
+                toToken: args.toToken,
+                fromAmount: (0, viem_1.parseUnits)(args.fromAmount, fromTokenDecimals),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                network: cdpNetwork,
+                taker: walletProvider.getAddress(),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }));
+            const formattedResponse = {
+                success: true,
+                fromAmount: args.fromAmount,
+                fromTokenName: fromTokenName,
+                fromToken: args.fromToken,
+                toAmount: (0, viem_1.formatUnits)(swapPrice.toAmount, toTokenDecimals),
+                minToAmount: (0, viem_1.formatUnits)(swapPrice.minToAmount, toTokenDecimals),
+                toTokenName: toTokenName,
+                toToken: args.toToken,
+                slippageBps: args.slippageBps,
+                liquidityAvailable: swapPrice.liquidityAvailable,
+                balanceEnough: swapPrice.issues.balance === undefined,
+                priceOfBuyTokenInSellToken: (Number(args.fromAmount) / Number((0, viem_1.formatUnits)(swapPrice.toAmount, toTokenDecimals))).toString(),
+                priceOfSellTokenInBuyToken: (Number((0, viem_1.formatUnits)(swapPrice.toAmount, toTokenDecimals)) / Number(args.fromAmount)).toString(),
+            };
+            return JSON.stringify(formattedResponse);
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: `Error fetching swap price: ${error}`,
+            });
+        }
+    }
+    /**
+     * Swaps tokens using the CDP client.
+     *
+     * @param walletProvider - The EVM wallet provider to perform the swap with.
+     * @param args - The input arguments for the swap action.
+     * @returns A JSON string with detailed swap execution information.
+     */
+    async swap(walletProvider, args) {
+        // Get CDP SDK network
+        const network = walletProvider.getNetwork();
+        const networkId = network.networkId;
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
+        // Check if the network is supported
+        if (networkId !== "base-mainnet" && networkId !== "ethereum-mainnet")
+            return JSON.stringify({
+                success: false,
+                error: "CDP Swap API is currently only supported on 'base-mainnet' or 'ethereum-mainnet'.",
+            });
+        try {
+            // Get token details
+            const { fromTokenDecimals, fromTokenName, toTokenName, toTokenDecimals } = await (0, swapUtils_1.getTokenDetails)(walletProvider, args.fromToken, args.toToken);
+            // Get the account
+            const account = await walletProvider.getClient().evm.getAccount({
+                address: walletProvider.getAddress(),
+            });
+            // Estimate swap price first to check liquidity, token balance and permit2 approval status
+            const swapPrice = await walletProvider.getClient().evm.getSwapPrice({
+                fromToken: args.fromToken,
+                toToken: args.toToken,
+                fromAmount: (0, viem_1.parseUnits)(args.fromAmount, fromTokenDecimals),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                network: cdpNetwork,
+                taker: account.address,
+            });
+            // Check if liquidity is available
+            if (!swapPrice.liquidityAvailable) {
+                return JSON.stringify({
+                    success: false,
+                    error: `No liquidity available to swap ${args.fromAmount} ${fromTokenName} (${args.fromToken}) to ${toTokenName} (${args.toToken})`,
+                });
+            }
+            // Check if balance is enough
+            if (swapPrice.issues.balance) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Balance is not enough to perform swap. Required: ${args.fromAmount} ${fromTokenName}, but only have ${(0, viem_1.formatUnits)(swapPrice.issues.balance.currentBalance, fromTokenDecimals)} ${fromTokenName} (${args.fromToken})`,
+                });
+            }
+            // Check if allowance is enough
+            let approvalTxHash = null;
+            if (swapPrice.issues.allowance) {
+                try {
+                    approvalTxHash = await walletProvider.sendTransaction({
+                        to: args.fromToken,
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: viem_1.erc20Abi,
+                            functionName: "approve",
+                            args: [swapUtils_1.PERMIT2_ADDRESS, viem_1.maxUint256],
+                        }),
+                    });
+                    const receipt = await walletProvider.waitForTransactionReceipt(approvalTxHash);
+                    if (receipt.status !== "success") {
+                        return JSON.stringify({
+                            success: false,
+                            error: `Approval transaction failed`,
+                        });
+                    }
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        success: false,
+                        error: `Error approving token: ${error}`,
+                    });
+                }
+            }
+            // Execute swap using the all-in-one pattern with retry logic
+            const swapResult = await (0, swapUtils_1.retryWithExponentialBackoff)(async () => {
+                return (await account.swap({
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    network: cdpNetwork,
+                    fromToken: args.fromToken,
+                    toToken: args.toToken,
+                    fromAmount: (0, viem_1.parseUnits)(args.fromAmount, fromTokenDecimals),
+                    slippageBps: args.slippageBps,
+                    signerAddress: account.address,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }));
+            }, 3, 5000); // Max 3 retries with 5s base delay
+            // Check if swap was successful
+            const swapReceipt = await walletProvider.waitForTransactionReceipt(swapResult.transactionHash);
+            if (swapReceipt.status !== "success") {
+                return JSON.stringify({
+                    success: false,
+                    error: `Swap transaction failed`,
+                });
+            }
+            // Format the successful response
+            const formattedResponse = {
+                success: true,
+                ...(approvalTxHash ? { approvalTxHash } : {}),
+                transactionHash: swapResult.transactionHash,
+                fromAmount: args.fromAmount,
+                fromTokenName: fromTokenName,
+                fromToken: args.fromToken,
+                toAmount: (0, viem_1.formatUnits)(swapPrice.toAmount, toTokenDecimals),
+                minToAmount: (0, viem_1.formatUnits)(swapPrice.minToAmount, toTokenDecimals),
+                toTokenName: toTokenName,
+                toToken: args.toToken,
+                slippageBps: args.slippageBps,
+                network: networkId,
+            };
+            return JSON.stringify(formattedResponse);
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: `Swap failed: ${error}`,
+            });
+        }
+    }
 }
 exports.CdpEvmWalletActionProvider = CdpEvmWalletActionProvider;
-_CdpEvmWalletActionProvider_instances = new WeakSet(), _CdpEvmWalletActionProvider_getCdpSdkNetwork = function _CdpEvmWalletActionProvider_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: "list_spend_permissions",
@@ -144,8 +301,51 @@ This action is specifically designed for EVM wallets and uses the EVM wallet for
         schema: schemas_1.UseSpendPermissionSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:paramtypes", [cdpEvmWalletProvider_1.CdpEvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpEvmWalletActionProvider.prototype, "useSpendPermission", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_swap_price",
+        description: `
+This tool fetches a price quote for swapping (trading) between two tokens using the CDP Swap API but does not execute a swap.
+It takes the following inputs:
+- fromToken: The contract address of the token to sell
+- toToken: The contract address of the token to buy
+- fromAmount: The amount of fromToken to swap in whole units (e.g. 1 ETH or 10.5 USDC)
+- slippageBps: (Optional) Maximum allowed slippage in basis points (100 = 1%)
+Important notes:
+- The contract address for native ETH is "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+- Use fromAmount units exactly as provided, do not convert to wei or any other units
+- Never assume token or address, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool if available to get the token address first
+`,
+        schema: schemas_1.SwapSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [cdpEvmWalletProvider_1.CdpEvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpEvmWalletActionProvider.prototype, "getSwapPrice", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "swap",
+        description: `
+This tool executes a token swap (trade) using the CDP Swap API.
+It takes the following inputs:
+- fromToken: The contract address of the token to sell
+- toToken: The contract address of the token to buy
+- fromAmount: The amount of fromToken to swap in whole units (e.g. 1 ETH or 10.5 USDC)
+- slippageBps: (Optional) Maximum allowed slippage in basis points (100 = 1%)
+Important notes:
+- The contract address for native ETH is "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+- If needed, it will automatically approve the permit2 contract to spend the fromToken
+- Use fromAmount units exactly as provided, do not convert to wei or any other units.
+- Never assume token or address, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool if available to get the token address first
+`,
+        schema: schemas_1.SwapSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [cdpEvmWalletProvider_1.CdpEvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpEvmWalletActionProvider.prototype, "swap", null);
 const cdpEvmWalletActionProvider = () => new CdpEvmWalletActionProvider();
 exports.cdpEvmWalletActionProvider = cdpEvmWalletActionProvider;

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

@@ -36,31 +36,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cdpEvmWalletActionProvider_1 = require("./cdpEvmWalletActionProvider");
 const schemas_1 = require("./schemas");
 const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
+const swapUtils = __importStar(require("./swapUtils"));
 // Mock the CDP SDK and utility functions
 jest.mock("@coinbase/cdp-sdk");
 jest.mock("./spendPermissionUtils");
+jest.mock("./swapUtils");
 describe("CDP EVM Wallet Action Provider", () => {
     let actionProvider;
     let mockWalletProvider;
     let mockCdpClient;
     let mockAccount;
+    const mockGetTokenDetails = swapUtils.getTokenDetails;
+    const mockRetryWithExponentialBackoff = swapUtils.retryWithExponentialBackoff;
     beforeEach(() => {
         jest.clearAllMocks();
         mockAccount = {
             useSpendPermission: jest.fn(),
+            swap: jest.fn(),
             address: "0x1234567890123456789012345678901234567890",
         };
         mockCdpClient = {
             evm: {
                 listSpendPermissions: jest.fn(),
                 getAccount: jest.fn(),
+                getSwapPrice: jest.fn(),
             },
         };
         mockWalletProvider = {
             getNetwork: jest.fn(),
             getAddress: jest.fn(),
             getClient: jest.fn(),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getCdpSdkNetwork: jest.fn(),
         };
+        // Default setup for utility functions
+        mockRetryWithExponentialBackoff.mockImplementation(async (fn) => {
+            return await fn();
+        });
         actionProvider = new cdpEvmWalletActionProvider_1.CdpEvmWalletActionProvider();
     });
     describe("listSpendPermissions", () => {
@@ -74,6 +87,7 @@ describe("CDP EVM Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully list spend permissions for EVM wallets", async () => {
             const expectedResult = "Found 2 spend permission(s):\n1. Token: USDC, Allowance: 500, Period: 1800 seconds, Start: 111111, End: 222222\n2. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
@@ -115,6 +129,7 @@ describe("CDP EVM Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
             mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
         });
         it("should successfully use spend permission for EVM wallets", async () => {
@@ -162,6 +177,7 @@ describe("CDP EVM Wallet Action Provider", () => {
                     networkId: testCase.networkId,
                 });
                 mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+                mockWalletProvider.getCdpSdkNetwork.mockReturnValue(testCase.expected);
                 mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
                 await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
                 expect(mockAccount.useSpendPermission).toHaveBeenCalledWith({
@@ -176,6 +192,7 @@ describe("CDP EVM Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "polygon-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("polygon-mainnet");
             const mockPermission = { spender: "0x1234", token: "MATIC" };
             const mockSpendResult = { status: "completed" };
             spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
@@ -229,6 +246,236 @@ describe("CDP EVM Wallet Action Provider", () => {
             expect(() => schemas_1.UseSpendPermissionSchema.parse(invalidInput)).toThrow();
         });
     });
+    describe("getSwapPrice", () => {
+        const mockArgs = {
+            fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
+            toToken: "0xA0b86991c6218b36c1d19D4a2e9EB0cE3606eB48", // USDC
+            fromAmount: "0.1",
+            slippageBps: 100,
+        };
+        beforeEach(() => {
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
+            mockGetTokenDetails.mockResolvedValue({
+                fromTokenDecimals: 18,
+                toTokenDecimals: 6,
+                fromTokenName: "ETH",
+                toTokenName: "USDC",
+            });
+        });
+        it("should get swap price quote on base-mainnet", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                toAmount: "990000", // 0.99 USDC
+                minToAmount: "980000", // 0.98 USDC
+                liquidityAvailable: true,
+                issues: {},
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockCdpClient.evm.getSwapPrice).toHaveBeenCalledWith({
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n, // 0.1 ETH in wei
+                network: "base",
+                taker: "0x1234567890123456789012345678901234567890",
+            });
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.fromAmount).toBe("0.1");
+            expect(parsedResult.toAmount).toBe("0.99");
+            expect(parsedResult.liquidityAvailable).toBe(true);
+        });
+        it("should get swap price quote on ethereum-mainnet", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("ethereum");
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                toAmount: "990000",
+                minToAmount: "980000",
+                liquidityAvailable: true,
+                issues: {},
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockCdpClient.evm.getSwapPrice).toHaveBeenCalledWith({
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n,
+                network: "ethereum",
+                taker: "0x1234567890123456789012345678901234567890",
+            });
+            expect(parsedResult.success).toBe(true);
+        });
+        it("should return error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("CDP Swap API is currently only supported on 'base-mainnet' or 'ethereum-mainnet'");
+        });
+        it("should handle swap price API errors", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockRejectedValue(new Error("API Error"));
+            const result = await actionProvider.getSwapPrice(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Error fetching swap price: Error: API Error");
+        });
+    });
+    describe("swap", () => {
+        const mockArgs = {
+            fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
+            toToken: "0xA0b86991c6218b36c1d19D4a2e9EB0cE3606eB48", // USDC
+            fromAmount: "0.1",
+            slippageBps: 100,
+        };
+        beforeEach(() => {
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
+            mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValue({ status: "success" });
+            mockGetTokenDetails.mockResolvedValue({
+                fromTokenDecimals: 18,
+                toTokenDecimals: 6,
+                fromTokenName: "ETH",
+                toTokenName: "USDC",
+            });
+        });
+        it("should execute swap on base-mainnet", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {},
+                toAmount: "990000", // 0.99 USDC
+                minToAmount: "980000", // 0.98 USDC
+            });
+            mockAccount.swap.mockResolvedValue({ transactionHash: "0xswap789" });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockCdpClient.evm.getAccount).toHaveBeenCalledWith({
+                address: "0x1234567890123456789012345678901234567890",
+            });
+            expect(mockAccount.swap).toHaveBeenCalledWith({
+                network: "base",
+                fromToken: mockArgs.fromToken,
+                toToken: mockArgs.toToken,
+                fromAmount: 100000000000000000n, // 0.1 ETH in wei
+                slippageBps: 100,
+                signerAddress: "0x1234567890123456789012345678901234567890",
+            });
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.transactionHash).toBe("0xswap789");
+            expect(parsedResult.fromAmount).toBe("0.1");
+            expect(parsedResult.toAmount).toBe("0.99");
+        });
+        it("should return error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("CDP Swap API is currently only supported on 'base-mainnet' or 'ethereum-mainnet'");
+        });
+        it("should return error when liquidity is not available", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: false,
+                issues: {},
+                toAmount: "0",
+                minToAmount: "0",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("No liquidity available to swap");
+        });
+        it("should return error when balance is insufficient", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {
+                    balance: {
+                        currentBalance: "50000000000000000", // 0.05 ETH
+                    },
+                },
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Balance is not enough to perform swap");
+            expect(parsedResult.error).toContain("but only have 0.05 ETH");
+        });
+        it("should handle approval transaction when allowance is insufficient", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {
+                    allowance: {
+                        requiredAllowance: "100000000000000000",
+                        currentAllowance: "0",
+                    },
+                },
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            mockWalletProvider.sendTransaction.mockResolvedValue("0xapproval123");
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({ status: "success" }); // For approval
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({ status: "success" }); // For swap
+            mockAccount.swap.mockResolvedValue({ transactionHash: "0xswap789" });
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.approvalTxHash).toBe("0xapproval123");
+            expect(parsedResult.transactionHash).toBe("0xswap789");
+        });
+        it("should handle swap execution errors", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            mockCdpClient.evm.getSwapPrice.mockResolvedValue({
+                liquidityAvailable: true,
+                issues: {},
+                toAmount: "990000",
+                minToAmount: "980000",
+            });
+            mockAccount.swap.mockRejectedValue(new Error("Swap execution failed"));
+            const result = await actionProvider.swap(mockWalletProvider, mockArgs);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toContain("Swap failed: Error: Swap execution failed");
+        });
+    });
     describe("supportsNetwork", () => {
         it("should return true for EVM networks", () => {
             const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
@@ -239,4 +486,35 @@ describe("CDP EVM Wallet Action Provider", () => {
             expect(actionProvider.supportsNetwork(svmNetwork)).toBe(false);
         });
     });
+    describe("SwapSchema", () => {
+        it("should validate correct swap input", () => {
+            const validInput = {
+                fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                toToken: "0xA0b86991c6218b36c1d19D4a2e9EB0cE3606eB48",
+                fromAmount: "0.1",
+            };
+            const result = schemas_1.SwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ ...validInput, slippageBps: 100 });
+        });
+        it("should validate swap input with optional slippageBps", () => {
+            const validInput = {
+                fromToken: "0xA0b86991c6218b36c1d19D4a2e9EB0cE3606eB48",
+                toToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                fromAmount: "100",
+                slippageBps: 50,
+            };
+            const result = schemas_1.SwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail validation when missing required fields", () => {
+            const invalidInput = {
+                fromToken: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                // missing toToken and fromAmount
+            };
+            const result = schemas_1.SwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
 });