@coinbase/agentkit 0.0.0-nightly-20250918210440 → 0.0.0-nightly-20251001210424

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,11 +3,14 @@ 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";
+export * from "./clanker";
 export * from "./compound";
 export * from "./defillama";
+export * from "./enso";
 export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
@@ -29,8 +32,8 @@ export * from "./flaunch";
 export * from "./onramp";
 export * from "./vaultsfyi";
 export * from "./x402";
+export * from "./yelay";
 export * from "./zerion";
 export * from "./zerodev";
 export * from "./zeroX";
 export * from "./zora";
-export * from "./clanker";

package/dist/action-providers/index.js

@@ -19,11 +19,14 @@ __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);
+__exportStar(require("./clanker"), exports);
 __exportStar(require("./compound"), exports);
 __exportStar(require("./defillama"), exports);
+__exportStar(require("./enso"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
@@ -45,8 +48,8 @@ __exportStar(require("./flaunch"), exports);
 __exportStar(require("./onramp"), exports);
 __exportStar(require("./vaultsfyi"), exports);
 __exportStar(require("./x402"), exports);
+__exportStar(require("./yelay"), 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/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/utils.d.ts

@@ -1,6 +1,6 @@
 import { Network } from "../../network";
 import { AxiosError } from "axios";
-import { EvmWalletProvider } from "../../wallet-providers";
+import { WalletProvider } from "../../wallet-providers";
 /**
  * Supported network types for x402 protocol
  */
@@ -35,7 +35,7 @@ export declare function formatPaymentOption(option: {
     asset: string;
     maxAmountRequired: string;
     network: string;
-}, walletProvider: EvmWalletProvider): Promise<string>;
+}, walletProvider: WalletProvider): Promise<string>;
 /**
  * Checks if an asset is USDC on any supported network.
  *
@@ -43,7 +43,7 @@ export declare function formatPaymentOption(option: {
  * @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;
+export declare function isUsdcAsset(asset: string, walletProvider: WalletProvider): boolean;
 /**
  * Converts whole units to atomic units for a given asset.
  *
@@ -52,4 +52,4 @@ export declare function isUsdcAsset(asset: string, walletProvider: EvmWalletProv
  * @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>;
+export declare function convertWholeUnitsToAtomic(wholeUnits: number, asset: string, walletProvider: WalletProvider): Promise<string | null>;

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

@@ -8,6 +8,14 @@ exports.convertWholeUnitsToAtomic = convertWholeUnitsToAtomic;
 const utils_1 = require("../erc20/utils");
 const constants_1 = require("../erc20/constants");
 const viem_1 = require("viem");
+const wallet_providers_1 = require("../../wallet-providers");
+/**
+ * USDC token addresses for Solana networks
+ */
+const SOLANA_USDC_ADDRESSES = {
+    "solana-devnet": "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+    "solana-mainnet": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+};
 /**
  * Converts the internal network ID to the format expected by the x402 protocol.
  *
@@ -75,7 +83,8 @@ async function formatPaymentOption(option, 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 isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
         const networkId = walletNetwork.networkId;
         const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
         if (tokenSymbols) {
@@ -99,7 +108,17 @@ async function formatPaymentOption(option, walletProvider) {
             // 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
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        // Check if the asset is USDC on Solana networks
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress && asset === usdcAddress) {
+            // USDC has 6 decimals on Solana
+            const formattedAmount = (0, viem_1.formatUnits)(BigInt(maxAmountRequired), 6);
+            return `${formattedAmount} USDC on ${network} network`;
+        }
+    }
+    // Fallback to original format for non-EVM/SVM networks or when token details can't be fetched
     return `${asset} ${maxAmountRequired} on ${network} network`;
 }
 /**
@@ -112,13 +131,21 @@ async function formatPaymentOption(option, walletProvider) {
 function isUsdcAsset(asset, walletProvider) {
     const walletNetwork = walletProvider.getNetwork();
     const isEvmNetwork = walletNetwork.protocolFamily === "evm";
-    if (isEvmNetwork) {
+    const isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
         const networkId = walletNetwork.networkId;
         const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
         if (tokenSymbols && tokenSymbols.USDC) {
             return asset.toLowerCase() === tokenSymbols.USDC.toLowerCase();
         }
     }
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress) {
+            return asset === usdcAddress;
+        }
+    }
     return false;
 }
 /**
@@ -133,7 +160,8 @@ 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 isSvmNetwork = walletNetwork.protocolFamily === "svm";
+    if (isEvmNetwork && walletProvider instanceof wallet_providers_1.EvmWalletProvider) {
         const networkId = walletNetwork.networkId;
         const tokenSymbols = constants_1.TOKEN_ADDRESSES_BY_SYMBOLS[networkId];
         if (tokenSymbols) {
@@ -155,6 +183,15 @@ async function convertWholeUnitsToAtomic(wholeUnits, asset, walletProvider) {
             // If we can't get token details, fall back to assuming 18 decimals
         }
     }
-    // Fallback to 18 decimals for unknown tokens or non-EVM networks
+    if (isSvmNetwork && walletProvider instanceof wallet_providers_1.SvmWalletProvider) {
+        // Check if the asset is USDC on Solana networks
+        const networkId = walletNetwork.networkId;
+        const usdcAddress = SOLANA_USDC_ADDRESSES[networkId];
+        if (usdcAddress && asset === usdcAddress) {
+            // USDC has 6 decimals on Solana
+            return (0, viem_1.parseUnits)(wholeUnits.toString(), 6).toString();
+        }
+    }
+    // Fallback to 18 decimals for unknown tokens or non-EVM/SVM networks
     return (0, viem_1.parseUnits)(wholeUnits.toString(), 18).toString();
 }

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

@@ -2,11 +2,11 @@ import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
 import { HttpRequestSchema, RetryWithX402Schema, DirectX402RequestSchema, ListX402ServicesSchema } from "./schemas";
-import { EvmWalletProvider } from "../../wallet-providers";
+import { WalletProvider } from "../../wallet-providers";
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
  */
-export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider> {
+export declare class X402ActionProvider extends ActionProvider<WalletProvider> {
     /**
      * Creates a new instance of X402ActionProvider.
      * Initializes the provider with x402 capabilities.
@@ -19,7 +19,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @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>;
+    discoverX402Services(walletProvider: WalletProvider, args: z.infer<typeof ListX402ServicesSchema>): Promise<string>;
     /**
      * Makes a basic HTTP request to an API endpoint.
      *
@@ -27,7 +27,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @param args - The request parameters including URL, method, headers, and body
      * @returns A JSON string containing the response or error details
      */
-    makeHttpRequest(walletProvider: EvmWalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
+    makeHttpRequest(walletProvider: WalletProvider, args: z.infer<typeof HttpRequestSchema>): Promise<string>;
     /**
      * Retries a request with x402 payment after receiving a 402 response.
      *
@@ -35,7 +35,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @param args - The request parameters including URL, method, headers, body, and payment option
      * @returns A JSON string containing the response with payment details or error information
      */
-    retryWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
+    retryWithX402(walletProvider: WalletProvider, args: z.infer<typeof RetryWithX402Schema>): Promise<string>;
     /**
      * Makes an HTTP request with automatic x402 payment handling.
      *
@@ -43,7 +43,7 @@ export declare class X402ActionProvider extends ActionProvider<EvmWalletProvider
      * @param args - The request parameters including URL, method, headers, and body
      * @returns A JSON string containing the response with optional payment details or error information
      */
-    makeHttpRequestWithX402(walletProvider: EvmWalletProvider, args: z.infer<typeof DirectX402RequestSchema>): Promise<string>;
+    makeHttpRequestWithX402(walletProvider: WalletProvider, args: z.infer<typeof DirectX402RequestSchema>): Promise<string>;
     /**
      * Checks if the action provider supports the given network.
      *