@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/actionDecorator.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_DECORATOR_KEY = void 0;
+exports.CreateAction = CreateAction;
+const wallet_providers_1 = require("../wallet-providers");
+const analytics_1 = require("../analytics");
+require("reflect-metadata");
+/**
+ * Metadata key for the action decorator
+ */
+exports.ACTION_DECORATOR_KEY = Symbol("agentkit:action");
+/**
+ * Decorator to embed metadata on class methods to indicate they are actions accessible to the agent
+ *
+ * @param params - The parameters for the action decorator
+ * @returns A decorator function
+ *
+ * @example
+ * ```typescript
+ * class MyActionProvider extends ActionProvider {
+ *   @CreateAction({ name: "my_action", description: "My action", schema: myActionSchema })
+ *   public myAction(args: z.infer<typeof myActionSchema>) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+function CreateAction(params) {
+    return (target, propertyKey, descriptor) => {
+        const prefixedActionName = `${target.constructor.name}_${params.name}`;
+        const originalMethod = descriptor.value;
+        const { isWalletProvider } = validateActionMethodArguments(target, propertyKey);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        descriptor.value = function (...args) {
+            let walletMetrics = {};
+            if (isWalletProvider) {
+                walletMetrics = {
+                    wallet_provider: args[0].getName(),
+                    wallet_address: args[0].getAddress(),
+                    network_id: args[0].getNetwork().networkId,
+                    chain_id: args[0].getNetwork().chainId,
+                    protocol_family: args[0].getNetwork().protocolFamily,
+                };
+            }
+            (0, analytics_1.sendAnalyticsEvent)({
+                name: "agent_action_invocation",
+                action: "invoke_action",
+                component: "agent_action",
+                action_name: prefixedActionName,
+                class_name: target.constructor.name,
+                method_name: propertyKey,
+                ...walletMetrics,
+            });
+            return originalMethod.apply(this, args);
+        };
+        const existingMetadata = Reflect.getMetadata(exports.ACTION_DECORATOR_KEY, target.constructor) || new Map();
+        const metaData = {
+            name: prefixedActionName,
+            description: params.description,
+            schema: params.schema,
+            invoke: descriptor.value,
+            walletProvider: isWalletProvider,
+        };
+        existingMetadata.set(propertyKey, metaData);
+        Reflect.defineMetadata(exports.ACTION_DECORATOR_KEY, existingMetadata, target.constructor);
+        return target;
+    };
+}
+/**
+ * Validates the arguments of an action method
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns An object containing the wallet provider flag
+ */
+function validateActionMethodArguments(target, propertyKey) {
+    const className = target instanceof Object ? target.constructor.name : undefined;
+    const params = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+    if (params == null) {
+        throw new Error(`Failed to get parameters for action method ${propertyKey} on class ${className}`);
+    }
+    if (params.length > 2) {
+        throw new Error(`Action method ${propertyKey} on class ${className} has more than 2 parameters`);
+    }
+    const walletProviderParam = params.find(param => {
+        if (!param || !param.prototype) {
+            return false;
+        }
+        if (param === wallet_providers_1.WalletProvider)
+            return true;
+        return param.prototype instanceof wallet_providers_1.WalletProvider;
+    });
+    return {
+        isWalletProvider: !!walletProviderParam,
+    };
+}

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

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { WalletProvider } from "../wallet-providers";
+import { Network } from "../network";
+/**
+ * Action is the interface for all actions.
+ */
+export interface Action<TActionSchema extends z.ZodSchema = z.ZodSchema> {
+    name: string;
+    description: string;
+    schema: TActionSchema;
+    invoke: (args: z.infer<TActionSchema>) => Promise<string>;
+}
+/**
+ * ActionProvider is the abstract base class for all action providers.
+ *
+ * @abstract
+ */
+export declare abstract class ActionProvider<TWalletProvider extends WalletProvider = WalletProvider> {
+    /**
+     * The name of the action provider.
+     */
+    readonly name: string;
+    /**
+     * The action providers to combine.
+     */
+    readonly actionProviders: ActionProvider<TWalletProvider>[];
+    /**
+     * The constructor for the action provider.
+     *
+     * @param name - The name of the action provider.
+     * @param actionProviders - The action providers to combine.
+     */
+    constructor(name: string, actionProviders: ActionProvider<TWalletProvider>[]);
+    /**
+     * Gets the actions of the action provider bound to the given wallet provider.
+     *
+     * @param walletProvider - The wallet provider.
+     * @returns The actions of the action provider.
+     */
+    getActions(walletProvider: TWalletProvider): Action[];
+    /**
+     * Checks if the action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the action provider supports the network, false otherwise.
+     */
+    abstract supportsNetwork(network: Network): boolean;
+}

