@coinbase/agentkit 0.2.3 → 0.3.0

package/README.md

@@ -248,6 +248,19 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Opensea</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>list_nft</code></td>
+    <td width="768">Lists an NFT for sale on OpenSea.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_nfts_by_account</code></td>
+    <td width="768">Fetches NFTs owned by a specific wallet address on OpenSea.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Pyth</strong></summary>
 <table width="100%">
 <tr>

package/dist/action-providers/allora/alloraActionProvider.d.ts

@@ -0,0 +1,44 @@
+import { ActionProvider } from "../actionProvider";
+import { AlloraAPIClientConfig } from "@alloralabs/allora-sdk";
+import { z } from "zod";
+import { GetAllTopicsSchema, GetInferenceByTopicIdSchema, GetPriceInferenceSchema } from "./schemas";
+/**
+ * Action provider for interacting with Allora Network
+ */
+export declare class AlloraActionProvider extends ActionProvider {
+    private client;
+    /**
+     * Creates an instance of AlloraActionProvider
+     *
+     * @param config - Configuration for the Allora API client including API key and optional chain slug
+     */
+    constructor(config?: AlloraAPIClientConfig);
+    /**
+     * Gets all available topics from Allora Network
+     *
+     * @param _ - Empty object as no parameters are required
+     * @returns A string containing the list of topics in JSON format
+     */
+    getAllTopics(_: z.infer<typeof GetAllTopicsSchema>): Promise<string>;
+    /**
+     * Gets inference data for a specific topic from Allora Network
+     *
+     * @param args - Object containing the topic ID to get inference for
+     * @returns A string containing the inference data in JSON format
+     */
+    getInferenceByTopicId(args: z.infer<typeof GetInferenceByTopicIdSchema>): Promise<string>;
+    /**
+     * Gets price inference for a token/timeframe pair from Allora Network
+     *
+     * @param args - Object containing the asset symbol and timeframe
+     * @returns A string containing the price inference data in JSON format
+     */
+    getPriceInference(args: z.infer<typeof GetPriceInferenceSchema>): Promise<string>;
+    /**
+     * Checks if the provider supports a given network
+     *
+     * @returns Always returns true as Allora service is network-agnostic
+     */
+    supportsNetwork(): boolean;
+}
+export declare const alloraActionProvider: (config?: AlloraAPIClientConfig) => AlloraActionProvider;

package/dist/action-providers/allora/alloraActionProvider.js

