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

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;

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

@@ -20,7 +20,10 @@ const schemas_1 = require("./schemas");
 const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402_axios_1 = require("x402-axios");
-const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+const verify_1 = require("x402/verify");
+const x402_1 = require("@coinbase/x402");
+const utils_1 = require("./utils");
+const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia", "solana-mainnet", "solana-devnet"];
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
@@ -39,6 +42,116 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
          */
         this.supportsNetwork = (network) => network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
     }
+    /**
+     * 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)
+     */
+    async discoverX402Services(walletProvider, args) {
+        try {
+            const { list } = (0, verify_1.useFacilitator)(x402_1.facilitator);
+            const services = await list();
+            if (!services || !services.items) {
+                return JSON.stringify({
+                    error: true,
+                    message: "No services found",
+                });
+            }
+            // Get the current wallet network
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            // Filter services by network, description, and optional USDC price
+            const hasValidMaxUsdcPrice = typeof args.maxUsdcPrice === "number" &&
+                Number.isFinite(args.maxUsdcPrice) &&
+                args.maxUsdcPrice > 0;
+            const filteredServices = services.items.filter(item => {
+                // Filter by network - only include services that accept the current wallet network
+                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                const hasMatchingNetwork = accepts.some(req => req.network === walletNetwork);
+                // Filter out services with empty or default descriptions
+                const hasDescription = accepts.some(req => req.description &&
+                    req.description.trim() !== "" &&
+                    req.description.trim() !== "Access to protected content");
+                return hasMatchingNetwork && hasDescription;
+            });
+            // Apply USDC price filtering if maxUsdcPrice is provided (only consider USDC assets)
+            let priceFilteredServices = filteredServices;
+            if (hasValidMaxUsdcPrice) {
+                priceFilteredServices = [];
+                for (const item of filteredServices) {
+                    const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                    let shouldInclude = false;
+                    for (const req of accepts) {
+                        if (req.network === walletNetwork && req.asset && req.maxAmountRequired) {
+                            // Only consider USDC assets when maxUsdcPrice filter is applied
+                            if ((0, utils_1.isUsdcAsset)(req.asset, walletProvider)) {
+                                try {
+                                    const maxUsdcPriceAtomic = await (0, utils_1.convertWholeUnitsToAtomic)(args.maxUsdcPrice, req.asset, walletProvider);
+                                    if (maxUsdcPriceAtomic) {
+                                        const requirement = BigInt(req.maxAmountRequired);
+                                        const maxUsdcPriceAtomicBigInt = BigInt(maxUsdcPriceAtomic);
+                                        if (requirement <= maxUsdcPriceAtomicBigInt) {
+                                            shouldInclude = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // If conversion fails, skip this requirement
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if (shouldInclude) {
+                        priceFilteredServices.push(item);
+                    }
+                }
+            }
+            // Format the filtered services
+            const filtered = await Promise.all(priceFilteredServices.map(async (item) => {
+                const accepts = Array.isArray(item.accepts) ? item.accepts : [];
+                const matchingAccept = accepts.find(req => req.network === walletNetwork);
+                // Format amount if available
+                let formattedMaxAmount = matchingAccept?.maxAmountRequired;
+                if (matchingAccept?.maxAmountRequired && matchingAccept?.asset) {
+                    formattedMaxAmount = await (0, utils_1.formatPaymentOption)({
+                        asset: matchingAccept.asset,
+                        maxAmountRequired: matchingAccept.maxAmountRequired,
+                        network: matchingAccept.network,
+                    }, walletProvider);
+                }
+                return {
+                    resource: item.resource,
+                    description: matchingAccept?.description || "",
+                    cost: formattedMaxAmount,
+                    ...(matchingAccept?.outputSchema?.input && {
+                        input: matchingAccept.outputSchema.input,
+                    }),
+                    ...(matchingAccept?.outputSchema?.output && {
+                        output: matchingAccept.outputSchema.output,
+                    }),
+                    ...(item.metadata && item.metadata.length > 0 && { metadata: item.metadata }),
+                };
+            }));
+            return JSON.stringify({
+                success: true,
+                walletNetwork,
+                total: services.items.length,
+                returned: filtered.length,
+                items: filtered,
+            }, null, 2);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return JSON.stringify({
+                error: true,
+                message: "Failed to list x402 services",
+                details: message,
+            }, null, 2);
+        }
+    }
     /**
      * Makes a basic HTTP request to an API endpoint.
      *
@@ -64,19 +177,32 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     data: response.data,
                 }, null, 2);
             }
+            // Check if wallet network matches any available payment options
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            const availableNetworks = response.data.accepts.map(option => option.network);
+            const hasMatchingNetwork = availableNetworks.includes(walletNetwork);
+            let paymentOptionsText = `The wallet network ${walletNetwork} does not match any available payment options (${availableNetworks.join(", ")}).`;
+            // Format payment options for matching networks
+            if (hasMatchingNetwork) {
+                const matchingOptions = response.data.accepts.filter(option => option.network === walletNetwork);
+                const formattedOptions = await Promise.all(matchingOptions.map(option => (0, utils_1.formatPaymentOption)(option, walletProvider)));
+                paymentOptionsText = `The payment options are: ${formattedOptions.join(", ")}`;
+            }
             return JSON.stringify({
                 status: "error_402_payment_required",
                 acceptablePaymentOptions: response.data.accepts,
                 nextSteps: [
                     "Inform the user that the requested server replied with a 402 Payment Required response.",
-                    `The payment options are: ${response.data.accepts.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
-                    "Ask the user if they want to retry the request with payment.",
-                    `Use retry_http_request_with_x402 to retry the request with payment.`,
+                    paymentOptionsText,
+                    hasMatchingNetwork ? "Ask the user if they want to retry the request with payment." : "",
+                    hasMatchingNetwork
+                        ? `Use retry_http_request_with_x402 to retry the request with payment.`
+                        : "",
                 ],
             });
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
+            return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
     /**
@@ -88,6 +214,16 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async retryWithX402(walletProvider, args) {
         try {
+            // Check network compatibility before attempting payment
+            const walletNetwork = (0, utils_1.getX402Network)(walletProvider.getNetwork());
+            const selectedNetwork = args.selectedPaymentOption.network;
+            if (walletNetwork !== selectedNetwork) {
+                return JSON.stringify({
+                    error: true,
+                    message: "Network mismatch",
+                    details: `Wallet is on ${walletNetwork} but payment requires ${selectedNetwork}`,
+                }, null, 2);
+            }
             // Make the request with payment handling
             const account = walletProvider.toSigner();
             const paymentSelector = (accepts) => {
@@ -108,7 +244,9 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                 }
                 return accepts[0];
             };
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account, paymentSelector);
+            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            account, paymentSelector);
             const response = await api.request({
                 url: args.url,
                 method: args.method ?? "GET",
@@ -142,7 +280,7 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
             });
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
+            return (0, utils_1.handleHttpError)(error, args.url);
         }
     }
     /**
@@ -155,6 +293,7 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
     async makeHttpRequestWithX402(walletProvider, args) {
         try {
             const account = walletProvider.toSigner();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account);
             const response = await api.request({
                 url: args.url,
@@ -183,42 +322,21 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
             }, null, 2);
         }
         catch (error) {
-            return this.handleHttpError(error, args.url);
-        }
-    }
-    /**
-     * 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
-     */
-    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 (0, utils_1.handleHttpError)(error, args.url);
         }
-        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);
     }
 }
 exports.X402ActionProvider = X402ActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "discover_x402_services",
+        description: "Discover available x402 services. Optionally filter by a maximum price in whole units of USDC (only USDC payment options will be considered when filter is applied).",
+        schema: schemas_1.ListX402ServicesSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], X402ActionProvider.prototype, "discoverX402Services", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "make_http_request",
@@ -272,6 +390,7 @@ This action combines both steps into one, which means:
 - No chance to review payment details before paying
 - No confirmation step
 - Automatic payment processing
+- Assumes payment option is compatible with wallet network
 
 EXAMPLES:
 - Production: make_http_request_with_x402("https://api.example.com/data")