@coinbase/agentkit 0.2.3 → 0.4.0

package/dist/action-providers/defillama/utils.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("DefiLlama Utilities", () => {
+    describe("pruneGetProtocolResponse", () => {
+        it("should handle null input", () => {
+            expect((0, utils_1.pruneGetProtocolResponse)(null)).toBeNull();
+        });
+        it("should not modify objects without time-series data", () => {
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                symbol: "ABC",
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input);
+            expect(result).not.toBeNull();
+            expect(result).toEqual(input);
+        });
+        it("should prune time-series arrays", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.tvl).toHaveLength(5);
+                const resultDates = result.tvl.map(entry => entry.date);
+                const sortedDates = [...resultDates].sort((a, b) => b - a);
+                expect(resultDates).toEqual(sortedDates);
+            }
+        });
+        it("should prune nested time-series arrays in chainTvls", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                chainTvls: {
+                    Ethereum: {
+                        tvl: [...timeSeriesData],
+                        tokens: [...tokenTimeSeriesData],
+                    },
+                    Polygon: {
+                        tvl: [...timeSeriesData],
+                        tokensInUsd: [...tokenTimeSeriesData],
+                    },
+                },
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 3);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.chainTvls).toBeDefined();
+                if (result.chainTvls) {
+                    expect(result.chainTvls.Ethereum.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Ethereum.tokens).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tokensInUsd).toHaveLength(3);
+                    const ethereumTvlDates = result.chainTvls.Ethereum.tvl.map(entry => entry.date);
+                    const sortedDates = [...ethereumTvlDates].sort((a, b) => b - a);
+                    expect(ethereumTvlDates).toEqual(sortedDates);
+                }
+            }
+        });
+        it("should respect the maxEntries parameter", () => {
+            const timeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+                tokens: [...tokenTimeSeriesData],
+            };
+            const result1 = (0, utils_1.pruneGetProtocolResponse)(input, 1);
+            expect(result1).not.toBeNull();
+            if (result1) {
+                expect(result1.tvl).toHaveLength(1);
+                expect(result1.tokens).toHaveLength(1);
+            }
+            const result10 = (0, utils_1.pruneGetProtocolResponse)(input, 10);
+            expect(result10).not.toBeNull();
+            if (result10) {
+                expect(result10.tvl).toHaveLength(10);
+                expect(result10.tokens).toHaveLength(10);
+            }
+        });
+        it("should handle arrays without date property", () => {
+            const nonDateArray = Array.from({ length: 20 }, (_, i) => ({
+                value: 1000 + i,
+                name: `Item ${i}`,
+            }));
+            // Using a type assertion for this test case as it's testing a specific behavior
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...nonDateArray],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.tvl).toHaveLength(5);
+            }
+        });
+    });
+});

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

@@ -3,10 +3,6 @@ export declare const ERC721_ABI: readonly [{
         readonly internalType: "address";
         readonly name: "to";
         readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
     }];
     readonly name: "mint";
     readonly outputs: readonly [];

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

