@coinbase/agentkit 0.0.0-nightly-20250915210424 → 0.0.0-nightly-20250917210422

package/README.md

@@ -407,7 +407,7 @@ const agent = createReactAgent({
 </tr>
 <tr>
     <td width="200"><code>fetch_price_feed_id</code></td>
-    <td width="768">Retrieves the unique price feed identifier for a given token symbol.</td>
+    <td width="768">Retrieves the unique price feed identifier for a given asset symbol.</td>
 </tr>
 </table>
 </details>
@@ -541,6 +541,10 @@ const agent = createReactAgent({
 <details>
 <summary><strong>x402</strong></summary>
 <table width="100%">
+<tr>
+    <td width="200"><code>discover_x402_services</code></td>
+    <td width="768">Discover available x402 services with optional filtering by maximum USDC price.</td>
+</tr>
 <tr>
     <td width="200"><code>make_http_request</code></td>
     <td width="768">Makes a basic HTTP request to an API endpoint. If the endpoint requires payment (returns 402),
@@ -553,6 +557,10 @@ it will return payment details that can be used on retry.</td>
 <tr>
     <td width="200"><code>make_http_request_with_x402</code></td>
     <td width="768">Combines make_http_request and retry_http_request_with_x402 into a single step.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>ZeroX</strong></summary>
 <table width="100%">
 <tr>

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,68 +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) {
-        // Stop-gap solution: Return hardcoded price feed ID for ETH
-        // This is temporary until proper new API link is provided after talking to the Pyth team
-        if (args.tokenSymbol.toUpperCase() === "ETH") {
-            return "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace";
-        }
-        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}`,
+            });
+        }
+        // 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 filteredData[0].id;
+        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),
@@ -105,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,
     }),

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

@@ -9,39 +9,180 @@ describe("PythActionProvider", () => {
         jest.resetAllMocks().restoreAllMocks();
     });
     describe("fetchPriceFeed", () => {
-        it("should return the first price feed ID that matches the input token symbol", async () => {
+        it("should return the first price feed ID that matches the input token symbol for crypto", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
             });
-            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "BTC" });
-            expect(priceFeedId).toEqual("some-price-feed-id");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("some-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for metals", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "gold-price-feed-id", attributes: { base: "XAU", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "XAU",
+                assetType: "metal",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("gold-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for commodities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "oil-price-feed-id", attributes: { base: "WTI", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "WTI",
+                assetType: "metal",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("oil-price-feed-id");
+        });
+        it("should return the first price feed ID that matches the input token symbol for equities", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "apple-price-feed-id",
+                        attributes: {
+                            base: "AAPL",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.AAPL/USD",
+                            display_symbol: "AAPL/USD",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "AAPL",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("apple-price-feed-id");
         });
-        it("should throw an error if no price feed is found", async () => {
+        it("should return the first price feed ID that matches the input token symbol for FX", async () => {
             fetchMock.mockResolvedValueOnce({
                 ok: true,
-                json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
+                json: async () => [
+                    { id: "eur-price-feed-id", attributes: { base: "EUR", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "EUR",
+                assetType: "fx",
+                quoteCurrency: "USD",
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "SOL" })).rejects.toThrow("No price feed found for SOL");
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("eur-price-feed-id");
         });
-        it("should return hardcoded price feed ID for ETH", async () => {
-            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "ETH" });
-            expect(priceFeedId).toEqual("0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace");
+        it("should return error if no price feed is found", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    { id: "some-price-feed-id", attributes: { base: "BTC", quote_currency: "USD" } },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "SOL",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for SOL/USD");
         });
-        it("should throw an error if the response is not ok", async () => {
+        it("should return 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");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
-        it("should throw an error if response is ok but no data is returned", async () => {
+        it("should return 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");
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "BTC",
+                assetType: "crypto",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price feed found for BTC");
+        });
+        it("should prefer regular market hours feed for equities over pre/post market", async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [
+                    {
+                        id: "post-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.POST",
+                            display_symbol: "COIN/USD POST MARKET",
+                        },
+                    },
+                    {
+                        id: "regular-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD",
+                            display_symbol: "COIN/USD",
+                        },
+                    },
+                    {
+                        id: "pre-market-feed-id",
+                        attributes: {
+                            base: "COIN",
+                            quote_currency: "USD",
+                            symbol: "Equity.US.COIN/USD.PRE",
+                            display_symbol: "COIN/USD PRE MARKET",
+                        },
+                    },
+                ],
+            });
+            const result = await provider.fetchPriceFeed({
+                tokenSymbol: "COIN",
+                assetType: "equity",
+                quoteCurrency: "USD",
+            });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.priceFeedID).toEqual("regular-market-feed-id");
+            expect(parsed.feedType).toEqual("COIN/USD");
         });
     });
     describe("fetchPrice", () => {
@@ -59,8 +200,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1");
         });
         it("should return the price for a given price feed ID with a negative exponent", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -76,9 +219,10 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const provider = (0, pythActionProvider_1.pythActionProvider)();
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("1.00");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("1.00");
         });
         it("should handle scaled price starting with a decimal", async () => {
             fetchMock.mockResolvedValueOnce({
@@ -94,24 +238,32 @@ describe("PythActionProvider", () => {
                     ],
                 }),
             });
-            const price = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
-            expect(price).toEqual("0.25");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(true);
+            expect(parsed.price).toEqual("0.25");
         });
-        it("should throw an error if there is no price data", async () => {
+        it("should return 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");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("No price data found for some-price-feed-id");
         });
-        it("should throw an error if response is not ok", async () => {
+        it("should return 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");
+            const result = await provider.fetchPrice({ priceFeedID: "some-price-feed-id" });
+            const parsed = JSON.parse(result);
+            expect(parsed.success).toBe(false);
+            expect(parsed.error).toContain("HTTP error! status: 404");
         });
     });
 });

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

@@ -4,10 +4,16 @@ import { z } from "zod";
  */
 export declare const PythFetchPriceFeedIDSchema: z.ZodObject<{
     tokenSymbol: z.ZodString;
+    quoteCurrency: z.ZodDefault<z.ZodString>;
+    assetType: z.ZodDefault<z.ZodEnum<["crypto", "equity", "fx", "metal"]>>;
 }, "strict", z.ZodTypeAny, {
     tokenSymbol: string;
+    quoteCurrency: string;
+    assetType: "crypto" | "equity" | "fx" | "metal";
 }, {
     tokenSymbol: string;
+    quoteCurrency?: string | undefined;
+    assetType?: "crypto" | "equity" | "fx" | "metal" | undefined;
 }>;
 /**
  * Input schema for Pyth fetch price action.

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

@@ -7,7 +7,15 @@ const zod_1 = require("zod");
  */
 exports.PythFetchPriceFeedIDSchema = zod_1.z
     .object({
-    tokenSymbol: zod_1.z.string().describe("The token symbol to fetch the price feed ID for"),
+    tokenSymbol: zod_1.z.string().describe("The asset ticker/symbol to fetch the price feed ID for"),
+    quoteCurrency: zod_1.z
+        .string()
+        .default("USD")
+        .describe("The quote currency to filter by (defaults to USD)"),
+    assetType: zod_1.z
+        .enum(["crypto", "equity", "fx", "metal"])
+        .default("crypto")
+        .describe("The asset type to search for (crypto, equity, fx, metal)"),
 })
     .strict();
 /**

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

@@ -1,4 +1,11 @@
 import { z } from "zod";
+export declare const ListX402ServicesSchema: z.ZodObject<{
+    maxUsdcPrice: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxUsdcPrice?: number | undefined;
+}, {
+    maxUsdcPrice?: number | undefined;
+}>;
 export declare const HttpRequestSchema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;

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

@@ -1,7 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = void 0;
+exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = exports.ListX402ServicesSchema = void 0;
 const zod_1 = require("zod");
+// Schema for listing x402 services
+exports.ListX402ServicesSchema = zod_1.z
+    .object({
+    maxUsdcPrice: zod_1.z
+        .number()
+        .optional()
+        .describe("Optional maximum price in USDC whole units (e.g., 0.1 for 0.10 USDC). Only USDC payment options will be considered when this filter is applied."),
+})
+    .strip()
+    .describe("Parameters for listing x402 services with optional filtering");
 // Schema for initial HTTP request
 exports.HttpRequestSchema = zod_1.z
     .object({

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

@@ -0,0 +1,55 @@
+import { Network } from "../../network";
+import { AxiosError } from "axios";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Supported network types for x402 protocol
+ */
+export type X402Network = "base" | "base-sepolia" | "solana" | "solana-devnet";
+/**
+ * Converts the internal network ID to the format expected by the x402 protocol.
+ *
+ * @param network - The network to convert
+ * @returns The network ID in x402 format
+ * @throws Error if the network is not supported
+ */
+export declare function getX402Network(network: Network): X402Network | string | undefined;
+/**
+ * Helper method to handle HTTP errors consistently.
+ *
+ * @param error - The axios error to handle
+ * @param url - The URL that was being accessed when the error occurred
+ * @returns A JSON string containing formatted error details
+ */
+export declare function handleHttpError(error: AxiosError, url: string): string;
+/**
+ * Formats a payment option into a human-readable string.
+ *
+ * @param option - The payment option to format
+ * @param option.asset - The asset address or identifier
+ * @param option.maxAmountRequired - The maximum amount required for the payment
+ * @param option.network - The network identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns A formatted string like "0.1 USDC on base"
+ */
+export declare function formatPaymentOption(option: {
+    asset: string;
+    maxAmountRequired: string;
+    network: string;
+}, walletProvider: EvmWalletProvider): Promise<string>;
+/**
+ * Checks if an asset is USDC on any supported network.
+ *
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for network context
+ * @returns True if the asset is USDC, false otherwise
+ */
+export declare function isUsdcAsset(asset: string, walletProvider: EvmWalletProvider): boolean;
+/**
+ * Converts whole units to atomic units for a given asset.
+ *
+ * @param wholeUnits - The amount in whole units (e.g., 0.1 for 0.1 USDC)
+ * @param asset - The asset address or identifier
+ * @param walletProvider - The wallet provider for token details lookup
+ * @returns The amount in atomic units as a string, or null if conversion fails
+ */
+export declare function convertWholeUnitsToAtomic(wholeUnits: number, asset: string, walletProvider: EvmWalletProvider): Promise<string | null>;