@coinbase/agentkit 0.10.2 → 0.10.4

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";
     };
 };

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

@@ -43,8 +43,10 @@ exports.TOKEN_ADDRESSES_BY_SYMBOLS = {
     },
     "arbitrum-mainnet": {
         USDC: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
     },
     "optimism-mainnet": {
         USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+        WETH: "0x4200000000000000000000000000000000000006",
     },
 };

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema } from "./schemas";
+import { GetBalanceSchema, TransferSchema, GetTokenAddressSchema, ApproveSchema, AllowanceSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * ERC20ActionProvider is an action provider for ERC20 tokens.
@@ -27,6 +27,22 @@ export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvide
      * @returns A message containing the transfer details.
      */
     transfer(walletProvider: EvmWalletProvider, args: z.infer<typeof TransferSchema>): Promise<string>;
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    approve(walletProvider: EvmWalletProvider, args: z.infer<typeof ApproveSchema>): Promise<string>;
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    getAllowance(walletProvider: EvmWalletProvider, args: z.infer<typeof AllowanceSchema>): Promise<string>;
     /**
      * Gets the contract address for a token symbol on the current network.
      *

package/dist/action-providers/erc20/erc20ActionProvider.js

@@ -117,6 +117,66 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
             return `Error transferring the asset: ${error}`;
         }
     }
+    /**
+     * Approves a spender to transfer a specified amount of tokens.
+     *
+     * @param walletProvider - The wallet provider to approve from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the approval details.
+     */
+    async approve(walletProvider, args) {
+        try {
+            // Get token details for better error messages and validation
+            const tokenAddress = (0, viem_1.getAddress)(args.tokenAddress);
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress);
+            if (!tokenDetails) {
+                return `Error: Could not fetch token details for ${args.tokenAddress}. Please verify the token address is correct.`;
+            }
+            // Convert amount to wei using token decimals
+            const amountInWei = (0, viem_1.parseUnits)(String(args.amount), tokenDetails.decimals);
+            const hash = await walletProvider.sendTransaction({
+                to: tokenAddress,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: viem_1.erc20Abi,
+                    functionName: "approve",
+                    args: [args.spenderAddress, amountInWei],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Approved ${args.amount} ${tokenDetails.name} (${args.tokenAddress}) for spender ${args.spenderAddress}.\nTransaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error approving tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks the allowance for a spender of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to check the allowance from.
+     * @param args - The input arguments containing tokenAddress and spender.
+     * @returns A message containing the allowance amount for the spender.
+     */
+    async getAllowance(walletProvider, args) {
+        try {
+            // Get token details for proper formatting
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, args.tokenAddress);
+            if (!tokenDetails) {
+                return `Error: Could not fetch token details for ${args.tokenAddress}. Please verify the token address is correct.`;
+            }
+            const allowance = await walletProvider.readContract({
+                address: args.tokenAddress,
+                abi: viem_1.erc20Abi,
+                functionName: "allowance",
+                args: [walletProvider.getAddress(), args.spenderAddress],
+            });
+            // Format the allowance using token decimals
+            const formattedAllowance = (0, viem_1.formatUnits)(allowance, tokenDetails.decimals);
+            return `Allowance for ${args.spenderAddress} to spend ${tokenDetails.name} (${args.tokenAddress}) is ${formattedAllowance} tokens`;
+        }
+        catch (error) {
+            return `Error checking allowance: ${error}`;
+        }
+    }
     /**
      * Gets the contract address for a token symbol on the current network.
      *
@@ -166,7 +226,7 @@ __decorate([
 It takes the following inputs:
 - amount: The amount to transfer in whole units (e.g. 10.5 USDC)
 - tokenAddress: The contract address of the token to transfer
-- destinationAddress: Where to send the funds (can be an onchain address, ENS 'example.eth', or Basename 'example.base.eth')
+- destinationAddress: The address to send the funds to
 Important notes:
 - Never assume token or destination addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
 `,
@@ -176,6 +236,48 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], ERC20ActionProvider.prototype, "transfer", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "approve",
+        description: `
+This tool will approve a spender to transfer ERC20 tokens from the wallet.
+
+It takes the following inputs:
+- amount: The amount to approve in whole units (e.g. 100 for 100 USDC)
+- tokenAddress: The contract address of the token to approve
+- spenderAddress: The spender address to approve
+
+Important notes:
+- This will overwrite any existing allowance
+- To revoke an allowance, set the amount to 0
+- Ensure you trust the spender address before approving
+- Never assume token addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
+`,
+        schema: schemas_1.ApproveSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "approve", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_allowance",
+        description: `
+This tool will get the allowance amount for a spender of an ERC20 token.
+
+It takes the following inputs:
+- tokenAddress: The contract address of the token to check allowance for
+- spenderAddress: The address to check allowance for
+
+Important notes:
+- Never assume token addresses, they have to be provided as inputs. If only token symbol is provided, use the get_token_address tool to get the token address first
+`,
+        schema: schemas_1.AllowanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "getAllowance", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "get_erc20_token_address",