@@ -0,0 +1,195 @@
+"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.alloraActionProvider = exports.AlloraActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const allora_sdk_1 = require("@alloralabs/allora-sdk");
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+/**
+ * Action provider for interacting with Allora Network
+ */
+class AlloraActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates an instance of AlloraActionProvider
+     *
+     * @param config - Configuration for the Allora API client including API key and optional chain slug
+     */
+    constructor(config = {}) {
+        super("allora", []);
+        // This is a public, development only key and should be used for testing purposes only.
+        // It might be changed or revoked in the future. It is also subject to limits and usage policies.
+        const DEFAULT_API_KEY = "UP-4151d0cc489a44a7aa5cd7ef";
+        config.apiKey = config.apiKey || DEFAULT_API_KEY;
+        config.chainSlug = config.chainSlug || allora_sdk_1.ChainSlug.TESTNET;
+        this.client = new allora_sdk_1.AlloraAPIClient(config);
+    }
+    /**
+     * Gets all available topics from Allora Network
+     *
+     * @param _ - Empty object as no parameters are required
+     * @returns A string containing the list of topics in JSON format
+     */
+    async getAllTopics(_) {
+        try {
+            const topics = await this.client.getAllTopics();
+            const topicsJson = JSON.stringify(topics);
+            return `The available topics at Allora Network are:\n ${topicsJson}`;
+        }
+        catch (error) {
+            return `Error getting all topics: ${error}`;
+        }
+    }
+    /**
+     * Gets inference data for a specific topic from Allora Network
+     *
+     * @param args - Object containing the topic ID to get inference for
+     * @returns A string containing the inference data in JSON format
+     */
+    async getInferenceByTopicId(args) {
+        try {
+            const inference = await this.client.getInferenceByTopicID(args.topicId);
+            const inferenceJson = JSON.stringify(inference.inference_data);
+            return `The inference for topic ${args.topicId} is:\n ${inferenceJson}`;
+        }
+        catch (error) {
+            return `Error getting inference for topic ${args.topicId}: ${error}`;
+        }
+    }
+    /**
+     * Gets price inference for a token/timeframe pair from Allora Network
+     *
+     * @param args - Object containing the asset symbol and timeframe
+     * @returns A string containing the price inference data in JSON format
+     */
+    async getPriceInference(args) {
+        try {
+            const inference = await this.client.getPriceInference(args.asset, args.timeframe);
+            const response = {
+                price: inference.inference_data.network_inference_normalized,
+                timestamp: inference.inference_data.timestamp,
+                asset: args.asset,
+                timeframe: args.timeframe,
+            };
+            const inferenceJson = JSON.stringify(response);
+            return `The price inference for ${args.asset} (${args.timeframe}) is:\n${inferenceJson}`;
+        }
+        catch (error) {
+            return `Error getting price inference for ${args.asset} (${args.timeframe}): ${error}`;
+        }
+    }
+    /**
+     * Checks if the provider supports a given network
+     *
+     * @returns Always returns true as Allora service is network-agnostic
+     */
+    supportsNetwork() {
+        return true; // Allora service is network-agnostic
+    }
+}
+exports.AlloraActionProvider = AlloraActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_all_topics",
+        description: `
+This tool will get all available inference topics from Allora Network.
+
+A successful response will return a list of available topics in JSON format. Example:
+[
+    {
+        "topic_id": 1,
+        "topic_name": "Bitcoin 8h",
+        "description": "Bitcoin price prediction for the next 8 hours",
+        "epoch_length": 100,
+        "ground_truth_lag": 10,
+        "loss_method": "method1",
+        "worker_submission_window": 50,
+        "worker_count": 5,
+        "reputer_count": 3,
+        "total_staked_allo": 1000,
+        "total_emissions_allo": 500,
+        "is_active": true,
+        "updated_at": "2023-01-01T00:00:00Z"
+    }
+]
+
+Key fields:
+- topic_id: Unique identifier, use with get_inference_by_topic_id action
+- topic_name: Name of the topic
+- description: Short description of the topic's purpose
+- is_active: If true, topic is active and accepting submissions
+- updated_at: Timestamp of last update
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetAllTopicsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getAllTopics", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_inference_by_topic_id",
+        description: `
+This tool will get inference for a specific topic from Allora Network.
+It requires a topic ID as input, which can be obtained from the get_all_topics action.
+
+A successful response will return a message with the inference data in JSON format. Example:
+    {
+        "network_inference": "0.5",
+        "network_inference_normalized": "0.5",
+        "confidence_interval_percentiles": ["0.1", "0.5", "0.9"],
+        "confidence_interval_percentiles_normalized": ["0.1", "0.5", "0.9"],
+        "confidence_interval_values": ["0.1", "0.5", "0.9"],
+        "confidence_interval_values_normalized": ["0.1", "0.5", "0.9"],
+        "topic_id": "1",
+        "timestamp": 1718198400,
+        "extra_data": "extra_data"
+    }
+The network_inference field is the inference for the topic.
+The network_inference_normalized field is the normalized inference for the topic.
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetInferenceByTopicIdSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getInferenceByTopicId", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_price_inference",
+        description: `
+This tool will get price inference for a specific token and timeframe from Allora Network.
+It requires an asset symbol (e.g., 'BTC', 'ETH') and a timeframe (e.g., '8h', '24h') as input.
+
+A successful response will return a message with the price inference. Example:
+    The price inference for BTC (8h) is:
+    {
+        "price": "100000",
+        "timestamp": 1718198400,
+        "asset": "BTC",
+        "timeframe": "8h"
+    }
+
+A failure response will return an error message with details.
+`,
+        schema: schemas_1.GetPriceInferenceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlloraActionProvider.prototype, "getPriceInference", null);
+const alloraActionProvider = (config = {}) => new AlloraActionProvider(config);
+exports.alloraActionProvider = alloraActionProvider;

