@coinbase/agentkit 0.3.0 → 0.5.0

package/dist/action-providers/across/acrossActionProvider.test.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const acrossActionProvider_1 = require("./acrossActionProvider");
+const viem_1 = require("viem");
+// Mock the necessary imports and modules
+jest.mock("viem", () => {
+    return {
+        ...jest.requireActual("viem"),
+        createPublicClient: jest.fn(),
+        createWalletClient: jest.fn(() => ({
+            writeContract: jest.fn().mockResolvedValue("0xdepositTxHash"),
+        })),
+        http: jest.fn(),
+        formatUnits: jest.fn().mockImplementation((value, decimals) => {
+            // Simple mock implementation just for testing
+            if (typeof value === "bigint") {
+                if (decimals === 18) {
+                    return (Number(value) / 10 ** 18).toString();
+                }
+                return value.toString();
+            }
+            return value.toString();
+        }),
+        parseUnits: jest.fn().mockImplementation((value, decimals) => {
+            if (decimals === 18) {
+                return BigInt(Number(value) * 10 ** 18);
+            }
+            return BigInt(value);
+        }),
+    };
+});
+jest.mock("viem/accounts", () => ({
+    privateKeyToAccount: jest.fn().mockReturnValue({
+        address: "0x9876543210987654321098765432109876543210",
+    }),
+}));
+// Mock the network module
+jest.mock("../../network", () => {
+    return {
+        ...jest.requireActual("../../network"),
+        NETWORK_ID_TO_VIEM_CHAIN: {
+            "ethereum-mainnet": {
+                id: 1,
+                name: "Ethereum",
+                network: "mainnet",
+            },
+            optimism: {
+                id: 10,
+                name: "Optimism",
+                network: "optimism",
+            },
+            "base-sepolia": {
+                id: 84532,
+                name: "Base Sepolia",
+                network: "base-sepolia",
+            },
+        },
+        CHAIN_ID_TO_NETWORK_ID: {
+            "1": "ethereum-mainnet",
+            "10": "optimism",
+            "84532": "base-sepolia",
+        },
+    };
+});
+// Mock the Across SDK
+const mockCreateAcrossClient = jest.fn();
+jest.mock("@across-protocol/app-sdk", () => ({
+    createAcrossClient: mockCreateAcrossClient,
+}));
+// Default implementation for the createAcrossClient mock
+const defaultClientImplementation = () => ({
+    getSupportedChains: jest.fn().mockResolvedValue([
+        {
+            chainId: 1, // Ethereum
+            name: "Ethereum",
+            network: "mainnet",
+            inputTokens: [
+                {
+                    symbol: "ETH",
+                    address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    decimals: 18,
+                },
+                {
+                    symbol: "USDC",
+                    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+                    decimals: 6,
+                },
+            ],
+        },
+        {
+            chainId: 10, // Optimism
+            name: "Optimism",
+            network: "optimism",
+            inputTokens: [
+                {
+                    symbol: "ETH",
+                    address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    decimals: 18,
+                },
+            ],
+        },
+    ]),
+    getAvailableRoutes: jest.fn().mockResolvedValue([
+        {
+            isNative: true,
+            originToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        },
+        {
+            isNative: false,
+            originToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        },
+    ]),
+    getQuote: jest.fn().mockResolvedValue({
+        deposit: {
+            inputAmount: BigInt("1000000000000000000"), // 1 ETH
+            outputAmount: BigInt("990000000000000000"), // 0.99 ETH (1% difference)
+            spokePoolAddress: "0x1234567890123456789012345678901234567890",
+        },
+        limits: {
+            minDeposit: BigInt("100000000000000000"), // 0.1 ETH
+            maxDeposit: BigInt("10000000000000000000"), // 10 ETH
+        },
+    }),
+    simulateDepositTx: jest.fn().mockResolvedValue({
+        request: {
+            address: "0x1234567890123456789012345678901234567890",
+            abi: [],
+            functionName: "deposit",
+            args: [],
+        },
+    }),
+    waitForDepositTx: jest.fn().mockResolvedValue({
+        depositId: "123456",
+    }),
+});
+// Set the default implementation
+mockCreateAcrossClient.mockImplementation(() => {
+    const client = defaultClientImplementation();
+    // Add the chains property to match what the code expects
+    return {
+        ...client,
+        chains: [
+            {
+                id: 1,
+                name: "Ethereum",
+                network: "mainnet",
+            },
+            {
+                id: 10,
+                name: "Optimism",
+                network: "optimism",
+            },
+        ],
+    };
+});
+// Mock the isTestnet function
+jest.mock("./utils", () => ({
+    isAcrossSupportedTestnet: jest.fn().mockReturnValue(false),
+}));
+describe("Across Action Provider", () => {
+    const MOCK_PRIVATE_KEY = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+    const MOCK_INPUT_TOKEN_SYMBOL = "ETH";
+    const MOCK_AMOUNT = "1.0";
+    const MOCK_DESTINATION_CHAIN_ID = "10"; // Optimism
+    const MOCK_RECIPIENT = "0x9876543210987654321098765432109876543210";
+    const MOCK_MAX_SLIPPAGE = 2.0;
+    let mockWallet;
+    let actionProvider;
+    let mockPublicClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset to default implementation
+        mockCreateAcrossClient.mockImplementation(() => {
+            const client = defaultClientImplementation();
+            // Add the chains property to match what the code expects
+            return {
+                ...client,
+                chains: [
+                    {
+                        id: 1,
+                        name: "Ethereum",
+                        network: "mainnet",
+                    },
+                    {
+                        id: 10,
+                        name: "Optimism",
+                        network: "optimism",
+                    },
+                ],
+            };
+        });
+        mockPublicClient = {
+            getBalance: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH
+            readContract: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH or 2 USDC
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({}),
+        };
+        viem_1.createPublicClient.mockReturnValue(mockPublicClient);
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_RECIPIENT),
+            sendTransaction: jest.fn().mockResolvedValue("0xmocktxhash"),
+            waitForTransactionReceipt: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                chainId: "1", // Ethereum mainnet
+                networkId: "ethereum-mainnet",
+                protocolFamily: "evm",
+            }),
+            getBalance: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH
+            readContract: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH/USDC
+        };
+        actionProvider = (0, acrossActionProvider_1.acrossActionProvider)({
+            privateKey: MOCK_PRIVATE_KEY,
+        });
+    });
+    describe("bridgeToken", () => {
+        it("should successfully bridge native ETH", async () => {
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the SDK interactions and response
+            expect(response).toContain("Successfully deposited tokens");
+            expect(response).toContain(`Token: ${MOCK_INPUT_TOKEN_SYMBOL}`);
+            expect(response).toContain("Transaction Hash for deposit: 0xdepositTxHash");
+        });
+        it("should successfully bridge ERC20 tokens", async () => {
+            const args = {
+                inputTokenSymbol: "USDC",
+                amount: "100",
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            // Set up mock for approval and deposit transactions
+            mockWallet.sendTransaction
+                .mockResolvedValueOnce("0xapprovalTxHash")
+                .mockResolvedValueOnce("0xdepositTxHash");
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the SDK interactions and response
+            expect(response).toContain("Successfully deposited tokens");
+            expect(response).toContain(`Token: ${args.inputTokenSymbol}`);
+            expect(response).toContain("Transaction Hash for approval: 0xapprovalTxHash");
+            expect(response).toContain("Transaction Hash for deposit: 0xdepositTxHash");
+        });
+        it("should fail when slippage is too high", async () => {
+            // Override the default mock with high slippage for this test only
+            mockCreateAcrossClient.mockImplementationOnce(() => ({
+                getSupportedChains: jest.fn().mockResolvedValue([
+                    {
+                        chainId: 1,
+                        inputTokens: [
+                            {
+                                symbol: "ETH",
+                                address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                                decimals: 18,
+                            },
+                        ],
+                    },
+                ]),
+                getAvailableRoutes: jest.fn().mockResolvedValue([
+                    {
+                        isNative: true,
+                        originToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    },
+                ]),
+                getQuote: jest.fn().mockResolvedValue({
+                    deposit: {
+                        inputAmount: BigInt("1000000000000000000"), // 1 ETH
+                        outputAmount: BigInt("800000000000000000"), // 0.8 ETH (20% difference)
+                        spokePoolAddress: "0x1234567890123456789012345678901234567890",
+                    },
+                    limits: {
+                        minDeposit: BigInt("100000000000000000"),
+                        maxDeposit: BigInt("10000000000000000000"),
+                    },
+                }),
+                simulateDepositTx: jest.fn().mockResolvedValue({
+                    request: {
+                        address: "0x1234567890123456789012345678901234567890",
+                        abi: [],
+                        functionName: "deposit",
+                        args: [],
+                    },
+                }),
+                waitForDepositTx: jest.fn().mockResolvedValue({
+                    depositId: "123456",
+                }),
+            }));
+            // Set a low max slippage
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: 0.5, // Only allow 0.5% slippage
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the error response
+            expect(response).toContain("Error with Across SDK");
+            expect(response).toContain("exceeds the maximum allowed slippage of 0.5%");
+        });
+        it("should handle errors in bridging", async () => {
+            const error = new Error("Insufficient balance");
+            mockWallet.getBalance.mockRejectedValueOnce(error);
+            mockWallet.sendTransaction.mockRejectedValueOnce(error);
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            expect(response).toContain("Error with Across SDK");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("checkDepositStatus", () => {
+        beforeEach(() => {
+            global.fetch = jest.fn();
+        });
+        it("should successfully check deposit status", async () => {
+            // Mock successful API response
+            const mockApiResponse = {
+                status: "filled",
+                originChainId: 1,
+                destinationChainId: 10,
+                depositTxHash: "0xdepositTxHash",
+                fillTx: "0xfillTxHash",
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockApiResponse,
+            });
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.status).toEqual("filled");
+            expect(parsedResponse.depositTxInfo.txHash).toEqual("0xdepositTxHash");
+            expect(parsedResponse.fillTxInfo.txHash).toEqual("0xfillTxHash");
+        });
+        it("should handle API errors", async () => {
+            // Mock API error
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            expect(response).toContain("Error checking deposit status");
+            expect(response).toContain("404");
+        });
+        it("should handle network errors", async () => {
+            // Mock network error
+            global.fetch.mockRejectedValueOnce(new Error("Network error"));
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            expect(response).toContain("Error checking deposit status");
+            expect(response).toContain("Network error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported networks", () => {
+            const evmNetwork = {
+                protocolFamily: "evm",
+                networkId: "ethereum",
+                chainId: "1",
+            };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+        });
+        it("should return false for unsupported networks", () => {
+            const nonEvmNetwork = {
+                protocolFamily: "solana",
+                networkId: "mainnet",
+            };
+            expect(actionProvider.supportsNetwork(nonEvmNetwork)).toBe(false);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/action-providers/across/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("./acrossActionProvider"), exports);

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for bridge token action.
+ */
+export declare const BridgeTokenSchema: z.ZodObject<{
+    destinationChainId: z.ZodString;
+    inputTokenSymbol: z.ZodDefault<z.ZodString>;
+    amount: z.ZodString;
+    recipient: z.ZodOptional<z.ZodString>;
+    maxSplippage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    destinationChainId: string;
+    inputTokenSymbol: string;
+    maxSplippage: number;
+    recipient?: string | undefined;
+}, {
+    amount: string;
+    destinationChainId: string;
+    inputTokenSymbol?: string | undefined;
+    recipient?: string | undefined;
+    maxSplippage?: number | undefined;
+}>;
+/**
+ * Input schema for check deposit status action.
+ */
+export declare const CheckDepositStatusSchema: z.ZodObject<{
+    originChainId: z.ZodOptional<z.ZodString>;
+    depositId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    depositId: string;
+    originChainId?: string | undefined;
+}, {
+    depositId: string;
+    originChainId?: string | undefined;
+}>;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckDepositStatusSchema = exports.BridgeTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for bridge token action.
+ */
+exports.BridgeTokenSchema = zod_1.z
+    .object({
+    destinationChainId: zod_1.z
+        .string()
+        .describe("The chain ID of the destination chain (e.g. 11155111 for ethereum-sepolia)"),
+    inputTokenSymbol: zod_1.z
+        .string()
+        .describe("The symbol of the token to bridge (e.g., 'ETH', 'WETH', 'USDC')")
+        .default("ETH"),
+    amount: zod_1.z
+        .string()
+        .describe("The amount of tokens to bridge in whole units (e.g. 1.5 WETH, 10 USDC)"),
+    recipient: zod_1.z
+        .string()
+        .optional()
+        .describe("The recipient address on the destination chain (defaults to sender)"),
+    maxSplippage: zod_1.z
+        .number()
+        .optional()
+        .describe("The maximum slippage percentage (e.g. 10 for 10%)")
+        .default(1.5),
+})
+    .strip()
+    .describe("Instructions for bridging tokens across chains using Across Protocol");
+/**
+ * Input schema for check deposit status action.
+ */
+exports.CheckDepositStatusSchema = zod_1.z
+    .object({
+    originChainId: zod_1.z
+        .string()
+        .optional()
+        .describe("The chain ID of the origin chain (defaults to the current chain)"),
+    depositId: zod_1.z
+        .string()
+        .describe("The ID of the deposit to check (returned by the bridge deposit transaction)"),
+})
+    .strip()
+    .describe("Instructions for checking the status of a deposit on Across Protocol");

package/dist/action-providers/across/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a chain ID corresponds to a testnet network supported by Across
+ *
+ * @param chainId - The blockchain network chain ID
+ * @returns true if the chain ID corresponds to a testnet network supported by Across, false otherwise
+ */
+export declare function isAcrossSupportedTestnet(chainId: number): boolean;

package/dist/action-providers/across/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAcrossSupportedTestnet = isAcrossSupportedTestnet;
+/**
+ * Checks if a chain ID corresponds to a testnet network supported by Across
+ *
+ * @param chainId - The blockchain network chain ID
+ * @returns true if the chain ID corresponds to a testnet network supported by Across, false otherwise
+ */
+function isAcrossSupportedTestnet(chainId) {
+    // List of testnet chain IDs
+    const testnetChainIds = [
+        11155111, // Sepolia
+        84532, // Base Sepolia
+        421614, // Arbitrum Sepolia
+        11155420, // Optimism Sepolia
+        919, // Mode Sepolia
+        80002, // Polygon Amoy
+        168587773, // Blast Sepolia
+        4202, // Lisk Sepolia
+        37111, // Lens Sepolia
+        1301, // Unichain Sepolia
+    ];
+    return testnetChainIds.includes(chainId);
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Base URL for the DefiLlama API
+ */
+export declare const DEFILLAMA_BASE_URL = "https://api.llama.fi";
+/**
+ * URL for the DefiLlama price API
+ */
+export declare const DEFILLAMA_PRICES_URL = "https://coins.llama.fi";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFILLAMA_PRICES_URL = exports.DEFILLAMA_BASE_URL = void 0;
+/**
+ * Base URL for the DefiLlama API
+ */
+exports.DEFILLAMA_BASE_URL = "https://api.llama.fi";
+/**
+ * URL for the DefiLlama price API
+ */
+exports.DEFILLAMA_PRICES_URL = "https://coins.llama.fi";

package/dist/action-providers/defillama/defillamaActionProvider.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { GetTokenPricesSchema, GetProtocolSchema, SearchProtocolsSchema } from "./schemas";
+/**
+ * DefiLlamaActionProvider is an action provider for DefiLlama API interactions.
+ * Provides functionality to fetch token prices, protocol information, and search protocols.
+ */
+export declare class DefiLlamaActionProvider extends ActionProvider {
+    /**
+     * Constructor for the DefiLlamaActionProvider class.
+     */
+    constructor();
+    /**
+     * Searches for protocols on DefiLlama.
+     * Note: This performs a case-insensitive search on protocol names.
+     * Returns all protocols whose names contain the search query.
+     *
+     * @param args - The protocol search parameters
+     * @returns A JSON string containing matching protocols or error message
+     */
+    searchProtocols(args: z.infer<typeof SearchProtocolsSchema>): Promise<string>;
+    /**
+     * Gets detailed information about a specific protocol.
+     * Note: Returns null if the protocol is not found.
+     * The response includes TVL, description, category, and other metadata.
+     * Time-series data is pruned to keep response size manageable.
+     *
+     * @param args - The protocol request parameters
+     * @returns A JSON string containing time-series pruned protocol information
+     */
+    getProtocol(args: z.infer<typeof GetProtocolSchema>): Promise<string>;
+    /**
+     * Gets current token prices from DefiLlama.
+     * Note: Token addresses must include chain prefix (e.g., 'ethereum:0x...')
+     * The searchWidth parameter can be used to specify a time range in minutes.
+     *
+     * @param args - The token price request parameters
+     * @returns A JSON string containing token prices or error message
+     */
+    getTokenPrices(args: z.infer<typeof GetTokenPricesSchema>): Promise<string>;
+    /**
+     * Checks if the DefiLlama action provider supports the given network.
+     * DefiLlama is network-agnostic, so this always returns true.
+     *
+     * @returns True, as DefiLlama actions are supported on all networks.
+     */
+    supportsNetwork(): boolean;
+}
+/**
+ * Creates a new instance of the DefiLlama action provider.
+ *
+ * @returns A new DefiLlamaActionProvider instance
+ */
+export declare const defillamaActionProvider: () => DefiLlamaActionProvider;