@coinbase/agentkit 0.0.0-nightly-20250328174338

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/action-providers/pyth/index.d.ts

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

package/dist/action-providers/pyth/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("./pythActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

package/dist/action-providers/pyth/pythActionProvider.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { PythFetchPriceFeedIDSchema, PythFetchPriceSchema } from "./schemas";
+/**
+ * PythActionProvider is an action provider for Pyth.
+ */
+export declare class PythActionProvider extends ActionProvider {
+    /**
+     * Constructs a new PythActionProvider.
+     */
+    constructor();
+    /**
+     * Fetch the price feed ID for a given token symbol from Pyth.
+     *
+     * @param args - The arguments for the action.
+     * @returns The price feed ID as a string.
+     */
+    fetchPriceFeed(args: z.infer<typeof PythFetchPriceFeedIDSchema>): Promise<string>;
+    /**
+     * Fetches the price from Pyth given a Pyth price feed ID.
+     *
+     * @param args - The arguments for the action.
+     * @returns The price as a string.
+     */
+    fetchPrice(args: z.infer<typeof PythFetchPriceSchema>): Promise<string>;
+    /**
+     * Checks if the Pyth action provider supports the given network.
+     *
+     * @returns True if the Pyth action provider supports the network, false otherwise.
+     */
+    supportsNetwork: () => boolean;
+}
+export declare const pythActionProvider: () => PythActionProvider;

package/dist/action-providers/pyth/pythActionProvider.js

@@ -0,0 +1,121 @@
+"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.pythActionProvider = exports.PythActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+/**
+ * PythActionProvider is an action provider for Pyth.
+ */
+class PythActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructs a new PythActionProvider.
+     */
+    constructor() {
+        super("pyth", []);
+        /**
+         * Checks if the Pyth action provider supports the given network.
+         *
+         * @returns True if the Pyth action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = () => true;
+    }
+    /**
+     * Fetch the price feed ID for a given token symbol from Pyth.
+     *
+     * @param args - The arguments for the action.
+     * @returns The price feed ID as a string.
+     */
+    async fetchPriceFeed(args) {
+        const url = `https://hermes.pyth.network/v2/price_feeds?query=${args.tokenSymbol}&asset_type=crypto`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        if (data.length === 0) {
+            throw new Error(`No price feed found for ${args.tokenSymbol}`);
+        }
+        const filteredData = data.filter(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (item) => item.attributes.base.toLowerCase() === args.tokenSymbol.toLowerCase());
+        if (filteredData.length === 0) {
+            throw new Error(`No price feed found for ${args.tokenSymbol}`);
+        }
+        return filteredData[0].id;
+    }
+    /**
+     * Fetches the price from Pyth given a Pyth price feed ID.
+     *
+     * @param args - The arguments for the action.
+     * @returns The price as a string.
+     */
+    async fetchPrice(args) {
+        const url = `https://hermes.pyth.network/v2/updates/price/latest?ids[]=${args.priceFeedID}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        const parsedData = data.parsed;
+        if (parsedData.length === 0) {
+            throw new Error(`No price data found for ${args.priceFeedID}`);
+        }
+        const priceInfo = parsedData[0].price;
+        const price = BigInt(priceInfo.price);
+        const exponent = priceInfo.expo;
+        if (exponent < 0) {
+            const adjustedPrice = price * BigInt(100);
+            const divisor = BigInt(10) ** BigInt(-exponent);
+            const scaledPrice = adjustedPrice / BigInt(divisor);
+            const priceStr = scaledPrice.toString();
+            const formattedPrice = `${priceStr.slice(0, -2)}.${priceStr.slice(-2)}`;
+            return formattedPrice.startsWith(".") ? `0${formattedPrice}` : formattedPrice;
+        }
+        const scaledPrice = price / BigInt(10) ** BigInt(exponent);
+        return scaledPrice.toString();
+    }
+}
+exports.PythActionProvider = PythActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "fetch_price_feed",
+        description: "Fetch the price feed ID for a given token symbol from Pyth.",
+        schema: schemas_1.PythFetchPriceFeedIDSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], PythActionProvider.prototype, "fetchPriceFeed", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "fetch_price",
+        description: `Fetch the price of a given price feed from Pyth.
+
+Inputs:
+- Pyth price feed ID
+
+Important notes:
+- Do not assume that a random ID is a Pyth price feed ID. If you are confused, ask a clarifying question.
+- This action only fetches price inputs from Pyth price feeds. No other source.
+- If you are asked to fetch the price from Pyth for a ticker symbol such as BTC, you must first use the pyth_fetch_price_feed_id
+action to retrieve the price feed ID before invoking the pyth_Fetch_price action
+`,
+        schema: schemas_1.PythFetchPriceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], PythActionProvider.prototype, "fetchPrice", null);
+const pythActionProvider = () => new PythActionProvider();
+exports.pythActionProvider = pythActionProvider;

package/dist/action-providers/pyth/pythActionProvider.test.d.ts

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

package/dist/action-providers/pyth/pythActionProvider.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pythActionProvider_1 = require("./pythActionProvider");
+describe("PythActionProvider", () => {
+    const fetchMock = jest.fn();
+    global.fetch = fetchMock;
+    const provider = (0, pythActionProvider_1.pythActionProvider)();
+    beforeEach(() => {
+        jest.resetAllMocks().restoreAllMocks();
+    });
+    describe("fetchPriceFeed", () => {
+        it("should return the first price feed ID that matches the input token symbol", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+            });
+            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "BTC" });
+            expect(priceFeedId).toEqual("some-price-feed-id");
+        });
+        it("should throw an error if no price feed is found", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+            });
+            await expect(provider.fetchPriceFeed({ tokenSymbol: "ETH" })).rejects.toThrow("No price feed found for ETH");
+        });
+        it("should throw an error if the response is not ok", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("HTTP error! status: 404");
+        });
+        it("should throw an error if response is ok but no data is returned", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [],
+            });
+            const provider = (0, pythActionProvider_1.pythActionProvider)();
+            await expect(provider.fetchPriceFeed({ tokenSymbol: "BTC" })).rejects.toThrow("No price feed found for BTC");
+        });
+    });
+    describe("fetchPrice", () => {
+        it("should return the price for a given price feed ID", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    parsed: [
+                        {
+                            price: {
+                                price: 100,
+                                expo: 2,
+                            },
+                        },
+                    ],
+                }),
+            });
+            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            expect(price).toEqual("1");
+        });
+        it("should return the price for a given price feed ID with a negative exponent", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    parsed: [
+                        {
+                            price: {
+                                price: 100,
+                                expo: -2,
+                            },
+                        },
+                    ],
+                }),
+            });
+            const provider = (0, pythActionProvider_1.pythActionProvider)();
+            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            expect(price).toEqual("1.00");
+        });
+        it("should handle scaled price starting with a decimal", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    parsed: [
+                        {
+                            price: {
+                                price: 25,
+                                expo: -2,
+                            },
+                        },
+                    ],
+                }),
+            });
+            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            expect(price).toEqual("0.25");
+        });
+        it("should throw an error if there is no price data", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    parsed: [],
+                }),
+            });
+            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("No price data found for some-price-feed-id");
+        });
+        it("should throw an error if response is not ok", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+            await expect(provider.fetchPrice({ priceFeedID: "some-price-feed-id" })).rejects.toThrow("HTTP error! status: 404");
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+/**
+ * Input schema for Pyth fetch price feed ID action.
+ */
+export declare const PythFetchPriceFeedIDSchema: z.ZodObject<{
+    tokenSymbol: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    tokenSymbol: string;
+}, {
+    tokenSymbol: string;
+}>;
+/**
+ * Input schema for Pyth fetch price action.
+ */
+export declare const PythFetchPriceSchema: z.ZodObject<{
+    priceFeedID: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    priceFeedID: string;
+}, {
+    priceFeedID: string;
+}>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythFetchPriceSchema = exports.PythFetchPriceFeedIDSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for Pyth fetch price feed ID action.
+ */
+exports.PythFetchPriceFeedIDSchema = zod_1.z
+    .object({
+    tokenSymbol: zod_1.z.string().describe("The token symbol to fetch the price feed ID for"),
+})
+    .strict();
+/**
+ * Input schema for Pyth fetch price action.
+ */
+exports.PythFetchPriceSchema = zod_1.z
+    .object({
+    priceFeedID: zod_1.z.string().describe("The price feed ID to fetch the price for"),
+})
+    .strict();

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

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