@coinbase/agentkit 0.1.0

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

@@ -0,0 +1,147 @@
+"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.morphoActionProvider = exports.MorphoActionProvider = exports.SUPPORTED_NETWORKS = void 0;
+const zod_1 = require("zod");
+const decimal_js_1 = require("decimal.js");
+const viem_1 = require("viem");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const utils_1 = require("../../utils");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * MorphoActionProvider is an action provider for Morpho Vault interactions.
+ */
+class MorphoActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the MorphoActionProvider class.
+     */
+    constructor() {
+        super("morpho", []);
+        /**
+         * Checks if the Morpho action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Morpho action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && exports.SUPPORTED_NETWORKS.includes(network.networkId);
+    }
+    /**
+     * Deposits assets into a Morpho Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    async deposit(wallet, args) {
+        const assets = new decimal_js_1.Decimal(args.assets);
+        if (assets.comparedTo(new decimal_js_1.Decimal(0.0)) != 1) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        try {
+            const atomicAssets = (0, viem_1.parseEther)(args.assets);
+            const approvalResult = await (0, utils_1.approve)(wallet, args.tokenAddress, args.vaultAddress, atomicAssets);
+            if (approvalResult.startsWith("Error")) {
+                return `Error approving Morpho Vault as spender: ${approvalResult}`;
+            }
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.METAMORPHO_ABI,
+                functionName: "deposit",
+                args: [atomicAssets, args.receiver],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.vaultAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Deposited ${args.assets} to Morpho Vault ${args.vaultAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error depositing to Morpho Vault: ${error}`;
+        }
+    }
+    /**
+     * Withdraws assets from a Morpho Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    async withdraw(wallet, args) {
+        if (BigInt(args.assets) <= 0) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.METAMORPHO_ABI,
+                functionName: "withdraw",
+                args: [BigInt(args.assets), args.receiver, args.receiver],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.vaultAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Withdrawn ${args.assets} from Morpho Vault ${args.vaultAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error withdrawing from Morpho Vault: ${error}`;
+        }
+    }
+}
+exports.MorphoActionProvider = MorphoActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "deposit",
+        description: `
+This tool allows depositing assets into a Morpho Vault. 
+
+It takes:
+- vaultAddress: The address of the Morpho Vault to deposit to
+- assets: The amount of assets to deposit in whole units
+  Examples for WETH:
+  - 1 WETH
+  - 0.1 WETH
+  - 0.01 WETH
+- receiver: The address to receive the shares
+- tokenAddress: The address of the token to approve
+
+Important notes:
+- Make sure to use the exact amount provided. Do not convert units for assets for this action.
+- Please use a token address (example 0x4200000000000000000000000000000000000006) for the tokenAddress field.
+`,
+        schema: schemas_1.DepositSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MorphoActionProvider.prototype, "deposit", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "withdraw",
+        description: `
+This tool allows withdrawing assets from a Morpho Vault. It takes:
+
+- vaultAddress: The address of the Morpho Vault to withdraw from
+- assets: The amount of assets to withdraw in atomic units (wei)
+- receiver: The address to receive the shares
+`,
+        schema: schemas_1.WithdrawSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MorphoActionProvider.prototype, "withdraw", null);
+const morphoActionProvider = () => new MorphoActionProvider();
+exports.morphoActionProvider = morphoActionProvider;

package/dist/action-providers/morpho/morphoActionProvider.test.d.ts

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

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const utils_1 = require("../../utils");
+const morphoActionProvider_1 = require("./morphoActionProvider");
+const constants_1 = require("./constants");
+const MOCK_VAULT_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_ATOMIC_ASSETS = "1000000000000000000";
+const MOCK_WHOLE_ASSETS = "1.0";
+const MOCK_RECEIVER_ID = "0x9876543210987654321098765432109876543210";
+const MOCK_TOKEN_ADDRESS = "0x4200000000000000000000000000000000000006";
+const MOCK_TX_HASH = "0xabcdef1234567890";
+const MOCK_RECEIPT = { status: 1, blockNumber: 1234567 };
+jest.mock("../../utils");
+const mockApprove = utils_1.approve;
+describe("Morpho Action Provider", () => {
+    const actionProvider = new morphoActionProvider_1.MorphoActionProvider();
+    let mockWallet;
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_RECEIVER_ID),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "1" }),
+            sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+        };
+        mockApprove.mockResolvedValue("Approval successful");
+    });
+    describe("deposit", () => {
+        it("should successfully deposit to Morpho vault", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_WHOLE_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+                tokenAddress: MOCK_TOKEN_ADDRESS,
+            };
+            const atomicAssets = (0, viem_1.parseEther)(MOCK_WHOLE_ASSETS);
+            const response = await actionProvider.deposit(mockWallet, args);
+            expect(mockApprove).toHaveBeenCalledWith(mockWallet, MOCK_TOKEN_ADDRESS, MOCK_VAULT_ADDRESS, atomicAssets);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_VAULT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.METAMORPHO_ABI,
+                    functionName: "deposit",
+                    args: [atomicAssets, MOCK_RECEIVER_ID],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toContain(`Deposited ${MOCK_WHOLE_ASSETS}`);
+            expect(response).toContain(MOCK_TX_HASH);
+            expect(response).toContain(JSON.stringify(MOCK_RECEIPT));
+        });
+        it("should handle errors when depositing", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_WHOLE_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+                tokenAddress: MOCK_TOKEN_ADDRESS,
+            };
+            mockWallet.sendTransaction.mockRejectedValue(new Error("Failed to deposit"));
+            const response = await actionProvider.deposit(mockWallet, args);
+            expect(response).toContain("Error depositing to Morpho Vault: Error: Failed to deposit");
+        });
+    });
+    describe("withdraw", () => {
+        it("should successfully withdraw from Morpho vault", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_ATOMIC_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+            };
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_VAULT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.METAMORPHO_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(MOCK_ATOMIC_ASSETS), MOCK_RECEIVER_ID, MOCK_RECEIVER_ID],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toContain(`Withdrawn ${MOCK_ATOMIC_ASSETS}`);
+            expect(response).toContain(MOCK_TX_HASH);
+            expect(response).toContain(JSON.stringify(MOCK_RECEIPT));
+        });
+        it("should handle errors when withdrawing", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_ATOMIC_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+            };
+            mockWallet.sendTransaction.mockRejectedValue(new Error("Failed to withdraw"));
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(response).toContain("Error withdrawing from Morpho Vault: Error: Failed to withdraw");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for Base Mainnet", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return true for Base Sepolia", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false for other EVM networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum",
+            });
+            expect(result).toBe(false);
+        });
+        it("should return false for non-EVM networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "bitcoin",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for Morpho Vault deposit action.
+ */
+export declare const DepositSchema: z.ZodObject<{
+    assets: z.ZodString;
+    receiver: z.ZodString;
+    tokenAddress: z.ZodString;
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assets: string;
+    receiver: string;
+    tokenAddress: string;
+    vaultAddress: string;
+}, {
+    assets: string;
+    receiver: string;
+    tokenAddress: string;
+    vaultAddress: string;
+}>;
+/**
+ * Input schema for Morpho Vault withdraw action.
+ */
+export declare const WithdrawSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    assets: z.ZodString;
+    receiver: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assets: string;
+    receiver: string;
+    vaultAddress: string;
+}, {
+    assets: string;
+    receiver: string;
+    vaultAddress: string;
+}>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawSchema = exports.DepositSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for Morpho Vault deposit action.
+ */
+exports.DepositSchema = zod_1.z
+    .object({
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of assets to deposit, in whole units"),
+    receiver: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address that will own the position on the vault which will receive the shares"),
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the assets token to approve for deposit"),
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the Morpho Vault to deposit to"),
+})
+    .describe("Input schema for Morpho Vault deposit action");
+/**
+ * Input schema for Morpho Vault withdraw action.
+ */
+exports.WithdrawSchema = zod_1.z
+    .object({
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the Morpho Vault to withdraw from"),
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+$/, "Must be a valid whole number")
+        .describe("The amount of assets to withdraw in atomic units e.g. 1"),
+    receiver: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to receive the shares"),
+})
+    .strip()
+    .describe("Input schema for Morpho Vault withdraw action");

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/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/twitter/index.d.ts

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

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

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+/**
+ * Input schema for retrieving account details.
+ */
+export declare const TwitterAccountDetailsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+/**
+ * Input schema for retrieving account mentions.
+ */
+export declare const TwitterAccountMentionsSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+}, {
+    userId: string;
+}>;
+/**
+ * Input schema for posting a tweet.
+ */
+export declare const TwitterPostTweetSchema: z.ZodObject<{
+    tweet: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tweet: string;
+}, {
+    tweet: string;
+}>;
+/**
+ * Input schema for posting a tweet reply.
+ */
+export declare const TwitterPostTweetReplySchema: z.ZodObject<{
+    tweetId: z.ZodString;
+    tweetReply: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tweetId: string;
+    tweetReply: string;
+}, {
+    tweetId: string;
+    tweetReply: string;
+}>;