@coinbase/agentkit 0.10.2 → 0.10.3

package/README.md

@@ -313,6 +313,15 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Enso</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>route</code></td>
+    <td width="768">Find and execute a route for entering or exiting any DeFi position or swapping any ERC20 tokens.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>ERC20</strong></summary>
 <table width="100%">
 <tr>
@@ -323,6 +332,14 @@ const agent = createReactAgent({
     <td width="200"><code>transfer</code></td>
     <td width="768">Transfers a specified amount of ERC-20 tokens to a destination address.</td>
 </tr>
+<tr>
+    <td width="200"><code>approve</code></td>
+    <td width="768">Approves a spender to transfer ERC-20 tokens on behalf of the wallet.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_allowance</code></td>
+    <td width="768">Checks the allowance amount for a spender of an ERC-20 token.</td>
+</tr>
 <tr>
     <td width="200"><code>get_erc20_token_address</code></td>
     <td width="768">Gets the contract address for frequently used ERC20 tokens on different networks by token symbol.</td>
@@ -650,6 +667,31 @@ it will return payment details that can be used on retry.</td>
 </table>
 </details>
 <details>
+<summary><strong>Yelay</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>get_vaults</code></td>
+    <td width="768">Fetches a list of available Yelay Vaults with their current APYs and contract addresses.</td>
+</tr>
+<tr>
+    <td width="200"><code>deposit</code></td>
+    <td width="768">Deposits assets into a specified Yelay Vault.</td>
+</tr>
+<tr>
+    <td width="200"><code>redeem</code></td>
+    <td width="768">Withdraws assets from a Yelay Vault.</td>
+</tr>
+<tr>
+    <td width="200"><code>claim</code></td>
+    <td width="768">Claims accumulated yield from a Yelay Vault.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_balance</code></td>
+    <td width="768">Gets the user's balance and yield information for a specific vault.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>ZeroX</strong></summary>
 <table width="100%">
 <tr>

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

@@ -12,10 +12,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiActionProvider = exports.CdpApiActionProvider = void 0;
 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 schemas_1 = require("./schemas");
+const faucetUtils_1 = require("./faucetUtils");
 /**
  * CdpApiActionProvider is an action provider for CDP API.
  *
@@ -47,35 +47,12 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
     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.");
-            }
-        }
-        else {
-            throw new Error("Wallet provider is not a CDP Wallet Provider.");
-        }
+        const address = walletProvider.getAddress();
+        const cdpClient = (0, faucetUtils_1.getCdpClient)(walletProvider);
+        (0, faucetUtils_1.validateNetworkSupport)(network, networkId);
+        return network.protocolFamily === "evm"
+            ? (0, faucetUtils_1.handleEvmFaucet)(cdpClient, address, networkId, args)
+            : (0, faucetUtils_1.handleSvmFaucet)(cdpClient, address, args);
     }
 }
 exports.CdpApiActionProvider = CdpApiActionProvider;

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

@@ -72,19 +72,13 @@ describe("CDP API Action Provider", () => {
             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");
+            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" }),
-            };
-            await expect(actionProvider.faucet(mockWalletWithoutClient, { assetId: "eth" })).rejects.toThrow("Wallet provider is not a CDP Wallet Provider");
+            await expect(actionProvider.faucet(mockWalletProvider, { assetId: "sol" })).rejects.toThrow("Faucet is only supported on solana-devnet svm networks");
         });
     });
     describe("RequestFaucetFundsV2Schema", () => {

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { CdpClient } from "@coinbase/cdp-sdk";
+import { Network } from "../../network";
+import { WalletProvider } from "../../wallet-providers";
+import { RequestFaucetFundsV2Schema } from "./schemas";
+/**
+ * Gets or creates a CDP client from the wallet provider or environment variables.
+ *
+ * @param walletProvider - The wallet provider to get the client from.
+ * @returns The CDP client.
+ */
+export declare function getCdpClient(walletProvider: WalletProvider): CdpClient;
+/**
+ * Validates that the network and protocol family are supported for faucet operations.
+ *
+ * @param network - The network to validate.
+ * @param networkId - The network ID to validate.
+ */
+export declare function validateNetworkSupport(network: Network, networkId: string): void;
+/**
+ * Handles faucet requests for EVM networks.
+ *
+ * @param cdpClient - The CDP client to use.
+ * @param address - The address to request funds from.
+ * @param networkId - The network ID to request funds from.
+ * @param args - The arguments to request funds from.
+ * @returns The transaction hash.
+ */
+export declare function handleEvmFaucet(cdpClient: CdpClient, address: string, networkId: string, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
+/**
+ * Handles faucet requests for Solana networks.
+ *
+ * @param cdpClient - The CDP client to use.
+ * @param address - The address to request funds from.
+ * @param args - The arguments to request funds from.
+ * @returns The transaction hash.
+ */
+export declare function handleSvmFaucet(cdpClient: CdpClient, address: string, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCdpClient = getCdpClient;
+exports.validateNetworkSupport = validateNetworkSupport;
+exports.handleEvmFaucet = handleEvmFaucet;
+exports.handleSvmFaucet = handleSvmFaucet;
+const cdp_sdk_1 = require("@coinbase/cdp-sdk");
+const cdpShared_1 = require("../../wallet-providers/cdpShared");
+/**
+ * Gets or creates a CDP client from the wallet provider or environment variables.
+ *
+ * @param walletProvider - The wallet provider to get the client from.
+ * @returns The CDP client.
+ */
+function getCdpClient(walletProvider) {
+    if ((0, cdpShared_1.isWalletProviderWithClient)(walletProvider)) {
+        return walletProvider.getClient();
+    }
+    const apiKeyId = process.env.CDP_API_KEY_ID;
+    const apiKeySecret = process.env.CDP_API_KEY_SECRET;
+    if (!apiKeyId || !apiKeySecret) {
+        throw new Error("Faucet requires CDP_API_KEY_ID and CDP_API_KEY_SECRET environment variables to be set.");
+    }
+    return new cdp_sdk_1.CdpClient({ apiKeyId, apiKeySecret });
+}
+/**
+ * Validates that the network and protocol family are supported for faucet operations.
+ *
+ * @param network - The network to validate.
+ * @param networkId - The network ID to validate.
+ */
+function validateNetworkSupport(network, networkId) {
+    const supportedProtocols = ["evm", "svm"];
+    if (!supportedProtocols.includes(network.protocolFamily)) {
+        throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
+    }
+    const supportedEvmNetworks = ["base-sepolia", "ethereum-sepolia"];
+    const supportedSvmNetworks = ["solana-devnet"];
+    const isEvmSupported = network.protocolFamily === "evm" && supportedEvmNetworks.includes(networkId);
+    const isSvmSupported = network.protocolFamily === "svm" && supportedSvmNetworks.includes(networkId);
+    if (!isEvmSupported && !isSvmSupported) {
+        const supportedNetworks = network.protocolFamily === "evm"
+            ? supportedEvmNetworks.join(" or ")
+            : supportedSvmNetworks.join(" or ");
+        throw new Error(`Faucet is only supported on ${supportedNetworks} ${network.protocolFamily} networks.`);
+    }
+}
+/**
+ * Handles faucet requests for EVM networks.
+ *
+ * @param cdpClient - The CDP client to use.
+ * @param address - The address to request funds from.
+ * @param networkId - The network ID to request funds from.
+ * @param args - The arguments to request funds from.
+ * @returns The transaction hash.
+ */
+async function handleEvmFaucet(cdpClient, address, networkId, args) {
+    const token = (args.assetId || "eth");
+    const faucetTx = await cdpClient.evm.requestFaucet({
+        address,
+        token,
+        network: networkId,
+    });
+    return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
+}
+/**
+ * Handles faucet requests for Solana networks.
+ *
+ * @param cdpClient - The CDP client to use.
+ * @param address - The address to request funds from.
+ * @param args - The arguments to request funds from.
+ * @returns The transaction hash.
+ */
+async function handleSvmFaucet(cdpClient, address, args) {
+    const token = (args.assetId || "sol");
+    const faucetTx = await cdpClient.solana.requestFaucet({
+        address,
+        token,
+    });
+    return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
+}

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

@@ -17,11 +17,11 @@ export declare const ClankTokenSchema: z.ZodObject<{
         platform: z.ZodString;
         url: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        url: string;
         platform: string;
-    }, {
         url: string;
+    }, {
         platform: string;
+        url: string;
     }>, "many">>;
     interface: z.ZodDefault<z.ZodString>;
     id: z.ZodDefault<z.ZodString>;
@@ -36,8 +36,8 @@ export declare const ClankTokenSchema: z.ZodObject<{
     interface: string;
     description?: string | undefined;
     socialMediaUrls?: {
-        url: string;
         platform: string;
+        url: string;
     }[] | undefined;
 }, {
     tokenName: string;
@@ -49,8 +49,8 @@ export declare const ClankTokenSchema: z.ZodObject<{
     id?: string | undefined;
     description?: string | undefined;
     socialMediaUrls?: {
-        url: string;
         platform: string;
+        url: string;
     }[] | undefined;
     interface?: string | undefined;
 }>;

package/dist/action-providers/enso/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const ENSO_API_KEY: "1e02632d-6feb-4a75-a157-documentation";
+export declare const ENSO_ETH: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const ENSO_ROUTE_SINGLE_SIG: "0xb94c3609";
+export declare const ENSO_SUPPORTED_NETWORKS: Set<number>;

package/dist/action-providers/enso/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENSO_SUPPORTED_NETWORKS = exports.ENSO_ROUTE_SINGLE_SIG = exports.ENSO_ETH = exports.ENSO_API_KEY = void 0;
+exports.ENSO_API_KEY = "1e02632d-6feb-4a75-a157-documentation";
+exports.ENSO_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+exports.ENSO_ROUTE_SINGLE_SIG = "0xb94c3609";
+exports.ENSO_SUPPORTED_NETWORKS = new Set([
+    1, 10, 56, 100, 130, 137, 146, 480, 999, 1868, 8453, 42161, 43114, 57073, 59144, 80094, 98866,
+    747474,
+]);

package/dist/action-providers/enso/ensoActionProvider.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EnsoActionProviderParams, EnsoRouteSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { EnsoClient } from "@ensofinance/sdk";
+/**
+ * EnsoActionProvider is an action provider for Enso.
+ */
+export declare class EnsoActionProvider extends ActionProvider<EvmWalletProvider> {
+    readonly ensoClient: EnsoClient;
+    /**
+     * Constructor for the EnsoActionProvider
+     *
+     * @param params - The initialization parameters for the Enso action provider
+     */
+    constructor(params?: EnsoActionProviderParams);
+    /**
+     * Finds the optimal route from a token to a token and executes it.
+     *
+     * @param walletProvider - The wallet to execute the transaction from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token route details.
+     */
+    route(walletProvider: EvmWalletProvider, args: z.infer<typeof EnsoRouteSchema>): Promise<string>;
+    /**
+     * Checks if the Enso action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Enso action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const ensoActionProvider: () => EnsoActionProvider;

package/dist/action-providers/enso/ensoActionProvider.js

@@ -0,0 +1,125 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensoActionProvider = exports.EnsoActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const viem_1 = require("viem");
+const wallet_providers_1 = require("../../wallet-providers");
+const constants_1 = require("./constants");
+const sdk_1 = require("@ensofinance/sdk");
+/**
+ * EnsoActionProvider is an action provider for Enso.
+ */
+class EnsoActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the EnsoActionProvider
+     *
+     * @param params - The initialization parameters for the Enso action provider
+     */
+    constructor(params = {}) {
+        super("enso", []);
+        /**
+         * Checks if the Enso action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Enso action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => {
+            const chainIdCheck = network.chainId && constants_1.ENSO_SUPPORTED_NETWORKS.has(Number(network.chainId));
+            return Boolean(chainIdCheck);
+        };
+        this.ensoClient = new sdk_1.EnsoClient({ apiKey: params.apiKey || constants_1.ENSO_API_KEY });
+    }
+    /**
+     * Finds the optimal route from a token to a token and executes it.
+     *
+     * @param walletProvider - The wallet to execute the transaction from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token route details.
+     */
+    async route(walletProvider, args) {
+        try {
+            const chainId = Number(walletProvider.getNetwork().chainId);
+            if (!chainId || !constants_1.ENSO_SUPPORTED_NETWORKS.has(chainId)) {
+                return `Network ${chainId} is not supported by Enso`;
+            }
+            const fromAddress = (0, viem_1.getAddress)(walletProvider.getAddress());
+            const tokenIn = (0, viem_1.getAddress)(args.tokenIn);
+            const tokenOut = (0, viem_1.getAddress)(args.tokenOut);
+            const tokenInResponse = await this.ensoClient.getTokenData({
+                address: tokenIn,
+                chainId,
+            });
+            if (tokenInResponse.data.length !== 1) {
+                throw `Could not find data for provided tokenIn`;
+            }
+            const tokenInData = tokenInResponse.data[0];
+            const amountIn = (0, viem_1.parseUnits)(args.amountIn, tokenInData.decimals).toString();
+            const params = {
+                chainId,
+                tokenIn: [tokenIn],
+                tokenOut: [tokenOut],
+                amountIn: [amountIn],
+                routingStrategy: "router",
+                fromAddress,
+                receiver: fromAddress,
+                spender: fromAddress,
+            };
+            if (args.slippage) {
+                params.slippage = args.slippage;
+            }
+            const routeData = await this.ensoClient.getRouteData(params);
+            if (!routeData.tx.data.startsWith(constants_1.ENSO_ROUTE_SINGLE_SIG)) {
+                return `Unsupported calldata returned from Enso API`;
+            }
+            // If the tokenIn is ERC20, do approve
+            if (args.tokenIn.toLowerCase() !== constants_1.ENSO_ETH.toLowerCase()) {
+                const approval = await this.ensoClient.getApprovalData({
+                    chainId,
+                    amount: amountIn,
+                    fromAddress,
+                    tokenAddress: (0, viem_1.getAddress)(args.tokenIn),
+                });
+                const hash = await walletProvider.sendTransaction({
+                    to: approval.tx.to,
+                    data: approval.tx.data,
+                });
+                await walletProvider.waitForTransactionReceipt(hash);
+            }
+            const hash = await walletProvider.sendTransaction({
+                to: routeData.tx.to,
+                value: BigInt(routeData.tx.value),
+                data: routeData.tx.data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Route executed successfully, transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error routing token through Enso: ${error}`;
+        }
+    }
+}
+exports.EnsoActionProvider = EnsoActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "route",
+        description: `This tool will find the optimal route for entering or exiting any DeFi position or swapping any ERC20 tokens.`,
+        schema: schemas_1.EnsoRouteSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], EnsoActionProvider.prototype, "route", null);
+const ensoActionProvider = () => new EnsoActionProvider();
+exports.ensoActionProvider = ensoActionProvider;

package/dist/action-providers/enso/ensoActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/enso/ensoActionProvider.test.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const ensoActionProvider_1 = require("./ensoActionProvider");
+const schemas_1 = require("./schemas");
+const MOCK_ADDRESS = "0x1234567890123456789012345678901234543210";
+const ENSO_ROUTER_BASE = "0xF75584eF6673aD213a685a1B58Cc0330B8eA22Cf";
+const WETH = "0x4200000000000000000000000000000000000006";
+const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+const mockGetTokenData = jest.fn();
+const mockGetRouteData = jest.fn();
+const mockGetApprovalData = jest.fn();
+jest.mock("@ensofinance/sdk", () => {
+    return {
+        EnsoClient: jest.fn().mockImplementation(() => {
+            return {
+                getTokenData: mockGetTokenData,
+                getRouteData: mockGetRouteData,
+                getApprovalData: mockGetApprovalData,
+            };
+        }),
+    };
+});
+describe("Enso Route Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            tokenIn: USDC,
+            tokenOut: WETH,
+            amountIn: "100",
+            slippage: 50,
+        };
+        const result = schemas_1.EnsoRouteSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.EnsoRouteSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Enso Route Action", () => {
+    let mockWallet;
+    const actionProvider = (0, ensoActionProvider_1.ensoActionProvider)();
+    const args = {
+        tokenIn: USDC,
+        tokenOut: WETH,
+        amountIn: "100",
+    };
+    beforeEach(async () => {
+        jest.clearAllMocks();
+        // Set up default mock responses for EnsoClient methods for successful scenarios
+        mockGetTokenData.mockResolvedValue({
+            data: [
+                {
+                    address: USDC,
+                    decimals: 6,
+                    symbol: "USDC",
+                },
+            ],
+        });
+        mockGetRouteData.mockResolvedValue({
+            tx: {
+                to: ENSO_ROUTER_BASE,
+                value: "0",
+                data: "0xb94c3609000000000000000000000000f75584ef6673ad213a685a1b58cc0330b8ea22cf0000000000000000000000000000000000000000000000000000000005f5e100",
+            },
+        });
+        mockGetApprovalData.mockResolvedValue({
+            tx: {
+                to: USDC,
+                data: "0x095ea7b3000000000000000000000000f75584ef6673ad213a685a1b58cc0330b8ea22cf0000000000000000000000000000000000000000000000000000000005f5e100",
+            },
+        });
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({ chainId: "8453" }),
+        };
+    });
+    it("should successfully respond", async () => {
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.route(mockWallet, args);
+        // First transaction should be the approval
+        expect(mockWallet.sendTransaction).toHaveBeenNthCalledWith(1, // First call
+        expect.objectContaining({
+            to: (0, viem_1.getAddress)(args.tokenIn),
+        }));
+        // Second transaction should be the route execution
+        expect(mockWallet.sendTransaction).toHaveBeenNthCalledWith(2, // Second call
+        expect.objectContaining({
+            to: ENSO_ROUTER_BASE,
+            value: BigInt(0),
+        }));
+        expect(response).toContain(`Route executed successfully, transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const error = new Error("Failed to route through Enso");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.route(mockWallet, args);
+        // First transaction should be the approval
+        expect(mockWallet.sendTransaction).toHaveBeenNthCalledWith(1, // First call
+        expect.objectContaining({
+            to: (0, viem_1.getAddress)(args.tokenIn),
+        }));
+        expect(response).toContain(`Error routing token through Enso: ${error}`);
+    });
+});
+describe("supportsNetwork", () => {
+    const actionProvider = (0, ensoActionProvider_1.ensoActionProvider)();
+    it("should return false for base-mainnet (supported only with chainId)", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "base-mainnet",
+        });
+        expect(result).toBe(false);
+    });
+    it("should return true for 8453 (base)", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            chainId: "8453",
+        });
+        expect(result).toBe(true);
+    });
+    it("should return false for base-sepolia", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "base-sepolia",
+        });
+        expect(result).toBe(false);
+    });
+    it("should return true for 1 (mainnet)", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            chainId: "1",
+        });
+        expect(result).toBe(true);
+    });
+});

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

@@ -0,0 +1 @@
+export * from "./ensoActionProvider";

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

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

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export interface EnsoActionProviderParams {
+    apiKey?: string;
+}
+/**
+ * Input schema for route action.
+ */
+export declare const EnsoRouteSchema: z.ZodObject<{
+    tokenIn: z.ZodString;
+    tokenOut: z.ZodString;
+    amountIn: z.ZodString;
+    slippage: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    slippage?: number | undefined;
+}, {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    slippage?: number | undefined;
+}>;