@coinbase/agentkit 0.0.0-nightly-20250820210426 → 0.0.0-nightly-20250822210413

package/README.md

@@ -383,6 +383,43 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Superfluid</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>create_pool</code></td>
+    <td width="768">Creates a new Superfluid pool for a Supertoken.</td>
+</tr>
+<tr>
+    <td width="200"><code>update_pool</code></td>
+    <td width="768">Updates an existing Superfluid pool with recipients and flow rates.</td>
+</tr>
+<tr>
+    <td width="200"><code>query_streams</code></td>
+    <td width="768">Queries existing Superfluid streams using Graphql.</td>
+</tr>
+<tr>
+    <td width="200"><code>create_stream</code></td>
+    <td width="768">Creates a new Superfluid stream to an address with a given flow rate.</td>
+</tr>
+<tr>
+    <td width="200"><code>update_stream</code></td>
+    <td width="768">Updates an existing Superfluid stream with a new flow rate.</td>
+</tr>
+<tr>
+    <td width="200"><code>delete_stream</code></td>
+    <td width="768">Stops an existing Superfluid stream.</td>
+</tr>
+<tr>
+    <td width="200"><code>create_super_token</code></td>
+    <td width="768">Creates a new Supertoken implementation for an existing ERC20 token.</td>
+</tr>
+<tr>
+    <td width="200"><code>wrap_superfluid_token</code></td>
+    <td width="768">Wraps an ERC20 token into its Superfluid Super token implementation.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Twitter</strong></summary>
 <table width="100%">
 <tr>

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { Network } from "../../network";
 import { WalletProvider } from "../../wallet-providers";
 import { ActionProvider } from "../actionProvider";
-import { RequestFaucetFundsV2Schema, SwapSchema } from "./schemas";
+import { RequestFaucetFundsV2Schema } from "./schemas";
 /**
  * CdpApiActionProvider is an action provider for CDP API.
  *
@@ -23,20 +23,12 @@ export declare class CdpApiActionProvider extends ActionProvider<WalletProvider>
      */
     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.
+     * 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.
+     * @returns True if the CDP action provider supports the network, false otherwise.
      */
     supportsNetwork: (_: Network) => boolean;
 }

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

@@ -8,11 +8,6 @@ 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;
@@ -35,12 +30,12 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
         super("cdp_api", []);
         _CdpApiActionProvider_instances.add(this);
         /**
-         * Checks if the Cdp action provider supports the given network.
+         * 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.
+         * @returns True if the CDP action provider supports the network, false otherwise.
          */
         this.supportsNetwork = (_) => true;
     }
@@ -84,50 +79,6 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
             throw new Error("Wallet provider is not a CDP Wallet Provider.");
         }
     }
-    /**
-     * 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.
-     */
-    async swap(walletProvider, args) {
-        const network = walletProvider.getNetwork();
-        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
-                        paymasterUrl: walletProvider.getPaymasterUrl?.(),
-                        // 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.");
-            }
-        }
-        else {
-            throw new Error("Wallet provider is not a CDP Wallet Provider.");
-        }
-    }
 }
 exports.CdpApiActionProvider = CdpApiActionProvider;
 _CdpApiActionProvider_instances = new WeakSet(), _CdpApiActionProvider_getCdpSdkNetwork = function _CdpApiActionProvider_getCdpSdkNetwork(networkId) {
@@ -159,19 +110,5 @@ from another wallet and provide the user with your wallet details.`,
     __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpApiActionProvider.prototype, "faucet", null);
-__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

@@ -10,20 +10,14 @@ describe("CDP API Action Provider", () => {
     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(),
@@ -93,94 +87,6 @@ describe("CDP API Action Provider", () => {
             await expect(actionProvider.faucet(mockWalletWithoutClient, { assetId: "eth" })).rejects.toThrow("Wallet provider is not a CDP Wallet Provider");
         });
     });
-    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" }),
-            };
-            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" };
@@ -193,35 +99,4 @@ describe("CDP API Action Provider", () => {
             expect(result.success).toBe(true);
         });
     });
-    describe("SwapSchema", () => {
-        it("should validate correct swap input", () => {
-            const validInput = {
-                fromAssetId: "eth",
-                toAssetId: "usdc",
-                amount: "0.1",
-            };
-            const result = schemas_1.SwapSchema.safeParse(validInput);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(validInput);
-        });
-        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 fail validation when missing required fields", () => {
-            const invalidInput = {
-                fromAssetId: "eth",
-                // missing toAssetId and amount
-            };
-            const result = schemas_1.SwapSchema.safeParse(invalidInput);
-            expect(result.success).toBe(false);
-        });
-    });
 });

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { WalletProvider } from "../../wallet-providers";
 import { CdpEvmWalletProvider } from "../../wallet-providers/cdpEvmWalletProvider";
 import { ActionProvider } from "../actionProvider";
-import { UseSpendPermissionSchema, ListSpendPermissionsSchema } from "./schemas";
+import { UseSpendPermissionSchema, ListSpendPermissionsSchema, SwapSchema } from "./schemas";
 import type { Network } from "../../network";
 /**
  * CdpEvmWalletActionProvider is an action provider for CDP EVM Wallet specific actions.
@@ -32,6 +32,22 @@ export declare class CdpEvmWalletActionProvider extends ActionProvider<CdpEvmWal
      * @returns A confirmation message with transaction details.
      */
     useSpendPermission(walletProvider: WalletProvider, args: z.infer<typeof UseSpendPermissionSchema>): Promise<string>;
+    /**
+     * 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.
+     */
+    getSwapPrice(walletProvider: CdpEvmWalletProvider, args: z.infer<typeof SwapSchema>): Promise<string>;
+    /**
+     * 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.
+     */
+    swap(walletProvider: CdpEvmWalletProvider, args: z.infer<typeof SwapSchema>): Promise<string>;
     /**
      * Checks if the EVM wallet action provider supports the given network.
      *

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

@@ -19,10 +19,13 @@ 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.
  *
@@ -105,6 +108,181 @@ 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 = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
+        // 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 = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
+        // 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) {
@@ -147,5 +325,46 @@ This action is specifically designed for EVM wallets and uses the EVM wallet for
     __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, 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.
+`,
+        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.
+`,
+        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;