@@ -3,10 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERC721_ABI = void 0;
 exports.ERC721_ABI = [
     {
-        inputs: [
-            { internalType: "address", name: "to", type: "address" },
-            { internalType: "uint256", name: "tokenId", type: "uint256" },
-        ],
+        inputs: [{ internalType: "address", name: "to", type: "address" }],
         name: "mint",
         outputs: [],
         payable: false,

package/dist/action-providers/erc721/erc721ActionProvider.js

@@ -46,7 +46,7 @@ class Erc721ActionProvider extends actionProvider_1.ActionProvider {
             const data = (0, viem_1.encodeFunctionData)({
                 abi: constants_1.ERC721_ABI,
                 functionName: "mint",
-                args: [args.destination, 1n],
+                args: [args.destination],
             });
             const hash = await walletProvider.sendTransaction({
                 to: args.contractAddress,

package/dist/action-providers/erc721/erc721ActionProvider.test.js

@@ -34,7 +34,7 @@ describe("ERC721 Action Provider", () => {
                 data: (0, viem_1.encodeFunctionData)({
                     abi: constants_1.ERC721_ABI,
                     functionName: "mint",
-                    args: [MOCK_DESTINATION, 1n],
+                    args: [MOCK_DESTINATION],
                 }),
             });
             expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");

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

@@ -5,6 +5,7 @@ export * from "./alchemy";
 export * from "./basename";
 export * from "./cdp";
 export * from "./compound";
+export * from "./defillama";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
@@ -12,8 +13,10 @@ export * from "./jupiter";
 export * from "./pyth";
 export * from "./moonwell";
 export * from "./morpho";
+export * from "./opensea";
 export * from "./spl";
 export * from "./twitter";
 export * from "./wallet";
 export * from "./weth";
 export * from "./wow";
+export * from "./allora";

package/dist/action-providers/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./alchemy"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp"), exports);
 __exportStar(require("./compound"), exports);
+__exportStar(require("./defillama"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
@@ -28,8 +29,10 @@ __exportStar(require("./jupiter"), exports);
 __exportStar(require("./pyth"), exports);
 __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);
+__exportStar(require("./opensea"), exports);
 __exportStar(require("./spl"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./weth"), exports);
 __exportStar(require("./wow"), exports);
+__exportStar(require("./allora"), exports);

package/dist/action-providers/morpho/morphoActionProvider.js

@@ -13,11 +13,12 @@ exports.morphoActionProvider = exports.MorphoActionProvider = exports.SUPPORTED_
 const zod_1 = require("zod");
 const decimal_js_1 = require("decimal.js");
 const viem_1 = require("viem");
+const constants_1 = require("../erc20/constants");
 const actionProvider_1 = require("../actionProvider");
 const wallet_providers_1 = require("../../wallet-providers");
 const actionDecorator_1 = require("../actionDecorator");
 const utils_1 = require("../../utils");
-const constants_1 = require("./constants");
+const constants_2 = require("./constants");
 const schemas_1 = require("./schemas");
 exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
@@ -50,13 +51,19 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
             return "Error: Assets amount must be greater than 0";
         }
         try {
-            const atomicAssets = (0, viem_1.parseEther)(args.assets);
+            const decimals = await wallet.readContract({
+                address: args.tokenAddress,
+                abi: constants_1.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const atomicAssets = (0, viem_1.parseUnits)(args.assets, decimals);
             const approvalResult = await (0, utils_1.approve)(wallet, args.tokenAddress, args.vaultAddress, atomicAssets);
             if (approvalResult.startsWith("Error")) {
                 return `Error approving Morpho Vault as spender: ${approvalResult}`;
             }
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.METAMORPHO_ABI,
+                abi: constants_2.METAMORPHO_ABI,
                 functionName: "deposit",
                 args: [atomicAssets, args.receiver],
             });
@@ -84,7 +91,7 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
         }
         try {
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_1.METAMORPHO_ABI,
+                abi: constants_2.METAMORPHO_ABI,
                 functionName: "withdraw",
                 args: [BigInt(args.assets), args.receiver, args.receiver],
             });

package/dist/action-providers/morpho/morphoActionProvider.test.js

@@ -11,6 +11,7 @@ const MOCK_RECEIVER_ID = "0x9876543210987654321098765432109876543210";
 const MOCK_TOKEN_ADDRESS = "0x4200000000000000000000000000000000000006";
 const MOCK_TX_HASH = "0xabcdef1234567890";
 const MOCK_RECEIPT = { status: 1, blockNumber: 1234567 };
+const MOCK_DECIMALS = 18;
 jest.mock("../../utils");
 const mockApprove = utils_1.approve;
 describe("Morpho Action Provider", () => {
@@ -22,6 +23,7 @@ describe("Morpho Action Provider", () => {
             getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "1" }),
             sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
             waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+            readContract: jest.fn().mockResolvedValue(MOCK_DECIMALS),
         };
         mockApprove.mockResolvedValue("Approval successful");
     });

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

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

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

package/dist/action-providers/opensea/openseaActionProvider.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { ListNftSchema, GetNftsByAccountSchema } from "./schemas";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Configuration options for the OpenseaActionProvider.
+ */
+export interface OpenseaActionProviderConfig {
+    /**
+     * OpenSea API Key.
+     */
+    apiKey?: string;
+    /**
+     * The network ID to use for the OpenseaActionProvider.
+     */
+    networkId?: string;
+    /**
+     * The private key to use for the OpenseaActionProvider.
+     */
+    privateKey?: string;
+}
+/**
+ * OpenseaActionProvider is an action provider for OpenSea marketplace interactions.
+ */
+export declare class OpenseaActionProvider extends ActionProvider<EvmWalletProvider> {
+    private readonly apiKey;
+    private walletWithProvider;
+    private openseaSDK;
+    private openseaBaseUrl;
+    /**
+     * Constructor for the OpenseaActionProvider class.
+     *
+     * @param config - The configuration options for the OpenseaActionProvider.
+     */
+    constructor(config?: OpenseaActionProviderConfig);
+    /**
+     * Lists an NFT for sale on OpenSea.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A message containing the listing details.
+     */
+    listNft(args: z.infer<typeof ListNftSchema>): Promise<string>;
+    /**
+     * Fetch NFTs of a specific wallet address.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the NFTs or error message
+     */
+    getNftsByAccount(args: z.infer<typeof GetNftsByAccountSchema>): Promise<string>;
+    /**
+     * Checks if the Opensea action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Opensea action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const openseaActionProvider: (config?: OpenseaActionProviderConfig) => OpenseaActionProvider;

package/dist/action-providers/opensea/openseaActionProvider.js

@@ -0,0 +1,146 @@
+"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.openseaActionProvider = exports.OpenseaActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const opensea_js_1 = require("opensea-js");
+const network_1 = require("../../network");
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+/**
+ * OpenseaActionProvider is an action provider for OpenSea marketplace interactions.
+ */
+class OpenseaActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the OpenseaActionProvider class.
+     *
+     * @param config - The configuration options for the OpenseaActionProvider.
+     */
+    constructor(config = {}) {
+        super("opensea", []);
+        /**
+         * Checks if the Opensea action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Opensea action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.chainId !== undefined && utils_1.supportedChains[network.chainId] !== undefined;
+        const apiKey = config.apiKey || process.env.OPENSEA_API_KEY;
+        if (!apiKey) {
+            throw new Error("OPENSEA_API_KEY is not configured.");
+        }
+        this.apiKey = apiKey;
+        const chainId = network_1.NETWORK_ID_TO_CHAIN_ID[config.networkId || "base-sepolia"];
+        const provider = ethers_1.ethers.getDefaultProvider(parseInt(chainId));
+        const walletWithProvider = new ethers_1.Wallet(config.privateKey, provider);
+        this.walletWithProvider = walletWithProvider;
+        const openseaSDK = new opensea_js_1.OpenSeaSDK(walletWithProvider, {
+            chain: (0, utils_1.chainIdToOpenseaChain)(chainId),
+            apiKey: this.apiKey,
+        });
+        this.openseaSDK = openseaSDK;
+        this.openseaBaseUrl = this.openseaSDK.api.apiBaseUrl.replace("-api", "").replace("api", "");
+    }
+    /**
+     * Lists an NFT for sale on OpenSea.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A message containing the listing details.
+     */
+    async listNft(args) {
+        try {
+            const expirationTime = Math.round(Date.now() / 1000 + args.expirationDays * 24 * 60 * 60);
+            await this.openseaSDK.createListing({
+                asset: {
+                    tokenId: args.tokenId,
+                    tokenAddress: args.contractAddress,
+                },
+                startAmount: args.price,
+                quantity: 1,
+                paymentTokenAddress: "0x0000000000000000000000000000000000000000", // ETH
+                expirationTime,
+                accountAddress: this.walletWithProvider.address,
+            });
+            const listingLink = `${this.openseaBaseUrl}/assets/${this.openseaSDK.chain}/${args.contractAddress}/${args.tokenId}`;
+            return `Successfully listed NFT ${args.contractAddress} token ${args.tokenId} for ${args.price} ETH, expiring in ${args.expirationDays} days. Listing on OpenSea: ${listingLink}.`;
+        }
+        catch (error) {
+            return `Error listing NFT ${args.contractAddress} token ${args.tokenId} for ${args.price} ETH using account ${this.walletWithProvider.address}: ${error}`;
+        }
+    }
+    /**
+     * Fetch NFTs of a specific wallet address.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the NFTs or error message
+     */
+    async getNftsByAccount(args) {
+        try {
+            const address = args.accountAddress || this.walletWithProvider.address;
+            const { nfts } = await this.openseaSDK.api.getNFTsByAccount(address);
+            return JSON.stringify(nfts);
+        }
+        catch (error) {
+            const address = args.accountAddress || this.walletWithProvider.address;
+            return `Error fetching NFTs for account ${address}: ${error}`;
+        }
+    }
+}
+exports.OpenseaActionProvider = OpenseaActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "list_nft",
+        description: `
+This tool will list an NFT for sale on the OpenSea marketplace. 
+EVM networks are supported on mainnet and testnets.
+
+It takes the following inputs:
+- contractAddress: The NFT contract address to list
+- tokenId: The ID of the NFT to list
+- price: The price in ETH for which the NFT will be listed
+- expirationDays: (Optional) Number of days the listing should be active for (default: 90)
+
+Important notes:
+- The wallet must own the NFT
+- Price is in ETH (e.g., 1.5 for 1.5 ETH). This is the amount the seller will receive if the NFT is sold. It is not required to have this amount in the wallet.
+- Listing the NFT requires approval for OpenSea to manage the entire NFT collection:  
+  - If the collection is not already approved, an onchain transaction is required, which will incur gas fees.  
+  - If already approved, listing is gasless and does not require any onchain transaction. 
+  - EVM networks are supported on mainnet and testnets, for example: base-mainnet and base-sepolia.
+  `,
+        schema: schemas_1.ListNftSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], OpenseaActionProvider.prototype, "listNft", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_nfts_by_account",
+        description: `
+This tool will fetch NFTs owned by a specific wallet address on OpenSea.
+
+It takes the following inputs:
+- accountAddress: (Optional) The wallet address to fetch NFTs for. If not provided, uses the connected wallet address.
+
+The tool will return a JSON string containing the NFTs owned by the specified address.
+    `,
+        schema: schemas_1.GetNftsByAccountSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], OpenseaActionProvider.prototype, "getNftsByAccount", null);
+const openseaActionProvider = (config) => new OpenseaActionProvider(config);
+exports.openseaActionProvider = openseaActionProvider;

package/dist/action-providers/opensea/openseaActionProvider.test.d.ts

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