package/dist/action-providers/actionProvider.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionProvider = void 0;
+const actionDecorator_1 = require("./actionDecorator");
+/**
+ * ActionProvider is the abstract base class for all action providers.
+ *
+ * @abstract
+ */
+class ActionProvider {
+    /**
+     * The constructor for the action provider.
+     *
+     * @param name - The name of the action provider.
+     * @param actionProviders - The action providers to combine.
+     */
+    constructor(name, 
+    // Update parameter type to match property type
+    actionProviders) {
+        this.name = name;
+        this.actionProviders = actionProviders;
+    }
+    /**
+     * Gets the actions of the action provider bound to the given wallet provider.
+     *
+     * @param walletProvider - The wallet provider.
+     * @returns The actions of the action provider.
+     */
+    getActions(walletProvider) {
+        const actions = [];
+        const actionProviders = [this, ...this.actionProviders];
+        for (const actionProvider of actionProviders) {
+            const actionsMetadataMap = Reflect.getMetadata(actionDecorator_1.ACTION_DECORATOR_KEY, actionProvider.constructor);
+            if (!actionsMetadataMap) {
+                if (!(actionProvider instanceof ActionProvider)) {
+                    console.warn(`Warning: ${actionProvider} is not an instance of ActionProvider.`);
+                }
+                else {
+                    console.warn(`Warning: ${actionProvider} has no actions.`);
+                }
+                continue;
+            }
+            for (const actionMetadata of actionsMetadataMap.values()) {
+                actions.push({
+                    name: actionMetadata.name,
+                    description: actionMetadata.description,
+                    schema: actionMetadata.schema,
+                    invoke: schemaArgs => {
+                        const args = [];
+                        if (actionMetadata.walletProvider) {
+                            args[0] = walletProvider;
+                        }
+                        args.push(schemaArgs);
+                        return actionMetadata.invoke.apply(actionProvider, args);
+                    },
+                });
+            }
+        }
+        return actions;
+    }
+}
+exports.ActionProvider = ActionProvider;

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { AlchemyTokenPricesBySymbolSchema, AlchemyTokenPricesByAddressSchema } from "./schemas";
+/**
+ * Configuration options for the AlchemyTokenPricesActionProvider.
+ */
+export interface AlchemyTokenPricesActionProviderConfig {
+    /**
+     * Alchemy API Key
+     */
+    apiKey?: string;
+}
+/**
+ * AlchemyTokenPricesActionProvider is an action provider for fetching token prices via the Alchemy Prices API.
+ * This provider enables querying current and historical token prices using symbols or addresses.
+ *
+ */
+export declare class AlchemyTokenPricesActionProvider extends ActionProvider {
+    private readonly apiKey;
+    private readonly baseUrl;
+    /**
+     * Creates a new instance of AlchemyTokenPricesActionProvider
+     *
+     * @param config - Configuration options including the API key
+     */
+    constructor(config?: AlchemyTokenPricesActionProviderConfig);
+    /**
+     * Fetch current token prices for one or more token symbols.
+     *
+     * @param args - The arguments containing an array of token symbols.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    tokenPricesBySymbol(args: z.infer<typeof AlchemyTokenPricesBySymbolSchema>): Promise<string>;
+    /**
+     * Fetch current token prices for one or more tokens identified by network and address pairs.
+     *
+     * @param args - The arguments containing an array of token network/address pairs.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    tokenPricesByAddress(args: z.infer<typeof AlchemyTokenPricesByAddressSchema>): Promise<string>;
+    /**
+     * Checks if the Alchemy Prices action provider supports the given network.
+     * Since the API works with multiple networks, this always returns true.
+     *
+     * @returns Always returns true.
+     */
+    supportsNetwork: () => boolean;
+}
+/**
+ * Factory function to create a new AlchemyTokenPricesActionProvider instance.
+ *
+ * @param config - The configuration options for the provider.
+ * @returns A new instance of AlchemyTokenPricesActionProvider.
+ */
+export declare const alchemyTokenPricesActionProvider: (config?: AlchemyTokenPricesActionProviderConfig) => AlchemyTokenPricesActionProvider;

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.js

