@coinbase/agentkit 0.10.1 → 0.10.2

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/superfluid/superfluidSuperTokenCreatorActionProvider.js

@@ -74,14 +74,15 @@ class SuperfluidSuperTokenCreatorActionProvider extends actionProvider_1.ActionP
                     `${symbol}x`,
                 ],
             });
+            const superTokenFactoryAddress = walletProvider.getNetwork().networkId === "base-sepolia"
+                ? constants_1.SuperTokenFactoryAddress_Base_Sepolia
+                : constants_1.SuperTokenFactoryAddress;
             const createSuperTokenHash = await walletProvider.sendTransaction({
-                to: walletProvider.getNetwork().networkId === "base-sepolia"
-                    ? constants_1.SuperTokenFactoryAddress_Base_Sepolia
-                    : constants_1.SuperTokenFactoryAddress,
+                to: superTokenFactoryAddress,
                 data: createSuperTokenData,
             });
             const receipt = await walletProvider.waitForTransactionReceipt(createSuperTokenHash);
-            const superTokenAddress = (0, parseLogs_1.extractCreatedSuperTokenAddressAbi)(receipt);
+            const superTokenAddress = (0, parseLogs_1.extractCreatedSuperTokenAddressAbi)(receipt, superTokenFactoryAddress);
             return `Created super token for ${args.erc20TokenAddress}.  Super token address at ${superTokenAddress}  Transaction hash: ${createSuperTokenHash}`;
         }
         catch (error) {

package/dist/action-providers/superfluid/utils/parseLogs.d.ts

@@ -12,7 +12,8 @@ type TxReceipt = {
  * Extracts the super token address using the contract abi
  *
  * @param receipt - the transaction receipt from creating the super token
+ * @param factoryAddress - the address of the factory that created the super token
  * @returns - The contract address of the created Super Token
  */
-export declare function extractCreatedSuperTokenAddressAbi(receipt: TxReceipt): `0x${string}`;
+export declare function extractCreatedSuperTokenAddressAbi(receipt: TxReceipt, factoryAddress: `0x${string}`): `0x${string}`;
 export {};

package/dist/action-providers/superfluid/utils/parseLogs.js

@@ -46,12 +46,15 @@ function pickTokenLike(args) {
  * Extracts the super token address using the contract abi
  *
  * @param receipt - the transaction receipt from creating the super token
+ * @param factoryAddress - the address of the factory that created the super token
  * @returns - The contract address of the created Super Token
  */
-function extractCreatedSuperTokenAddressAbi(receipt) {
-    const factory = receipt.to?.toLowerCase();
+function extractCreatedSuperTokenAddressAbi(receipt, factoryAddress) {
+    const factory = factoryAddress.toLowerCase();
     if (!factory)
-        throw new Error("Missing receipt.to (factory address)");
+        throw new Error("Missing factory address");
+    console.log("factory", factory);
+    console.log("receipt.logs", receipt.logs);
     for (const log of receipt.logs) {
         if (log.address.toLowerCase() !== factory)
             continue;

package/dist/action-providers/wallet/walletActionProvider.js

@@ -69,6 +69,9 @@ class WalletActionProvider extends actionProvider_1.ActionProvider {
                 "Wallet Details:",
                 `- Provider: ${name}`,
                 `- Address: ${address}`,
+                ...(walletProvider instanceof wallet_providers_1.CdpSmartWalletProvider
+                    ? [`- Owner Address: ${walletProvider.ownerAccount.address}`]
+                    : []),
                 "- Network:",
                 `  * Protocol Family: ${network.protocolFamily}`,
                 `  * Network ID: ${network.networkId || "N/A"}`,

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>;

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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getX402Network = getX402Network;
+exports.handleHttpError = handleHttpError;
+exports.formatPaymentOption = formatPaymentOption;
+exports.isUsdcAsset = isUsdcAsset;
+exports.convertWholeUnitsToAtomic = convertWholeUnitsToAtomic;
+const utils_1 = require("../erc20/utils");
+const constants_1 = require("../erc20/constants");
+const viem_1 = require("viem");
+/**
+ * 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
+ */
+function getX402Network(network) {
+    switch (network.networkId) {
+        case "base-mainnet":
+            return "base";
+        case "base-sepolia":
+            return "base-sepolia";
+        case "solana-mainnet":
+            return "solana";
+        case "solana-devnet":
+            return "solana-devnet";
+        default:
+            return network.networkId;
+    }
+}
+/**
+ * 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
+ */
+function handleHttpError(error, url) {
+    if (error.response) {
+        return JSON.stringify({
+            error: true,
+            message: `HTTP ${error.response.status} error when accessing ${url}`,
+            details: error.response.data?.error || error.response.statusText,
+            suggestion: "Check if the URL is correct and the API is available.",
+        }, null, 2);
+    }
+    if (error.request) {
+        return JSON.stringify({
+            error: true,
+            message: `Network error when accessing ${url}`,
+            details: error.message,
+            suggestion: "Check your internet connection and verify the API endpoint is accessible.",
+        }, null, 2);
+    }
+    return JSON.stringify({
+        error: true,
+        message: `Error making request to ${url}`,
+        details: error.message,
+        suggestion: "Please check the request parameters and try again.",
+    }, null, 2);
+}
+/**
+ * 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"
+ */
+async function formatPaymentOption(option, walletProvider) {
+    const { asset, maxAmountRequired, network } = option;
+    // Check if this is an EVM network and we can use ERC20 helpers
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    if (isEvmNetwork) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols) {
+            for (const [symbol, address] of Object.entries(tokenSymbols)) {
+                if (asset.toLowerCase() === address.toLowerCase()) {
+                    const decimals = symbol === "USDC" || symbol === "EURC" ? 6 : 18;
+                    const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), decimals);
+                    return `${formattedAmount} ${symbol} on ${network} network`;
+                }
+            }
+        }
+        // Fall back to getTokenDetails for unknown tokens
+        try {
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, asset);
+            if (tokenDetails) {
+                const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), tokenDetails.decimals);
+                return `${formattedAmount} ${tokenDetails.name} on ${network} network`;
+            }
+        }
+        catch {
+            // If we can't get token details, fall back to raw format
+        }
+    }
+    // Fallback to original format for non-EVM networks or when token details can't be fetched
+    return `${asset} ${maxAmountRequired} on ${network} network`;
+}
+/**
+ * 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
+ */
+function isUsdcAsset(asset, walletProvider) {
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    if (isEvmNetwork) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols && tokenSymbols.USDC) {
+            return asset.toLowerCase() === tokenSymbols.USDC.toLowerCase();
+        }
+    }
+    return false;
+}
+/**
+ * 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
+ */
+async function convertWholeUnitsToAtomic(wholeUnits, asset, walletProvider) {
+    // Check if this is an EVM network and we can use ERC20 helpers
+    const walletNetwork = walletProvider.getNetwork();
+    const isEvmNetwork = walletNetwork.protocolFamily === "evm";
+    if (isEvmNetwork) {
+        const networkId = walletNetwork.networkId;
+        const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
+        if (tokenSymbols) {
+            for (const [symbol, address] of Object.entries(tokenSymbols)) {
+                if (asset.toLowerCase() === address.toLowerCase()) {
+                    const decimals = symbol === "USDC" || symbol === "EURC" ? 6 : 18;
+                    return (0, viem_1.parseUnits)(wholeUnits.toString(), decimals).toString();
+                }
+            }
+        }
+        // Fall back to getTokenDetails for unknown tokens
+        try {
+            const tokenDetails = await (0, utils_1.getTokenDetails)(walletProvider, asset);
+            if (tokenDetails) {
+                return (0, viem_1.parseUnits)(wholeUnits.toString(), tokenDetails.decimals).toString();
+            }
+        }
+        catch {
+            // If we can't get token details, fall back to assuming 18 decimals
+        }
+    }
+    // Fallback to 18 decimals for unknown tokens or non-EVM networks
+    return (0, viem_1.parseUnits)(wholeUnits.toString(), 18).toString();
+}

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
-import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema } from "./schemas";
+import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema, ListX402ServicesSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
@@ -12,6 +12,14 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * Initializes the provider with x402 capabilities.
      */
     constructor();
+    /**
+     * Discovers available x402 services with optional filtering.
+     *
+     * @param walletProvider - The wallet provider to use for network filtering
+     * @param args - Optional filters: maxUsdcPrice
+     * @returns JSON string with the list of services (filtered by network and description)
+     */
+    discoverX402Services(walletProvider: EvmWalletProvider, args: z.infer<typeof ListX402ServicesSchema>): Promise<string>;
     /**
      * Makes a basic HTTP request to an API endpoint.
      *
@@ -43,13 +51,5 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @returns True if the network is supported, false otherwise
      */
     supportsNetwork: (network: Network) => boolean;
-    /**
-     * 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
-     */
-    private handleHttpError;
 }
 export declare const x402ActionProvider: () => X402ActionProvider;