@coinbase/agentkit 0.6.1 → 0.7.0

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.test.js

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vaultsfyiActionProvider_1 = require("./vaultsfyiActionProvider");
+const constants_1 = require("./constants");
+const mockFetchResult = (status, data) => {
+    return {
+        json: async () => data,
+        status,
+        ok: status >= 200 && status < 300,
+    };
+};
+const mockVault = (num) => ({
+    apiResult: {
+        address: `0x${num.toString(16).padStart(40, "0")}`,
+        network: `network-${num}`,
+        name: `vault-${num}`,
+        protocol: `protocol-${num}`,
+        token: {
+            name: `token-${num}`,
+            assetAddress: `0x${num.toString(16).padStart(40, "0")}`,
+            symbol: `T${num}`,
+            decimals: 18,
+        },
+        tvlDetails: {
+            tvlUsd: num.toString(),
+        },
+        apy: {
+            base: {
+                "7day": num * 100,
+            },
+            rewards: {
+                "7day": num * 100,
+            },
+            total: {
+                "7day": num * 100,
+            },
+        },
+        isTransactional: true,
+    },
+    transformedResult: {
+        name: `vault-${num}`,
+        address: `0x${num.toString(16).padStart(40, "0")}`,
+        network: `network-${num}`,
+        protocol: `protocol-${num}`,
+        tvlInUsd: num,
+        token: {
+            name: `token-${num}`,
+            address: `0x${num.toString(16).padStart(40, "0")}`,
+            symbol: `T${num}`,
+        },
+        apy: {
+            base: num,
+            rewards: num,
+            total: num,
+        },
+        link: `https://app.vaults.fyi/opportunity/network-${num}/0x${num.toString(16).padStart(40, "0")}`,
+    },
+});
+const MOCK_TX_HASH = "0xmock-hash";
+describe("VaultsfyiActionProvider", () => {
+    const provider = new vaultsfyiActionProvider_1.VaultsfyiActionProvider({ apiKey: "test-api-key" });
+    let mockWalletProvider;
+    let mockedFetch;
+    const originalFetch = global.fetch;
+    beforeAll(() => {
+        global.fetch = mockedFetch = jest.fn();
+    });
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn(),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "test-network",
+            }),
+            nativeTransfer: jest.fn(),
+            readContract: jest.fn(() => Promise.resolve(18)), // token decimals
+            sendTransaction: jest.fn(() => Promise.resolve(MOCK_TX_HASH)),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    describe("network support", () => {
+        it("should support all vaultsfyi networks", () => {
+            Object.keys(constants_1.VAULTSFYI_SUPPORTED_CHAINS).forEach(network => {
+                expect(provider.supportsNetwork({
+                    protocolFamily: "evm",
+                    chainId: network,
+                })).toBe(true);
+            });
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                chainId: "some-other-chain",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("vaults action", () => {
+        it("should return a transformed vault", async () => {
+            const mockedVault = mockVault(1);
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: [mockedVault.apiResult] }));
+            const args = {};
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 1,
+                nextPage: false,
+                results: [mockedVault.transformedResult],
+            });
+        });
+        it("should filter by protocol", async () => {
+            const mockedVaults = [mockVault(1), mockVault(2)];
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+            const args = { protocol: "protocol-1" };
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 1,
+                nextPage: false,
+                results: [mockedVaults[0].transformedResult],
+            });
+        });
+        it("should take a limit", async () => {
+            const mockedVaults = [mockVault(1), mockVault(2)];
+            mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+            const args = { take: 1 };
+            const result = await provider.vaults(mockWalletProvider, args);
+            expect(JSON.parse(result)).toStrictEqual({
+                totalResults: 2,
+                nextPage: true,
+                results: [mockedVaults[0].transformedResult],
+            });
+        });
+        describe("sorting", () => {
+            it("should sort by TVL", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = { sort: { field: "tvl", direction: "asc" } };
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+            it("should sort by APY", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = { sort: { field: "apy", direction: "asc" } };
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+            it("should sort by name by default", async () => {
+                const mockedVaults = [mockVault(2), mockVault(1)];
+                mockedFetch.mockResolvedValue(mockFetchResult(200, { data: mockedVaults.map(v => v.apiResult) }));
+                const args = {};
+                const result = await provider.vaults(mockWalletProvider, args);
+                expect(JSON.parse(result)).toStrictEqual({
+                    totalResults: 2,
+                    nextPage: false,
+                    results: [mockedVaults[1].transformedResult, mockedVaults[0].transformedResult],
+                });
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {};
+            expect(await provider.vaults(mockWalletProvider, args)).toBe("Failed to fetch vaults: Internal Server Error, some more info");
+        });
+    });
+    describe("deposit action", () => {
+        it("should execute deposit", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.deposit(mockWalletProvider, args);
+            expect(response).toBe("Deposit successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should execute multiple transactions", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                    {
+                        tx: {
+                            to: "0x789",
+                            data: "0xabc",
+                            value: "2",
+                            chainId: 1,
+                        },
+                        description: "Deposit to vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.deposit(mockWalletProvider, args);
+            expect(response).toBe("Deposit successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x789",
+                data: "0xabc",
+                value: 2n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.deposit(mockWalletProvider, args)).toBe("Failed to fetch deposit transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("redeem action", () => {
+        it("should execute redeem", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Redeem from vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.redeem(mockWalletProvider, args);
+            expect(response).toBe("Redeem successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.redeem(mockWalletProvider, args)).toBe("Failed to fetch redeem transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("claim rewards action", () => {
+        it("should execute claim rewards", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                currentActionIndex: 0,
+                actions: [
+                    {
+                        tx: {
+                            to: "0x123",
+                            data: "0x456",
+                            value: "1",
+                            chainId: 1,
+                        },
+                        description: "Claim rewards from vault",
+                    },
+                ],
+            }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            const response = await provider.claim(mockWalletProvider, args);
+            expect(response).toBe("Claim successful");
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledWith({
+                to: "0x123",
+                data: "0x456",
+                value: 1n,
+                chainId: 1,
+            });
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123",
+                assetAddress: "0x456",
+                network: "mainnet",
+                amount: 1,
+            };
+            expect(await provider.claim(mockWalletProvider, args)).toBe("Failed to fetch claim transactions: Internal Server Error, some more info");
+        });
+    });
+    describe("wallet balances action", () => {
+        it("should strip and transform balances correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                mainnet: [
+                    {
+                        address: "0x123",
+                        name: "token-1",
+                        symbol: "T1",
+                        balance: (10 ** 18).toString(),
+                        decimals: 18,
+                        somethingElse: "should be stripped",
+                    },
+                ],
+            }));
+            const response = await provider.balances(mockWalletProvider);
+            expect(JSON.parse(response)).toStrictEqual({
+                mainnet: [
+                    {
+                        address: "0x123",
+                        name: "token-1",
+                        symbol: "T1",
+                        balance: 1,
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            expect(await provider.balances(mockWalletProvider)).toBe("Failed to fetch wallet balances: Internal Server Error, some more info");
+        });
+    });
+    describe("wallet positions action", () => {
+        it("should strip and transform positions correctly", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(200, {
+                mainnet: [
+                    {
+                        vaultName: "vault-1",
+                        vaultAddress: "0x123",
+                        asset: {
+                            assetAddress: "0x456",
+                            name: "token-1",
+                            symbol: "T1",
+                            decimals: 18,
+                        },
+                        balanceNative: (10 ** 18).toString(),
+                        balanceLp: (10 ** 18).toString(),
+                        unclaimedUsd: "100",
+                        apy: {
+                            base: 100,
+                            rewards: 100,
+                            total: 100,
+                        },
+                    },
+                ],
+            }));
+            const response = await provider.positions(mockWalletProvider);
+            expect(JSON.parse(response)).toStrictEqual({
+                mainnet: [
+                    {
+                        name: "vault-1",
+                        vaultAddress: "0x123",
+                        asset: {
+                            address: "0x456",
+                            name: "token-1",
+                            symbol: "T1",
+                        },
+                        underlyingTokenBalance: 1,
+                        lpTokenBalance: 1,
+                        unclaimedRewards: true,
+                        apy: {
+                            base: 1,
+                            rewards: 1,
+                            total: 1,
+                        },
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: Internal Server Error, some more info");
+        });
+    });
+});

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

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

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

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * Input schema for get CAB action.
+ */
+export declare const GetCABSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"networkFilter">;
+    tokenTickers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    networks: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "networkFilter";
+    networks: number[];
+    tokenTickers?: string[] | undefined;
+}, {
+    type: "networkFilter";
+    networks: number[];
+    tokenTickers?: string[] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"networkType">;
+    tokenTickers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    networkType: z.ZodEnum<["mainnet", "testnet"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "networkType";
+    networkType: "testnet" | "mainnet";
+    tokenTickers?: string[] | undefined;
+}, {
+    type: "networkType";
+    networkType: "testnet" | "mainnet";
+    tokenTickers?: string[] | undefined;
+}>]>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCABSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for get CAB action.
+ */
+exports.GetCABSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("networkFilter"),
+        tokenTickers: zod_1.z.array(zod_1.z.string()).optional(),
+        networks: zod_1.z.array(zod_1.z.number()).describe("The networks to get the balance for."),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("networkType"),
+        tokenTickers: zod_1.z.array(zod_1.z.string()).optional(),
+        networkType: zod_1.z
+            .enum(["mainnet", "testnet"])
+            .describe("The type of network to get the balance for."),
+    }),
+]);

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.d.ts

@@ -0,0 +1,32 @@
+import { ZeroDevWalletProvider } from "../../wallet-providers";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { GetCABSchema } from "./schemas";
+import { z } from "zod";
+/**
+ * ZeroDevWalletActionProvider is an action provider for ZeroDevWalletProvider.
+ *
+ * This provider is used for any action that requires a ZeroDevWalletProvider.
+ */
+export declare class ZeroDevWalletActionProvider extends ActionProvider<ZeroDevWalletProvider> {
+    /**
+     * Constructs a new ZeroDevWalletActionProvider.
+     */
+    constructor();
+    /**
+     * Gets the chain abstracted balance for the wallet.
+     *
+     * @param walletProvider - The wallet provider to get the balance for.
+     * @param args - The arguments for the action.
+     * @returns The chain abstracted balance for the wallet.
+     */
+    getCAB(walletProvider: ZeroDevWalletProvider, args: z.infer<typeof GetCABSchema>): Promise<import("@zerodev/intent").GetCABResult>;
+    /**
+     * Checks if the ZeroDevWalletActionProvider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the ZeroDevWalletActionProvider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const zeroDevWalletActionProvider: () => ZeroDevWalletActionProvider;

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.js

@@ -0,0 +1,66 @@
+"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.zeroDevWalletActionProvider = exports.ZeroDevWalletActionProvider = void 0;
+const wallet_providers_1 = require("../../wallet-providers");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const zod_1 = require("zod");
+/**
+ * ZeroDevWalletActionProvider is an action provider for ZeroDevWalletProvider.
+ *
+ * This provider is used for any action that requires a ZeroDevWalletProvider.
+ */
+class ZeroDevWalletActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructs a new ZeroDevWalletActionProvider.
+     */
+    constructor() {
+        super("zeroDevWallet", []);
+        /**
+         * Checks if the ZeroDevWalletActionProvider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the ZeroDevWalletActionProvider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+    }
+    /**
+     * Gets the chain abstracted balance for the wallet.
+     *
+     * @param walletProvider - The wallet provider to get the balance for.
+     * @param args - The arguments for the action.
+     * @returns The chain abstracted balance for the wallet.
+     */
+    async getCAB(walletProvider, args) {
+        return walletProvider.getCAB(args);
+    }
+}
+exports.ZeroDevWalletActionProvider = ZeroDevWalletActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_cab",
+        description: `This tool retrieves the chain abstracted balance (CAB) for specified tokens across multiple networks. 
+It takes the following inputs:
+- tokenTickers: An array of token symbols (e.g., ["ETH", "USDC"]) to get balances for
+- networks (optional): An array of network IDs to check balances on. If not provided, will check all supported networks
+- networkType (optional): Filter networks by type ("mainnet" or "testnet"). If not provided, will check both types
+
+The tool will return the aggregated balance across all specified networks for each token ticker. This is useful for getting a complete picture of a wallet's holdings across different chains in a single call.`,
+        schema: schemas_1.GetCABSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.ZeroDevWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZeroDevWalletActionProvider.prototype, "getCAB", null);
+const zeroDevWalletActionProvider = () => new ZeroDevWalletActionProvider();
+exports.zeroDevWalletActionProvider = zeroDevWalletActionProvider;

package/dist/action-providers/zerodev/zeroDevWalletActionProvider.test.d.ts

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