package/dist/action-providers/allora/alloraActionProvider.test.d.ts

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

package/dist/action-providers/allora/alloraActionProvider.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alloraActionProvider_1 = require("./alloraActionProvider");
+const allora_sdk_1 = require("@alloralabs/allora-sdk");
+jest.mock("@alloralabs/allora-sdk");
+describe("AlloraActionProvider", () => {
+    let provider;
+    const mockConfig = { apiKey: "test-api-key", chainSlug: allora_sdk_1.ChainSlug.TESTNET };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = new alloraActionProvider_1.AlloraActionProvider(mockConfig);
+    });
+    describe("getAllTopics", () => {
+        it("should return topics when successful", async () => {
+            const mockTopics = [
+                {
+                    topic_id: 1,
+                    topic_name: "Bitcoin 8h",
+                    description: "Bitcoin price prediction",
+                    epoch_length: 100,
+                    ground_truth_lag: 10,
+                    loss_method: "method1",
+                    worker_submission_window: 50,
+                    worker_count: 5,
+                    reputer_count: 3,
+                    total_staked_allo: 1000,
+                    total_emissions_allo: 500,
+                    is_active: true,
+                    updated_at: "2023-01-01T00:00:00Z",
+                },
+            ];
+            allora_sdk_1.AlloraAPIClient.prototype.getAllTopics.mockResolvedValue(mockTopics);
+            const result = await provider.getAllTopics({});
+            expect(result).toContain("The available topics at Allora Network are:");
+            expect(result).toContain(JSON.stringify(mockTopics));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getAllTopics.mockRejectedValue(error);
+            const result = await provider.getAllTopics({});
+            expect(result).toContain("Error getting all topics:");
+            expect(result).toContain(error.toString());
+        });
+    });
+    describe("getInferenceByTopicId", () => {
+        const mockTopicId = 1;
+        it("should return inference when successful", async () => {
+            const mockInferenceResponse = {
+                inference_data: {
+                    network_inference: "0.5",
+                    network_inference_normalized: "0.5",
+                    confidence_interval_percentiles: ["0.1", "0.5", "0.9"],
+                    confidence_interval_percentiles_normalized: ["0.1", "0.5", "0.9"],
+                    confidence_interval_values: ["0.1", "0.5", "0.9"],
+                    confidence_interval_values_normalized: ["0.1", "0.5", "0.9"],
+                    topic_id: "1",
+                    timestamp: 1718198400,
+                    extra_data: "extra_data",
+                },
+            };
+            allora_sdk_1.AlloraAPIClient.prototype.getInferenceByTopicID.mockResolvedValue(mockInferenceResponse);
+            const result = await provider.getInferenceByTopicId({ topicId: mockTopicId });
+            expect(result).toContain(`The inference for topic ${mockTopicId} is:`);
+            expect(result).toContain(JSON.stringify(mockInferenceResponse.inference_data));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getInferenceByTopicID.mockRejectedValue(error);
+            const result = await provider.getInferenceByTopicId({ topicId: mockTopicId });
+            expect(result).toContain(`Error getting inference for topic ${mockTopicId}:`);
+            expect(result).toContain(error.toString());
+        });
+    });
+    describe("getPriceInference", () => {
+        const mockAsset = allora_sdk_1.PriceInferenceToken.BTC;
+        const mockTimeframe = "8h";
+        it("should return price inference when successful", async () => {
+            const mockPriceInference = {
+                inference_data: {
+                    network_inference_normalized: "50000.00",
+                    timestamp: 1718198400,
+                },
+            };
+            allora_sdk_1.AlloraAPIClient.prototype.getPriceInference.mockResolvedValue(mockPriceInference);
+            const expectedResponse = {
+                price: "50000.00",
+                timestamp: 1718198400,
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            };
+            const result = await provider.getPriceInference({
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            });
+            expect(result).toContain(`The price inference for ${mockAsset} (${mockTimeframe}) is:`);
+            expect(result).toContain(JSON.stringify(expectedResponse));
+        });
+        it("should handle errors", async () => {
+            const error = new Error("API Error");
+            allora_sdk_1.AlloraAPIClient.prototype.getPriceInference.mockRejectedValue(error);
+            const result = await provider.getPriceInference({
+                asset: mockAsset,
+                timeframe: mockTimeframe,
+            });
+            expect(result).toContain(`Error getting price inference for ${mockAsset} (${mockTimeframe}):`);
+            expect(result).toContain(error.toString());
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from "./alloraActionProvider";
+export * from "./schemas";

package/dist/action-providers/allora/index.js

@@ -0,0 +1,18 @@
+"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("./alloraActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/**
+ * Input schema for getting all topics from Allora Network
+ */
+export declare const GetAllTopicsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Input schema for getting inference data by topic ID from Allora Network
+ */
+export declare const GetInferenceByTopicIdSchema: z.ZodObject<{
+    topicId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    topicId: number;
+}, {
+    topicId: number;
+}>;
+/**
+ * Input schema for getting price inference for a token/timeframe pair
+ */
+export declare const GetPriceInferenceSchema: z.ZodObject<{
+    asset: z.ZodString;
+    timeframe: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    asset: string;
+    timeframe: string;
+}, {
+    asset: string;
+    timeframe: string;
+}>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPriceInferenceSchema = exports.GetInferenceByTopicIdSchema = exports.GetAllTopicsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for getting all topics from Allora Network
+ */
+exports.GetAllTopicsSchema = zod_1.z
+    .object({})
+    .strip()
+    .describe("Instructions for getting all topics from Allora Network");
+/**
+ * Input schema for getting inference data by topic ID from Allora Network
+ */
+exports.GetInferenceByTopicIdSchema = zod_1.z
+    .object({
+    topicId: zod_1.z.number().describe("The ID of the topic to get inference data for"),
+})
+    .strip()
+    .describe("Instructions for getting inference data from Allora Network by topic ID");
+/**
+ * Input schema for getting price inference for a token/timeframe pair
+ */
+exports.GetPriceInferenceSchema = zod_1.z
+    .object({
+    asset: zod_1.z.string().describe("The token to get price inference for (e.g., 'BTC', 'ETH')"),
+    timeframe: zod_1.z.string().describe("The timeframe for the prediction (e.g., '8h', '24h')"),
+})
+    .strip()
+    .describe("Instructions for getting price inference for a token/timeframe pair");

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

@@ -12,8 +12,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

@@ -28,8 +28,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/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 {};

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opensea_js_1 = require("opensea-js");
+const openseaActionProvider_1 = require("./openseaActionProvider");
+jest.mock("opensea-js");
+describe("OpenSea Action Provider", () => {
+    const MOCK_API_KEY = "test-api-key";
+    const MOCK_PRIVATE_KEY = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+    const MOCK_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_TOKEN_ID = "1";
+    const MOCK_PRICE = 0.1;
+    const MOCK_EXPIRATION_DAYS = 90;
+    const MOCK_OPENSEA_BASE_URL = "https://testnets.opensea.io";
+    const MOCK_OPENSEA_CHAIN = "base_sepolia";
+    let actionProvider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock OpenSeaSDK constructor
+        opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+            createListing: jest.fn(),
+            api: {
+                apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                getNFTsByAccount: jest.fn(),
+            },
+            chain: MOCK_OPENSEA_CHAIN,
+        }));
+        actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+            apiKey: MOCK_API_KEY,
+            privateKey: MOCK_PRIVATE_KEY,
+            networkId: "base-sepolia",
+        });
+    });
+    describe("listNft", () => {
+        it("should successfully list an NFT", async () => {
+            const mockListing = {};
+            const mockCreateListing = jest.fn().mockResolvedValue(mockListing);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: mockCreateListing,
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                tokenId: MOCK_TOKEN_ID,
+                price: MOCK_PRICE,
+                expirationDays: MOCK_EXPIRATION_DAYS,
+            };
+            const response = await actionProvider.listNft(args);
+            expect(mockCreateListing).toHaveBeenCalledWith(expect.objectContaining({
+                asset: {
+                    tokenId: MOCK_TOKEN_ID,
+                    tokenAddress: MOCK_CONTRACT,
+                },
+                startAmount: MOCK_PRICE,
+                quantity: 1,
+            }));
+            expect(response).toBe(`Successfully listed NFT ${MOCK_CONTRACT} token ${MOCK_TOKEN_ID} for ${MOCK_PRICE} ETH, expiring in ${MOCK_EXPIRATION_DAYS} days. Listing on OpenSea: ${MOCK_OPENSEA_BASE_URL}/assets/${MOCK_OPENSEA_CHAIN}/${MOCK_CONTRACT}/${MOCK_TOKEN_ID}.`);
+        });
+        it("should handle listing errors", async () => {
+            const error = new Error("Listing failed");
+            const mockCreateListing = jest.fn().mockRejectedValue(error);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: mockCreateListing,
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                tokenId: MOCK_TOKEN_ID,
+                price: MOCK_PRICE,
+                expirationDays: MOCK_EXPIRATION_DAYS,
+            };
+            const response = await actionProvider.listNft(args);
+            expect(response).toContain(`Error listing NFT ${MOCK_CONTRACT} token ${MOCK_TOKEN_ID}`);
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("getNftsByAccount", () => {
+        const MOCK_WALLET_ADDRESS = "0xabcdef1234567890abcdef1234567890abcdef12";
+        const MOCK_NFTS = [
+            {
+                identifier: "1",
+                contract: MOCK_CONTRACT,
+                name: "Test NFT 1",
+            },
+            {
+                identifier: "2",
+                contract: MOCK_CONTRACT,
+                name: "Test NFT 2",
+            },
+        ];
+        it("should successfully fetch NFTs for the specified account", async () => {
+            const mockGetNFTsByAccount = jest.fn().mockResolvedValue({ nfts: MOCK_NFTS });
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                accountAddress: MOCK_WALLET_ADDRESS,
+            };
+            const response = await actionProvider.getNftsByAccount(args);
+            expect(mockGetNFTsByAccount).toHaveBeenCalledWith(MOCK_WALLET_ADDRESS);
+            expect(response).toBe(JSON.stringify(MOCK_NFTS));
+        });
+        it("should use connected wallet address when no account is specified", async () => {
+            const mockGetNFTsByAccount = jest.fn().mockResolvedValue({ nfts: MOCK_NFTS });
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {}; // No accountAddress provided
+            const response = await actionProvider.getNftsByAccount(args);
+            // Should use the wallet address from the provider
+            expect(mockGetNFTsByAccount).toHaveBeenCalled();
+            expect(response).toBe(JSON.stringify(MOCK_NFTS));
+        });
+        it("should handle errors when fetching NFTs", async () => {
+            const error = new Error("Failed to fetch NFTs");
+            const mockGetNFTsByAccount = jest.fn().mockRejectedValue(error);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                accountAddress: MOCK_WALLET_ADDRESS,
+            };
+            const response = await actionProvider.getNftsByAccount(args);
+            expect(mockGetNFTsByAccount).toHaveBeenCalledWith(MOCK_WALLET_ADDRESS);
+            expect(response).toContain(`Error fetching NFTs for account ${MOCK_WALLET_ADDRESS}`);
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported networks", () => {
+            const baseSepoliaNetwork = {
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+                chainId: "84532",
+            };
+            expect(actionProvider.supportsNetwork(baseSepoliaNetwork)).toBe(true);
+        });
+        it("should return false for unsupported networks", () => {
+            const fantomNetwork = {
+                protocolFamily: "bitcoin",
+                networkId: "any",
+            };
+            expect(actionProvider.supportsNetwork(fantomNetwork)).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Input schema for listing an NFT on OpenSea.
+ */
+export declare const ListNftSchema: z.ZodObject<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    price: z.ZodNumber;
+    expirationDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: string;
+    price: number;
+    tokenId: string;
+    expirationDays: number;
+}, {
+    contractAddress: string;
+    price: number;
+    tokenId: string;
+    expirationDays?: number | undefined;
+}>;
+/**
+ * Input schema for getting NFTs from a specific wallet address.
+ */
+export declare const GetNftsByAccountSchema: z.ZodObject<{
+    accountAddress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    accountAddress?: string | undefined;
+}, {
+    accountAddress?: string | undefined;
+}>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetNftsByAccountSchema = exports.ListNftSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for listing an NFT on OpenSea.
+ */
+exports.ListNftSchema = zod_1.z
+    .object({
+    contractAddress: zod_1.z.string().nonempty().describe("The NFT contract address to list"),
+    tokenId: zod_1.z.string().nonempty().describe("The tokenID of the NFT to list"),
+    price: zod_1.z.number().positive().describe("The price in ETH to list the NFT for"),
+    expirationDays: zod_1.z
+        .number()
+        .positive()
+        .optional()
+        .default(90)
+        .describe("Number of days the listing should be active for (default: 90)"),
+})
+    .strip()
+    .describe("Input schema for listing an NFT on OpenSea");
+/**
+ * Input schema for getting NFTs from a specific wallet address.
+ */
+exports.GetNftsByAccountSchema = zod_1.z
+    .object({
+    accountAddress: zod_1.z
+        .string()
+        .optional()
+        .describe("The wallet address to fetch NFTs for (defaults to connected wallet if not provided)"),
+})
+    .strip()
+    .describe("Input schema for fetching NFTs by account");

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

@@ -0,0 +1,12 @@
+import { Chain } from "opensea-js";
+/**
+ * Supported Opensea chains
+ */
+export declare const supportedChains: Record<string, Chain>;
+/**
+ * Maps EVM chain IDs to Opensea chain
+ *
+ * @param chainId - The EVM chain ID to map
+ * @returns The corresponding OpenSea Chain enum value
+ */
+export declare const chainIdToOpenseaChain: (chainId: string) => Chain;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToOpenseaChain = exports.supportedChains = void 0;
+const opensea_js_1 = require("opensea-js");
+/**
+ * Supported Opensea chains
+ */
+exports.supportedChains = {
+    "1": opensea_js_1.Chain.Mainnet,
+    "137": opensea_js_1.Chain.Polygon,
+    "80002": opensea_js_1.Chain.Amoy,
+    "11155111": opensea_js_1.Chain.Sepolia,
+    "8217": opensea_js_1.Chain.Klaytn,
+    "1001": opensea_js_1.Chain.Baobab,
+    "43114": opensea_js_1.Chain.Avalanche,
+    "43113": opensea_js_1.Chain.Fuji,
+    "42161": opensea_js_1.Chain.Arbitrum,
+    "42170": opensea_js_1.Chain.ArbitrumNova,
+    "421614": opensea_js_1.Chain.ArbitrumSepolia,
+    "238": opensea_js_1.Chain.Blast,
+    "168587773": opensea_js_1.Chain.BlastSepolia,
+    "8453": opensea_js_1.Chain.Base,
+    "84532": opensea_js_1.Chain.BaseSepolia,
+    "10": opensea_js_1.Chain.Optimism,
+    "11155420": opensea_js_1.Chain.OptimismSepolia,
+    "7777777": opensea_js_1.Chain.Zora,
+    "999999999": opensea_js_1.Chain.ZoraSepolia,
+    "1329": opensea_js_1.Chain.Sei,
+    "1328": opensea_js_1.Chain.SeiTestnet,
+    "8333": opensea_js_1.Chain.B3,
+    "1993": opensea_js_1.Chain.B3Sepolia,
+    "80094": opensea_js_1.Chain.BeraChain,
+};
+/**
+ * Maps EVM chain IDs to Opensea chain
+ *
+ * @param chainId - The EVM chain ID to map
+ * @returns The corresponding OpenSea Chain enum value
+ */
+const chainIdToOpenseaChain = (chainId) => {
+    const chain = exports.supportedChains[chainId];
+    if (!chain) {
+        throw new Error(`Unsupported chain ID on Opensea: ${chainId}`);
+    }
+    return chain;
+};
+exports.chainIdToOpenseaChain = chainIdToOpenseaChain;

package/dist/wallet-providers/cdpWalletProvider.d.ts

@@ -227,5 +227,11 @@ export declare class CdpWalletProvider extends EvmWalletProvider {
      * @returns The wallet's data.
      */
     exportWallet(): Promise<WalletData>;
+    /**
+     * Gets the wallet.
+     *
+     * @returns The wallet.
+     */
+    getWallet(): Wallet;
 }
 export {};

package/dist/wallet-providers/cdpWalletProvider.js

@@ -381,6 +381,17 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         }
         return __classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f").export();
     }
+    /**
+     * Gets the wallet.
+     *
+     * @returns The wallet.
+     */
+    getWallet() {
+        if (!__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f")) {
+            throw new Error("Wallet not initialized");
+        }
+        return __classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f");
+    }
 }
 exports.CdpWalletProvider = CdpWalletProvider;
 _CdpWalletProvider_cdpWallet = new WeakMap(), _CdpWalletProvider_address = new WeakMap(), _CdpWalletProvider_network = new WeakMap(), _CdpWalletProvider_publicClient = new WeakMap(), _CdpWalletProvider_gasLimitMultiplier = new WeakMap(), _CdpWalletProvider_feePerGasMultiplier = new WeakMap();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -25,7 +25,8 @@
     "prepack": "tsc",
     "docs": "typedoc --entryPoints ./src --entryPointStrategy expand --exclude ./src/tests/**/*.ts",
     "docs:serve": "http-server ./docs",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "generate:action-provider": "tsx ./scripts/generate-action-provider/main.ts"
   },
   "keywords": [
     "coinbase",
@@ -39,12 +40,14 @@
     "typescript"
   ],
   "dependencies": {
+    "@alloralabs/allora-sdk": "^0.1.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/server-auth": "^1.18.4",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",
     "md5": "^2.3.0",
+    "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
     "twitter-api-v2": "^1.18.2",
     "viem": "^2.22.16",
@@ -52,12 +55,20 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
+    "@types/nunjucks": "^3.2.6",
+    "@types/ora": "^3.2.0",
+    "@types/prompts": "^2.4.9",
     "@types/secp256k1": "^4.0.6",
     "http-server": "^14.1.1",
     "jest": "^29.7.0",
     "mock-fs": "^5.2.0",
+    "nunjucks": "^3.2.4",
+    "ora": "^7.0.1",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2",
     "ts-jest": "^29.2.5",
     "tsd": "^0.31.2",
+    "tsx": "^4.7.1",
     "typescript": "^5.7.2"
   },
   "exports": {