@coinbase/agentkit 0.10.1 → 0.10.3

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

@@ -18,6 +18,7 @@ const schemas_1 = require("./schemas");
 const spendPermissionUtils_1 = require("./spendPermissionUtils");
 const swapUtils_1 = require("./swapUtils");
 const viem_1 = require("viem");
+const utils_1 = require("../../utils");
 /**
  * CdpSmartWalletActionProvider is an action provider for CDP Smart Wallet specific actions.
  *
@@ -216,7 +217,7 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
                 }
             }
             // Execute swap using the all-in-one pattern with retry logic
-            const swapResult = await (0, swapUtils_1.retryWithExponentialBackoff)(async () => {
+            const swapResult = await (0, utils_1.retryWithExponentialBackoff)(async () => {
                 return (await walletProvider.smartAccount.swap({
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     network: cdpNetwork,

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

@@ -37,17 +37,19 @@ const cdpSmartWalletActionProvider_1 = require("./cdpSmartWalletActionProvider")
 const schemas_1 = require("./schemas");
 const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
 const swapUtils = __importStar(require("./swapUtils"));
+const utils = __importStar(require("../../utils"));
 // Mock the CDP SDK and utility functions
 jest.mock("@coinbase/cdp-sdk");
 jest.mock("./spendPermissionUtils");
 jest.mock("./swapUtils");
+jest.mock("../../utils");
 describe("CDP Smart Wallet Action Provider", () => {
     let actionProvider;
     let mockWalletProvider;
     let mockCdpClient;
     let mockSmartAccount;
     const mockGetTokenDetails = swapUtils.getTokenDetails;
-    const mockRetryWithExponentialBackoff = swapUtils.retryWithExponentialBackoff;
+    const mockRetryWithExponentialBackoff = utils.retryWithExponentialBackoff;
     beforeEach(() => {
         jest.clearAllMocks();
         mockSmartAccount = {

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/cdp/swapUtils.d.ts

@@ -21,12 +21,3 @@ export declare function getTokenDetails(walletProvider: EvmWalletProvider, fromT
     fromTokenName: string;
     toTokenName: string;
 }>;
-/**
- * Retry function with exponential backoff
- *
- * @param fn - The function to retry
- * @param maxRetries - Maximum number of retries (default: 3)
- * @param baseDelay - Base delay in milliseconds (default: 1000)
- * @returns Promise that resolves with the function result or rejects with the last error
- */
-export declare function retryWithExponentialBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PERMIT2_ADDRESS = void 0;
 exports.isNativeEth = isNativeEth;
 exports.getTokenDetails = getTokenDetails;
-exports.retryWithExponentialBackoff = retryWithExponentialBackoff;
 const viem_1 = require("viem");
 // Permit2 contract address is the same across all networks
 exports.PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
@@ -105,38 +104,3 @@ async function getTokenDetails(walletProvider, fromToken, toToken) {
     }
     return { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName };
 }
-/**
- * Utility function to sleep for a given number of milliseconds
- *
- * @param ms - Number of milliseconds to sleep
- * @returns Promise that resolves after the specified delay
- */
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-/**
- * Retry function with exponential backoff
- *
- * @param fn - The function to retry
- * @param maxRetries - Maximum number of retries (default: 3)
- * @param baseDelay - Base delay in milliseconds (default: 1000)
- * @returns Promise that resolves with the function result or rejects with the last error
- */
-async function retryWithExponentialBackoff(fn, maxRetries = 3, baseDelay = 1000) {
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        // Wait before each attempt
-        // Calculate delay with exponential backoff: baseDelay * 2^attempt
-        const delay = baseDelay * Math.pow(2, attempt);
-        await sleep(delay);
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            // If this was the last attempt, throw the error
-            if (attempt === maxRetries) {
-                throw lastError;
-            }
-        }
-    }
-    throw lastError;
-}

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

@@ -17,40 +17,40 @@ 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>;
 }, "strip", z.ZodTypeAny, {
     id: string;
+    tokenName: string;
     tokenSymbol: string;
     image: string;
-    tokenName: string;
     vaultPercentage: number;
     lockDuration_Days: number;
     vestingDuration_Days: number;
     interface: string;
     description?: string | undefined;
     socialMediaUrls?: {
-        url: string;
         platform: string;
+        url: string;
     }[] | undefined;
 }, {
+    tokenName: string;
     tokenSymbol: string;
     image: string;
-    tokenName: string;
     vaultPercentage: number;
     lockDuration_Days: number;
     vestingDuration_Days: number;
     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;
+}>;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsoRouteSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for route action.
+ */
+exports.EnsoRouteSchema = zod_1.z
+    .object({
+    tokenIn: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("Address of the token to swap from. For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
+    tokenOut: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("Address of the token to swap to, For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"),
+    amountIn: zod_1.z.string().describe("Amount of tokenIn to swap in whole units (e.g. 100 USDC)"),
+    slippage: zod_1.z.number().optional().describe("Slippage in basis points (1/10000). Default - 50"),
+})
+    .strip()
+    .describe("Instructions for routing through Enso API");

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

@@ -30,8 +30,10 @@ export declare const TOKEN_ADDRESSES_BY_SYMBOLS: {
     };
     readonly "arbitrum-mainnet": {
         readonly USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831";
+        readonly WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
     };
     readonly "optimism-mainnet": {
         readonly USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85";
+        readonly WETH: "0x4200000000000000000000000000000000000006";
     };
 };