@@ -0,0 +1,173 @@
+"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.alchemyTokenPricesActionProvider = exports.AlchemyTokenPricesActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+/**
+ * AlchemyTokenPricesActionProvider is an action provider for fetching token prices via the Alchemy Prices API.
+ * This provider enables querying current and historical token prices using symbols or addresses.
+ *
+ */
+class AlchemyTokenPricesActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates a new instance of AlchemyTokenPricesActionProvider
+     *
+     * @param config - Configuration options including the API key
+     */
+    constructor(config = {}) {
+        super("alchemyTokenPrices", []);
+        /**
+         * Checks if the Alchemy Prices action provider supports the given network.
+         * Since the API works with multiple networks, this always returns true.
+         *
+         * @returns Always returns true.
+         */
+        this.supportsNetwork = () => {
+            return true;
+        };
+        config.apiKey || (config.apiKey = process.env.ALCHEMY_API_KEY);
+        if (!config.apiKey) {
+            throw new Error("ALCHEMY_API_KEY is not configured.");
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = "https://api.g.alchemy.com/prices/v1";
+    }
+    /**
+     * Fetch current token prices for one or more token symbols.
+     *
+     * @param args - The arguments containing an array of token symbols.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    async tokenPricesBySymbol(args) {
+        try {
+            // Build query parameters: for each symbol add a separate query parameter
+            const params = new URLSearchParams();
+            for (const symbol of args.symbols) {
+                params.append("symbols", symbol);
+            }
+            const url = `${this.baseUrl}/${this.apiKey}/tokens/by-symbol?${params.toString()}`;
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            return `Successfully fetched token prices by symbol:\n${JSON.stringify(data, null, 2)}`;
+        }
+        catch (error) {
+            return `Error fetching token prices by symbol: ${error}`;
+        }
+    }
+    /**
+     * Fetch current token prices for one or more tokens identified by network and address pairs.
+     *
+     * @param args - The arguments containing an array of token network/address pairs.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    async tokenPricesByAddress(args) {
+        try {
+            const url = `${this.baseUrl}/${this.apiKey}/tokens/by-address`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(args),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            return `Successfully fetched token prices by address:\n${JSON.stringify(data, null, 2)}`;
+        }
+        catch (error) {
+            return `Error fetching token prices by address: ${error}`;
+        }
+    }
+}
+exports.AlchemyTokenPricesActionProvider = AlchemyTokenPricesActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "token_prices_by_symbol",
+        description: `
+This tool will fetch current prices for one or more tokens using their symbols via the Alchemy Prices API.
+
+A successful response will return a JSON payload similar to:
+{
+  "data": [
+    {
+      "symbol": "ETH",
+      "prices": [
+        {
+          "currency": "usd",
+          "value": "2873.490923459",
+          "lastUpdatedAt": "2025-02-03T23:46:40Z"
+        }
+      ]
+    }
+  ]
+}
+
+A failure response will return an error message with details.
+    `,
+        schema: schemas_1.AlchemyTokenPricesBySymbolSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlchemyTokenPricesActionProvider.prototype, "tokenPricesBySymbol", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "token_prices_by_address",
+        description: `
+This tool will fetch current prices for tokens using network and address pairs via the Alchemy Prices API.
+
+A successful response will return a JSON payload similar to:
+{
+  "data": [
+    {
+      "network": "eth-mainnet",
+      "address": "0xYourTokenAddress",
+      "prices": [
+        {
+          "currency": "usd",
+          "value": "1234.56",
+          "lastUpdatedAt": "2025-02-03T23:46:40Z"
+        }
+      ]
+    }
+  ]
+}
+
+A failure response will return an error message with details.
+    `,
+        schema: schemas_1.AlchemyTokenPricesByAddressSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlchemyTokenPricesActionProvider.prototype, "tokenPricesByAddress", null);
+/**
+ * Factory function to create a new AlchemyTokenPricesActionProvider instance.
+ *
+ * @param config - The configuration options for the provider.
+ * @returns A new instance of AlchemyTokenPricesActionProvider.
+ */
+const alchemyTokenPricesActionProvider = (config) => new AlchemyTokenPricesActionProvider(config);
+exports.alchemyTokenPricesActionProvider = alchemyTokenPricesActionProvider;

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.test.d.ts

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

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alchemyTokenPricesActionProvider_1 = require("./alchemyTokenPricesActionProvider");
+const MOCK_API_KEY = "alch-demo";
+// Sample responses for each action
+const MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE = {
+    data: [
+        {
+            symbol: "ETH",
+            prices: [
+                {
+                    currency: "usd",
+                    value: "2873.490923459",
+                    lastUpdatedAt: "2025-02-03T23:46:40Z",
+                },
+            ],
+        },
+    ],
+};
+const MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE = {
+    data: [
+        {
+            network: "eth-mainnet",
+            address: "0x1234567890abcdef",
+            prices: [
+                {
+                    currency: "usd",
+                    value: "1234.56",
+                    lastUpdatedAt: "2025-02-03T23:46:40Z",
+                },
+            ],
+        },
+    ],
+};
+describe("AlchemyTokenPricesActionProvider", () => {
+    let provider;
+    beforeEach(() => {
+        process.env.ALCHEMY_API_KEY = MOCK_API_KEY;
+        provider = (0, alchemyTokenPricesActionProvider_1.alchemyTokenPricesActionProvider)({ apiKey: MOCK_API_KEY });
+        jest.restoreAllMocks();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("tokenPricesBySymbol", () => {
+        it("should successfully fetch token prices by symbol", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE,
+            });
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH", "BTC"] });
+            // Verify the URL has the correct API key and query parameters.
+            const expectedUrlPart = `${provider["baseUrl"]}/${MOCK_API_KEY}/tokens/by-symbol`;
+            expect(fetchMock).toHaveBeenCalled();
+            const calledUrl = fetchMock.mock.calls[0][0];
+            expect(calledUrl).toContain(expectedUrlPart);
+            expect(calledUrl).toContain("symbols=ETH");
+            expect(calledUrl).toContain("symbols=BTC");
+            expect(response).toContain("Successfully fetched token prices by symbol");
+            expect(response).toContain(JSON.stringify(MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE, null, 2));
+        });
+        it("should handle non-ok response for token prices by symbol", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 400,
+            });
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH"] });
+            expect(response).toContain("Error fetching token prices by symbol");
+            expect(response).toContain("400");
+        });
+        it("should handle fetch error for token prices by symbol", async () => {
+            const error = new Error("Fetch error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH"] });
+            expect(response).toContain("Error fetching token prices by symbol");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("tokenPricesByAddress", () => {
+        it("should successfully fetch token prices by address", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE,
+            });
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(fetchMock).toHaveBeenCalled();
+            // Verify that fetch was called with the correct POST URL and options.
+            const expectedUrl = `${provider["baseUrl"]}/${MOCK_API_KEY}/tokens/by-address`;
+            expect(fetchMock).toHaveBeenCalledWith(expectedUrl, expect.objectContaining({
+                method: "POST",
+                headers: expect.objectContaining({
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                }),
+                body: JSON.stringify(payload),
+            }));
+            expect(response).toContain("Successfully fetched token prices by address");
+            expect(response).toContain(JSON.stringify(MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE, null, 2));
+        });
+        it("should handle non-ok response for token prices by address", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 429,
+            });
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(response).toContain("Error fetching token prices by address");
+            expect(response).toContain("429");
+        });
+        it("should handle fetch error for token prices by address", async () => {
+            const error = new Error("Fetch error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(response).toContain("Error fetching token prices by address");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should always return true", () => {
+            expect(provider.supportsNetwork()).toBe(true);
+        });
+    });
+});

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

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

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

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+/**
+ * Input schema for fetching token prices by symbol.
+ *
+ * The API expects a list of token symbols.
+ */
+export declare const AlchemyTokenPricesBySymbolSchema: z.ZodObject<{
+    symbols: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    symbols: string[];
+}, {
+    symbols: string[];
+}>;
+/**
+ * Input schema for fetching token prices by address.
+ *
+ * The API expects an object with an array of addresses, where each address contains
+ * a network identifier and a token contract address.
+ */
+export declare const AlchemyTokenPricesByAddressSchema: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodObject<{
+        network: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        network: string;
+    }, {
+        address: string;
+        network: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    addresses: {
+        address: string;
+        network: string;
+    }[];
+}, {
+    addresses: {
+        address: string;
+        network: string;
+    }[];
+}>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlchemyTokenPricesByAddressSchema = exports.AlchemyTokenPricesBySymbolSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for fetching token prices by symbol.
+ *
+ * The API expects a list of token symbols.
+ */
+exports.AlchemyTokenPricesBySymbolSchema = zod_1.z
+    .object({
+    symbols: zod_1.z
+        .array(zod_1.z.string())
+        .min(1, "At least one token symbol is required. Example: ETH, BTC, SOL, etc.")
+        .max(25, "A maximum of 25 token symbols can be provided."),
+})
+    .describe("Input schema for fetching token prices by symbol from Alchemy");
+/**
+ * Input schema for fetching token prices by address.
+ *
+ * The API expects an object with an array of addresses, where each address contains
+ * a network identifier and a token contract address.
+ */
+exports.AlchemyTokenPricesByAddressSchema = zod_1.z
+    .object({
+    addresses: zod_1.z
+        .array(zod_1.z.object({
+        network: zod_1.z.string().describe("Network identifier (e.g., eth-mainnet, base-mainnet etc.)"),
+        address: zod_1.z.string().describe("Token contract address"),
+    }))
+        .min(1, "At least one address is required.")
+        .max(25, "A maximum of 25 addresses can be provided."),
+})
+    .describe("Input schema for fetching token prices by address from Alchemy");