@coinbase/agentkit 0.10.0 → 0.10.2

package/dist/action-providers/flaunch/{utils.js → swap_utils.js}

@@ -1,174 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwapAmountsFromReceipt = exports.getSwapAmountsFromLog = exports.memecoinToEthWithPermit2 = exports.ethToMemecoin = exports.getAmountWithSlippage = exports.generateTokenUri = void 0;
+exports.getSwapAmountsFromReceipt = exports.getSwapAmountsFromLog = exports.memecoinToEthWithPermit2 = exports.ethToMemecoin = exports.getAmountWithSlippage = void 0;
+exports.buyFlaunchCoin = buyFlaunchCoin;
 const viem_1 = require("viem");
 const constants_1 = require("./constants");
-/**
- * Uploads a base64 image to IPFS using Pinata
- *
- * @param params - Configuration and base64 image data
- * @param params.pinataConfig - Pinata configuration including JWT
- * @param params.base64Image - Base64 encoded image data
- * @param params.name - Optional name for the uploaded file
- * @param params.metadata - Optional metadata key-value pairs
- * @returns Upload response with CID and other details
- */
-const uploadImageToIPFS = async (params) => {
-    try {
-        const formData = new FormData();
-        // Convert base64 to Blob and then to File
-        // Remove data URL prefix if present (e.g., "data:image/jpeg;base64,")
-        const base64Data = params.base64Image.split(",")[1] || params.base64Image;
-        const byteCharacters = atob(base64Data);
-        const byteArrays = [];
-        for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
-            const slice = byteCharacters.slice(offset, offset + 1024);
-            const byteNumbers = new Array(slice.length);
-            for (let i = 0; i < slice.length; i++) {
-                byteNumbers[i] = slice.charCodeAt(i);
-            }
-            const byteArray = new Uint8Array(byteNumbers);
-            byteArrays.push(byteArray);
-        }
-        // Detect mime type from base64 string
-        let mimeType = "image/png"; // default
-        if (params.base64Image.startsWith("data:")) {
-            mimeType = params.base64Image.split(";")[0].split(":")[1];
-        }
-        const blob = new Blob(byteArrays, { type: mimeType });
-        const fileName = params.name || `image.${mimeType.split("/")[1]}`;
-        const file = new File([blob], fileName, { type: mimeType });
-        formData.append("file", file);
-        const pinataMetadata = {
-            name: params.name || null,
-            keyvalues: params.metadata || {},
-        };
-        formData.append("pinataMetadata", JSON.stringify(pinataMetadata));
-        const pinataOptions = {
-            cidVersion: 1,
-        };
-        formData.append("pinataOptions", JSON.stringify(pinataOptions));
-        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${params.pinataConfig.jwt}`,
-            },
-            body: formData,
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(`Failed to upload image to IPFS: ${error.message || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            IpfsHash: data.IpfsHash,
-            PinSize: data.PinSize,
-            Timestamp: data.Timestamp,
-            isDuplicate: data.isDuplicate || false,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to upload image to IPFS: ${error.message}`);
-        }
-        throw error;
-    }
-};
-/**
- * Uploads JSON data to IPFS using Pinata
- *
- * @param params - Configuration and JSON data
- * @param params.pinataConfig - Pinata configuration including JWT
- * @param params.json - JSON data to upload
- * @param params.name - Optional name for the uploaded file
- * @param params.metadata - Optional metadata key-value pairs
- * @returns Upload response with CID and other details
- */
-const uploadJsonToIPFS = async (params) => {
-    try {
-        const requestBody = {
-            pinataOptions: {
-                cidVersion: 1,
-            },
-            pinataMetadata: {
-                name: params.name || null,
-                keyvalues: params.metadata || {},
-            },
-            pinataContent: params.json,
-        };
-        const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${params.pinataConfig.jwt}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(requestBody),
-        });
-        if (!response.ok) {
-            const error = await response.json();
-            throw new Error(`Failed to upload JSON to IPFS: ${error.message || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            IpfsHash: data.IpfsHash,
-            PinSize: data.PinSize,
-            Timestamp: data.Timestamp,
-            isDuplicate: data.isDuplicate || false,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
-        }
-        throw error;
-    }
-};
-const generateTokenUriBase64Image = async (name, params) => {
-    // 1. upload image to IPFS
-    const imageRes = await uploadImageToIPFS({
-        pinataConfig: params.pinataConfig,
-        base64Image: params.metadata.base64Image,
-    });
-    // 2. upload metadata to IPFS
-    const coinMetadata = {
-        name,
-        description: params.metadata.description,
-        image: `ipfs://${imageRes.IpfsHash}`,
-        external_link: params.metadata.websiteUrl || "",
-        collaborators: [],
-        discordUrl: params.metadata.discordUrl || "",
-        twitterUrl: params.metadata.twitterUrl || "",
-        telegramUrl: params.metadata.telegramUrl || "",
-    };
-    const metadataRes = await uploadJsonToIPFS({
-        pinataConfig: params.pinataConfig,
-        json: coinMetadata,
-    });
-    return `ipfs://${metadataRes.IpfsHash}`;
-};
-const generateTokenUri = async (name, params) => {
-    // 1. get base64Image from imageUrl
-    const response = await fetch(params.metadata.imageUrl);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch image: ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const base64Image = Buffer.from(arrayBuffer).toString("base64");
-    // 2. generate token uri
-    const tokenUri = await generateTokenUriBase64Image(name, {
-        pinataConfig: params.pinataConfig,
-        metadata: {
-            base64Image,
-            description: params.metadata.description,
-            websiteUrl: params.metadata.websiteUrl,
-            discordUrl: params.metadata.discordUrl,
-            twitterUrl: params.metadata.twitterUrl,
-            telegramUrl: params.metadata.telegramUrl,
-        },
-    });
-    return tokenUri;
-};
-exports.generateTokenUri = generateTokenUri;
+const network_1 = require("../../network");
+const viem_2 = require("viem");
 const getAmountWithSlippage = (amount, slippage, swapType) => {
     if (amount == null) {
         return 0n;
@@ -184,7 +21,7 @@ const ETH = viem_1.zeroAddress;
 const ethToMemecoin = (params) => {
     const flETH = constants_1.FLETHAddress[params.chainId];
     const flETHHooks = constants_1.FLETHHooksAddress[params.chainId];
-    const flaunchHooks = constants_1.FlaunchPositionManagerAddress[params.chainId];
+    const flaunchHooks = constants_1.FlaunchPositionManagerV1_1Address[params.chainId];
     // Determine actions based on swapType
     const v4Actions = ("0x" +
         (params.swapType === "EXACT_IN" ? constants_1.V4Actions.SWAP_EXACT_IN : constants_1.V4Actions.SWAP_EXACT_OUT) +
@@ -314,11 +151,11 @@ const ethToMemecoin = (params) => {
 };
 exports.ethToMemecoin = ethToMemecoin;
 // @notice Before calling the UniversalRouter the user must have:
-// 1. Given the Permit2 contract allowance to spend the memecoin
+// Given the Permit2 contract allowance to spend the memecoin
 const memecoinToEthWithPermit2 = (params) => {
     const flETH = constants_1.FLETHAddress[params.chainId];
     const flETHHooks = constants_1.FLETHHooksAddress[params.chainId];
-    const flaunchHooks = constants_1.FlaunchPositionManagerAddress[params.chainId];
+    const flaunchHooks = constants_1.FlaunchPositionManagerV1_1Address[params.chainId];
     const v4Actions = ("0x" +
         constants_1.V4Actions.SWAP_EXACT_IN +
         constants_1.V4Actions.SETTLE_ALL +
@@ -483,11 +320,11 @@ const getSwapAmountsFromReceipt = ({ receipt, coinAddress, chainId, }) => {
     const filteredPoolSwapEvent = receipt.logs
         .map(log => {
         try {
-            if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerAddress[chainId].toLowerCase()) {
+            if (log.address.toLowerCase() !== constants_1.FlaunchPositionManagerV1_1Address[chainId].toLowerCase()) {
                 return null;
             }
             const event = (0, viem_1.decodeEventLog)({
-                abi: constants_1.POSITION_MANAGER_ABI,
+                abi: constants_1.POSITION_MANAGERV1_1_ABI,
                 data: log.data,
                 topics: log.topics,
             });
@@ -505,3 +342,131 @@ const getSwapAmountsFromReceipt = ({ receipt, coinAddress, chainId, }) => {
     });
 };
 exports.getSwapAmountsFromReceipt = getSwapAmountsFromReceipt;
+/**
+ * Buys a flaunch coin using ETH input.
+ *
+ * @param walletProvider - The wallet provider instance for blockchain interactions
+ * @param coinAddress - The address of the coin to buy
+ * @param swapType - The type of swap to perform
+ * @param swapParams - The parameters for the swap
+ * @param swapParams.amountIn - The amount of ETH to spend (for EXACT_IN)
+ * @param swapParams.amountOut - The amount of coins to buy (for EXACT_OUT)
+ * @param slippagePercent - The slippage percentage
+ * @returns A promise that resolves to a string describing the transaction result
+ */
+async function buyFlaunchCoin(walletProvider, coinAddress, swapType, swapParams, slippagePercent) {
+    const network = walletProvider.getNetwork();
+    const chainId = network.chainId;
+    const networkId = network.networkId;
+    if (!chainId || !networkId) {
+        throw new Error("Chain ID is not set.");
+    }
+    try {
+        let amountIn;
+        let amountOutMin;
+        let amountOut;
+        let amountInMax;
+        if (swapType === "EXACT_IN") {
+            amountIn = (0, viem_1.parseEther)(swapParams.amountIn);
+            const quoteResult = await walletProvider.getPublicClient().simulateContract({
+                address: constants_1.QuoterAddress[chainId],
+                abi: constants_1.QUOTER_ABI,
+                functionName: "quoteExactInput",
+                args: [
+                    {
+                        exactAmount: amountIn,
+                        exactCurrency: viem_1.zeroAddress, // ETH
+                        path: [
+                            {
+                                fee: 0,
+                                tickSpacing: 60,
+                                hookData: "0x",
+                                hooks: constants_1.FLETHHooksAddress[chainId],
+                                intermediateCurrency: constants_1.FLETHAddress[chainId],
+                            },
+                            {
+                                fee: 0,
+                                tickSpacing: 60,
+                                hooks: constants_1.FlaunchPositionManagerV1_1Address[chainId],
+                                hookData: "0x",
+                                intermediateCurrency: coinAddress,
+                            },
+                        ],
+                    },
+                ],
+            });
+            amountOutMin = (0, exports.getAmountWithSlippage)(quoteResult.result[0], // amountOut
+            (slippagePercent / 100).toFixed(18).toString(), swapType);
+        }
+        else {
+            // EXACT_OUT
+            amountOut = (0, viem_1.parseEther)(swapParams.amountOut);
+            const quoteResult = await walletProvider.getPublicClient().simulateContract({
+                address: constants_1.QuoterAddress[chainId],
+                abi: constants_1.QUOTER_ABI,
+                functionName: "quoteExactOutput",
+                args: [
+                    {
+                        path: [
+                            {
+                                intermediateCurrency: viem_1.zeroAddress,
+                                fee: 0,
+                                tickSpacing: 60,
+                                hookData: "0x",
+                                hooks: constants_1.FLETHHooksAddress[chainId],
+                            },
+                            {
+                                intermediateCurrency: constants_1.FLETHAddress[chainId],
+                                fee: 0,
+                                tickSpacing: 60,
+                                hooks: constants_1.FlaunchPositionManagerV1_1Address[chainId],
+                                hookData: "0x",
+                            },
+                        ],
+                        exactCurrency: coinAddress,
+                        exactAmount: amountOut,
+                    },
+                ],
+            });
+            amountInMax = (0, exports.getAmountWithSlippage)(quoteResult.result[0], // amountIn
+            (slippagePercent / 100).toFixed(18).toString(), swapType);
+        }
+        const { commands, inputs } = (0, exports.ethToMemecoin)({
+            sender: walletProvider.getAddress(),
+            memecoin: coinAddress,
+            chainId: Number(chainId),
+            referrer: viem_1.zeroAddress,
+            swapType,
+            amountIn,
+            amountOutMin,
+            amountOut,
+            amountInMax,
+        });
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: constants_1.UNIVERSAL_ROUTER_ABI,
+            functionName: "execute",
+            args: [commands, inputs],
+        });
+        const hash = await walletProvider.sendTransaction({
+            to: constants_1.UniversalRouterAddress[chainId],
+            data,
+            value: swapType === "EXACT_IN" ? amountIn : amountInMax,
+        });
+        const receipt = await walletProvider.waitForTransactionReceipt(hash);
+        const swapAmounts = (0, exports.getSwapAmountsFromReceipt)({
+            receipt,
+            coinAddress: coinAddress,
+            chainId: Number(chainId),
+        });
+        const coinSymbol = await walletProvider.readContract({
+            address: coinAddress,
+            abi: constants_1.ERC20_ABI,
+            functionName: "symbol",
+        });
+        return `Bought ${(0, viem_2.formatEther)(swapAmounts.coinsBought)} $${coinSymbol} for ${(0, viem_2.formatEther)(swapAmounts.ethSold)} ETH\n
+      Tx hash: [${hash}](${network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId].blockExplorers?.default.url}/tx/${hash})`;
+    }
+    catch (error) {
+        return `Error buying coin: ${error}`;
+    }
+}

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

@@ -3,6 +3,7 @@ export * from "./actionProvider";
 export * from "./customActionProvider";
 export * from "./across";
 export * from "./alchemy";
+export * from "./baseAccount";
 export * from "./basename";
 export * from "./cdp-legacy";
 export * from "./cdp";
@@ -18,6 +19,7 @@ export * from "./moonwell";
 export * from "./morpho";
 export * from "./opensea";
 export * from "./spl";
+export * from "./superfluid";
 export * from "./truemarkets";
 export * from "./twitter";
 export * from "./wallet";
@@ -30,4 +32,6 @@ export * from "./vaultsfyi";
 export * from "./x402";
 export * from "./zerion";
 export * from "./zerodev";
+export * from "./zeroX";
 export * from "./zora";
+export * from "./clanker";

package/dist/action-providers/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./actionProvider"), exports);
 __exportStar(require("./customActionProvider"), exports);
 __exportStar(require("./across"), exports);
 __exportStar(require("./alchemy"), exports);
+__exportStar(require("./baseAccount"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp-legacy"), exports);
 __exportStar(require("./cdp"), exports);
@@ -34,6 +35,7 @@ __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);
 __exportStar(require("./opensea"), exports);
 __exportStar(require("./spl"), exports);
+__exportStar(require("./superfluid"), exports);
 __exportStar(require("./truemarkets"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
@@ -46,4 +48,6 @@ __exportStar(require("./vaultsfyi"), exports);
 __exportStar(require("./x402"), exports);
 __exportStar(require("./zerion"), exports);
 __exportStar(require("./zerodev"), exports);
+__exportStar(require("./zeroX"), exports);
 __exportStar(require("./zora"), exports);
+__exportStar(require("./clanker"), exports);

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

@@ -9,9 +9,9 @@ export declare const SwapTokenSchema: z.ZodObject<{
     slippageBps: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     amount: number;
+    slippageBps: number;
     inputMint: string;
     outputMint: string;
-    slippageBps: number;
 }, {
     amount: number;
     inputMint: string;

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

@@ -7,12 +7,12 @@ export declare const MintSchema: z.ZodObject<{
     tokenAddress: z.ZodString;
     mTokenAddress: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    assets: string;
     tokenAddress: string;
+    assets: string;
     mTokenAddress: string;
 }, {
-    assets: string;
     tokenAddress: string;
+    assets: string;
     mTokenAddress: string;
 }>;
 /**

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

@@ -13,12 +13,12 @@ exports.morphoActionProvider = exports.MorphoActionProvider = exports.SUPPORTED_
 const zod_1 = require("zod");
 const decimal_js_1 = require("decimal.js");
 const viem_1 = require("viem");
-const constants_1 = require("../erc20/constants");
+const viem_2 = 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_2 = require("./constants");
+const constants_1 = require("./constants");
 const schemas_1 = require("./schemas");
 exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
@@ -53,7 +53,7 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
         try {
             const decimals = await wallet.readContract({
                 address: args.tokenAddress,
-                abi: constants_1.abi,
+                abi: viem_2.erc20Abi,
                 functionName: "decimals",
                 args: [],
             });
@@ -63,7 +63,7 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
                 return `Error approving Morpho Vault as spender: ${approvalResult}`;
             }
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_2.METAMORPHO_ABI,
+                abi: constants_1.METAMORPHO_ABI,
                 functionName: "deposit",
                 args: [atomicAssets, args.receiver],
             });
@@ -91,7 +91,7 @@ class MorphoActionProvider extends actionProvider_1.ActionProvider {
         }
         try {
             const data = (0, viem_1.encodeFunctionData)({
-                abi: constants_2.METAMORPHO_ABI,
+                abi: constants_1.METAMORPHO_ABI,
                 functionName: "withdraw",
                 args: [BigInt(args.assets), args.receiver, args.receiver],
             });

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

@@ -8,14 +8,14 @@ export declare const DepositSchema: z.ZodObject<{
     tokenAddress: z.ZodString;
     vaultAddress: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    tokenAddress: string;
     receiver: string;
     assets: string;
-    tokenAddress: string;
     vaultAddress: string;
 }, {
+    tokenAddress: string;
     receiver: string;
     assets: string;
-    tokenAddress: string;
     vaultAddress: string;
 }>;
 /**

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

@@ -13,14 +13,14 @@ export declare class PythActionProvider extends ActionProvider {
      * 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.
+     * @returns The price feed ID as stringified JSON.
      */
     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.
+     * @returns The price as stringified JSON.
      */
     fetchPrice(args: z.infer<typeof PythFetchPriceSchema>): Promise<string>;
     /**

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

@@ -34,63 +34,120 @@ class PythActionProvider extends actionProvider_1.ActionProvider {
      * 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.
+     * @returns The price feed ID as stringified JSON.
      */
     async fetchPriceFeed(args) {
-        const url = `https://hermes.pyth.network/v2/price_feeds?query=${args.tokenSymbol}&asset_type=crypto`;
+        const url = `https://hermes.pyth.network/v2/price_feeds?query=${args.tokenSymbol}&asset_type=${args.assetType}`;
         const response = await fetch(url);
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            return JSON.stringify({
+                success: false,
+                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}`);
+            return JSON.stringify({
+                success: false,
+                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());
+        (item) => item.attributes.base.toLowerCase() === args.tokenSymbol.toLowerCase() &&
+            item.attributes.quote_currency.toLowerCase() === args.quoteCurrency.toLowerCase());
         if (filteredData.length === 0) {
-            throw new Error(`No price feed found for ${args.tokenSymbol}`);
+            return JSON.stringify({
+                success: false,
+                error: `No price feed found for ${args.tokenSymbol}/${args.quoteCurrency}`,
+            });
         }
-        return filteredData[0].id;
+        // For equities, select the regular feed over special market hours feeds
+        let selectedFeed = filteredData[0];
+        if (args.assetType === "equity") {
+            // Look for regular market feed (no PRE, POST, ON, EXT suffixes)
+            const regularMarketFeed = filteredData.find(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (item) => !item.attributes.symbol.includes(".PRE") &&
+                !item.attributes.symbol.includes(".POST") &&
+                !item.attributes.symbol.includes(".ON") &&
+                !item.attributes.symbol.includes(".EXT"));
+            if (regularMarketFeed) {
+                selectedFeed = regularMarketFeed;
+            }
+        }
+        return JSON.stringify({
+            success: true,
+            priceFeedID: selectedFeed.id,
+            tokenSymbol: args.tokenSymbol,
+            quoteCurrency: args.quoteCurrency,
+            feedType: selectedFeed.attributes.display_symbol,
+        });
     }
     /**
      * Fetches the price from Pyth given a Pyth price feed ID.
      *
      * @param args - The arguments for the action.
-     * @returns The price as a string.
+     * @returns The price as stringified JSON.
      */
     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}`);
+            return JSON.stringify({
+                success: false,
+                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}`);
+            return JSON.stringify({
+                success: false,
+                error: `No price data found for ${args.priceFeedID}`,
+            });
         }
+        // Helper function to format price
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const formatPrice = (priceInfo) => {
+            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();
+        };
         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();
+        return JSON.stringify({
+            success: true,
+            priceFeedID: args.priceFeedID,
+            price: formatPrice(priceInfo),
+        });
     }
 }
 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.",
+        description: `Fetch the price feed ID for a given token symbol from Pyth.
+
+    Inputs:
+    - tokenSymbol: The asset ticker/symbol to fetch the price feed ID for (e.g. BTC, ETH, COIN, XAU, EUR, etc.)
+    - quoteCurrency: The quote currency to filter by (defaults to USD)
+    - assetType: The asset type to search for (crypto, equity, fx, metal) - defaults to crypto
+
+    Examples:
+    - Crypto: BTC, ETH, SOL
+    - Equities: COIN, AAPL, TSLA
+    - FX: EUR, GBP, JPY
+    - Metals: XAU (Gold), XAG (Silver), XPT (Platinum), XPD (Palladium)
+    `,
         schema: schemas_1.PythFetchPriceFeedIDSchema,
     }),
     __metadata("design:type", Function),
@@ -100,16 +157,16 @@ __decorate([
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "fetch_price",
-        description: `Fetch the price of a given price feed from Pyth.
+        description: `Fetch the price of a price feed from Pyth.
 
 Inputs:
-- Pyth price feed ID
+- priceFeedID: Price feed ID (string)
 
 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
+action to retrieve the price feed ID before invoking the pyth_fetch_price action
 `,
         schema: schemas_1.PythFetchPriceSchema,
     }),