@coinbase/agentkit 0.0.0-nightly-20250831210403 → 0.0.0-nightly-20250902210403

package/README.md

@@ -524,6 +524,15 @@ 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>
+<summary><strong>ZeroX</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>get_swap_price_quote_from_0x</code></td>
+    <td width="768">Fetches a price quote for swapping between two tokens using the 0x API.</td>
+</tr>
+<tr>
+    <td width="200"><code>execute_swap_on_0x</code></td>
+    <td width="768">Executes a token swap between two tokens using the 0x API.</td>
 </tr>
 </table>
 </details>

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

@@ -31,4 +31,5 @@ export * from "./vaultsfyi";
 export * from "./x402";
 export * from "./zerion";
 export * from "./zerodev";
+export * from "./zeroX";
 export * from "./zora";

package/dist/action-providers/index.js

@@ -47,4 +47,5 @@ __exportStar(require("./vaultsfyi"), exports);
 __exportStar(require("./x402"), exports);
 __exportStar(require("./zerion"), exports);
 __exportStar(require("./zerodev"), exports);
+__exportStar(require("./zeroX"), exports);
 __exportStar(require("./zora"), exports);

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

@@ -0,0 +1 @@
+export * from "./zeroXActionProvider";

package/dist/action-providers/zeroX/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zeroXActionProvider"), exports);

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+/**
+ * Input schema for getting a swap price.
+ */
+export declare const GetSwapPriceSchema: z.ZodObject<{
+    sellToken: z.ZodString;
+    buyToken: z.ZodString;
+    sellAmount: z.ZodString;
+    slippageBps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    swapFeeRecipient: z.ZodOptional<z.ZodString>;
+    swapFeeBps: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    slippageBps: number;
+    buyToken: string;
+    sellToken: string;
+    sellAmount: string;
+    swapFeeBps: number;
+    swapFeeRecipient?: string | undefined;
+}, {
+    buyToken: string;
+    sellToken: string;
+    sellAmount: string;
+    slippageBps?: number | undefined;
+    swapFeeRecipient?: string | undefined;
+    swapFeeBps?: number | undefined;
+}>;
+/**
+ * Input schema for executing a swap.
+ */
+export declare const ExecuteSwapSchema: z.ZodObject<{
+    sellToken: z.ZodString;
+    buyToken: z.ZodString;
+    sellAmount: z.ZodString;
+    slippageBps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    swapFeeRecipient: z.ZodOptional<z.ZodString>;
+    swapFeeBps: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    slippageBps: number;
+    buyToken: string;
+    sellToken: string;
+    sellAmount: string;
+    swapFeeBps: number;
+    swapFeeRecipient?: string | undefined;
+}, {
+    buyToken: string;
+    sellToken: string;
+    sellAmount: string;
+    slippageBps?: number | undefined;
+    swapFeeRecipient?: string | undefined;
+    swapFeeBps?: number | undefined;
+}>;

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteSwapSchema = exports.GetSwapPriceSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for getting a swap price.
+ */
+exports.GetSwapPriceSchema = zod_1.z
+    .object({
+    sellToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to sell"),
+    buyToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to buy"),
+    sellAmount: zod_1.z
+        .string()
+        .describe("The amount of sellToken to sell in whole units (e.g., 1.5 WETH, 10 USDC)"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(10000)
+        .optional()
+        .default(100)
+        .describe("The maximum acceptable slippage in basis points (0-10000, default: 100)"),
+    swapFeeRecipient: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The wallet address to receive an affiliate fee on the trade"),
+    swapFeeBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(1000)
+        .default(100)
+        .describe("The amount in basis points (0-1000) of the sellToken to charge as trading fee (defaults to 100 = 1%), only used if swapFeeRecipient is provided"),
+})
+    .strip()
+    .describe("Get a price quote for swapping one token for another");
+/**
+ * Input schema for executing a swap.
+ */
+exports.ExecuteSwapSchema = zod_1.z
+    .object({
+    sellToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to sell"),
+    buyToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to buy"),
+    sellAmount: zod_1.z
+        .string()
+        .describe("The amount of sellToken to sell in whole units (e.g., 1.5 WETH, 10 USDC)"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(10000)
+        .optional()
+        .default(100)
+        .describe("The maximum acceptable slippage in basis points (0-10000, default: 100)"),
+    swapFeeRecipient: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The wallet address to receive an affiliate fee on the trade"),
+    swapFeeBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(1000)
+        .default(100)
+        .describe("The amount in basis points (0-1000) of the sellToken to charge as trading fee (defaults to 100 = 1%), only used if swapFeeRecipient is provided"),
+})
+    .strip()
+    .describe("Execute a swap between two tokens");

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

@@ -0,0 +1,23 @@
+import { EvmWalletProvider } from "../../wallet-providers";
+export declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+export declare function isNativeEth(token: string): boolean;
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+export declare function getTokenDetails(walletProvider: EvmWalletProvider, fromToken: string, toToken: string): Promise<{
+    fromTokenDecimals: number;
+    toTokenDecimals: number;
+    fromTokenName: string;
+    toTokenName: string;
+}>;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERMIT2_ADDRESS = void 0;
+exports.isNativeEth = isNativeEth;
+exports.getTokenDetails = getTokenDetails;
+const viem_1 = require("viem");
+// Permit2 contract address is the same across all networks
+exports.PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+function isNativeEth(token) {
+    return token.toLowerCase() === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+}
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+async function getTokenDetails(walletProvider, fromToken, toToken) {
+    // Initialize default values for native ETH
+    let fromTokenDecimals = 18;
+    let fromTokenName = "ETH";
+    let toTokenDecimals = 18;
+    let toTokenName = "ETH";
+    // Prepare multicall contracts array
+    const contracts = [];
+    const contractIndexMap = {
+        fromDecimals: -1,
+        fromName: -1,
+        toDecimals: -1,
+        toName: -1,
+    };
+    // Add from token contracts if not native ETH
+    if (!isNativeEth(fromToken)) {
+        contractIndexMap.fromDecimals = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.fromName = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Add to token contracts if not native ETH
+    if (!isNativeEth(toToken)) {
+        contractIndexMap.toDecimals = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.toName = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Execute multicall if there are contracts to call
+    if (contracts.length > 0) {
+        try {
+            const results = await walletProvider.getPublicClient().multicall({
+                contracts,
+            });
+            // Extract from token details
+            if (contractIndexMap.fromDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.fromDecimals];
+                const nameResult = results[contractIndexMap.fromName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    fromTokenDecimals = decimalsResult.result;
+                    fromTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for fromToken ${fromToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+            // Extract to token details
+            if (contractIndexMap.toDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.toDecimals];
+                const nameResult = results[contractIndexMap.toName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    toTokenDecimals = decimalsResult.result;
+                    toTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for toToken ${toToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read token details via multicall. Error: ${error}`);
+        }
+    }
+    return { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName };
+}

package/dist/action-providers/zeroX/zeroXActionProvider.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { GetSwapPriceSchema, ExecuteSwapSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Configuration for the ZeroXActionProvider.
+ */
+export interface ZeroXActionProviderConfig {
+    /**
+     * The API key to use for 0x API requests.
+     */
+    apiKey?: string;
+}
+/**
+ * 0x API Action Provider for token swaps.
+ * Requires a 0x API key.
+ */
+export declare class ZeroXActionProvider extends ActionProvider<EvmWalletProvider> {
+    #private;
+    /**
+     * Constructor for the ZeroXActionProvider.
+     *
+     * @param config - Configuration for the provider.
+     */
+    constructor(config: ZeroXActionProviderConfig);
+    /**
+     * Gets a price quote for swapping one token for another.
+     *
+     * @param walletProvider - The wallet provider to get information from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the price quote.
+     */
+    getSwapPrice(walletProvider: EvmWalletProvider, args: z.infer<typeof GetSwapPriceSchema>): Promise<string>;
+    /**
+     * Executes a token swap using the 0x API.
+     *
+     * @param walletProvider - The wallet provider to use for the swap.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the result of the swap.
+     */
+    executeSwap(walletProvider: EvmWalletProvider, args: z.infer<typeof ExecuteSwapSchema>): Promise<string>;
+    /**
+     * Checks if the ZeroX action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the ZeroX action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+/**
+ * Creates a new ZeroXActionProvider with the provided configuration.
+ *
+ * @param config - Optional configuration for the provider.
+ * @returns A new ZeroXActionProvider.
+ */
+export declare const zeroXActionProvider: (config: ZeroXActionProviderConfig) => ZeroXActionProvider;

package/dist/action-providers/zeroX/zeroXActionProvider.js

@@ -0,0 +1,405 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ZeroXActionProvider_apiKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zeroXActionProvider = exports.ZeroXActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const wallet_providers_1 = require("../../wallet-providers");
+const viem_1 = require("viem");
+const utils_1 = require("./utils");
+/**
+ * 0x API Action Provider for token swaps.
+ * Requires a 0x API key.
+ */
+class ZeroXActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZeroXActionProvider.
+     *
+     * @param config - Configuration for the provider.
+     */
+    constructor(config) {
+        super("zerox", []);
+        _ZeroXActionProvider_apiKey.set(this, void 0);
+        /**
+         * Checks if the ZeroX action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the ZeroX action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+        const apiKey = config.apiKey || process.env.ZEROX_API_KEY;
+        if (!apiKey) {
+            throw new Error("0x API key not provided.");
+        }
+        __classPrivateFieldSet(this, _ZeroXActionProvider_apiKey, apiKey, "f");
+    }
+    /**
+     * Gets a price quote for swapping one token for another.
+     *
+     * @param walletProvider - The wallet provider to get information from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the price quote.
+     */
+    async getSwapPrice(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const chainId = network.chainId;
+        if (!chainId)
+            throw new Error("Chain ID not available from wallet provider");
+        try {
+            // Get token details
+            const { fromTokenDecimals: sellTokenDecimals, toTokenDecimals: buyTokenDecimals, fromTokenName: sellTokenName, toTokenName: buyTokenName, } = await (0, utils_1.getTokenDetails)(walletProvider, args.sellToken, args.buyToken);
+            // Convert sell amount to base units
+            const sellAmount = (0, viem_1.parseUnits)(args.sellAmount, sellTokenDecimals).toString();
+            // Create URL for the price API request
+            const url = new URL("https://api.0x.org/swap/permit2/price");
+            url.searchParams.append("chainId", chainId.toString());
+            url.searchParams.append("sellToken", args.sellToken);
+            url.searchParams.append("buyToken", args.buyToken);
+            url.searchParams.append("sellAmount", sellAmount);
+            url.searchParams.append("taker", walletProvider.getAddress());
+            url.searchParams.append("slippageBps", args.slippageBps.toString());
+            if (args.swapFeeRecipient) {
+                url.searchParams.append("swapFeeRecipient", args.swapFeeRecipient);
+                url.searchParams.append("swapFeeBps", args.swapFeeBps.toString());
+                url.searchParams.append("swapFeeToken", args.sellToken);
+            }
+            // Make the request
+            const response = await fetch(url.toString(), {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    "0x-api-key": __classPrivateFieldGet(this, _ZeroXActionProvider_apiKey, "f"),
+                    "0x-version": "v2",
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return JSON.stringify({
+                    success: false,
+                    error: `Error fetching swap price: ${response.status} ${response.statusText} - ${errorText}`,
+                });
+            }
+            const data = await response.json();
+            // Format the response
+            const formattedResponse = {
+                success: true,
+                sellAmount: (0, viem_1.formatUnits)(BigInt(sellAmount), sellTokenDecimals),
+                sellTokenName: sellTokenName,
+                sellToken: args.sellToken,
+                buyAmount: (0, viem_1.formatUnits)(data.buyAmount, buyTokenDecimals),
+                minBuyAmount: data.minBuyAmount ? (0, viem_1.formatUnits)(data.minBuyAmount, buyTokenDecimals) : null,
+                buyTokenName: buyTokenName,
+                buyToken: args.buyToken,
+                slippageBps: args.slippageBps,
+                liquidityAvailable: data.liquidityAvailable,
+                balanceEnough: data.issues?.balance === null,
+                priceOfBuyTokenInSellToken: (Number((0, viem_1.formatUnits)(BigInt(sellAmount), sellTokenDecimals)) /
+                    Number((0, viem_1.formatUnits)(data.buyAmount, buyTokenDecimals))).toString(),
+                priceOfSellTokenInBuyToken: (Number((0, viem_1.formatUnits)(data.buyAmount, buyTokenDecimals)) /
+                    Number((0, viem_1.formatUnits)(BigInt(sellAmount), sellTokenDecimals))).toString(),
+            };
+            return JSON.stringify(formattedResponse);
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: `Error fetching swap price: ${error}`,
+            });
+        }
+    }
+    /**
+     * Executes a token swap using the 0x API.
+     *
+     * @param walletProvider - The wallet provider to use for the swap.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the result of the swap.
+     */
+    async executeSwap(walletProvider, args) {
+        // Sanity checks
+        const network = walletProvider.getNetwork();
+        const chainId = network.chainId;
+        if (!chainId)
+            throw new Error("Chain ID not available from wallet provider");
+        try {
+            // Get token details
+            const { fromTokenDecimals: sellTokenDecimals, toTokenDecimals: buyTokenDecimals, fromTokenName: sellTokenName, toTokenName: buyTokenName, } = await (0, utils_1.getTokenDetails)(walletProvider, args.sellToken, args.buyToken);
+            // Convert sell amount to base units
+            const sellAmount = (0, viem_1.parseUnits)(args.sellAmount, sellTokenDecimals).toString();
+            // Get the wallet address
+            const walletAddress = walletProvider.getAddress();
+            // Fetch price quote first
+            const priceUrl = new URL("https://api.0x.org/swap/permit2/price");
+            priceUrl.searchParams.append("chainId", chainId.toString());
+            priceUrl.searchParams.append("sellToken", args.sellToken);
+            priceUrl.searchParams.append("buyToken", args.buyToken);
+            priceUrl.searchParams.append("sellAmount", sellAmount);
+            priceUrl.searchParams.append("taker", walletAddress);
+            priceUrl.searchParams.append("slippageBps", args.slippageBps.toString());
+            if (args.swapFeeRecipient) {
+                priceUrl.searchParams.append("swapFeeRecipient", args.swapFeeRecipient);
+                priceUrl.searchParams.append("swapFeeBps", args.swapFeeBps.toString());
+                priceUrl.searchParams.append("swapFeeToken", args.sellToken);
+            }
+            const priceResponse = await fetch(priceUrl.toString(), {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    "0x-api-key": __classPrivateFieldGet(this, _ZeroXActionProvider_apiKey, "f"),
+                    "0x-version": "v2",
+                },
+            });
+            if (!priceResponse.ok) {
+                const errorText = await priceResponse.text();
+                return JSON.stringify({
+                    success: false,
+                    error: `Error fetching swap price: ${priceResponse.status} ${priceResponse.statusText} - ${errorText}`,
+                });
+            }
+            const priceData = await priceResponse.json();
+            // Check if liquidity is available
+            if (priceData.liquidityAvailable === false) {
+                return JSON.stringify({
+                    success: false,
+                    error: "No liquidity available for this swap.",
+                });
+            }
+            // Check if balance of sell token is enough
+            if (priceData.balance != null) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Insufficient balance of sell token ${priceData.balance.token}. Requested to swap ${priceData.balance.expected}, but balance is only ${priceData.balance.actual}.`,
+                });
+            }
+            // Check if permit2 approval is needed for ERC20 tokens
+            // Only needed once per token per address
+            let approvalTxHash = null;
+            if (priceData.issues?.allowance) {
+                try {
+                    approvalTxHash = await walletProvider.sendTransaction({
+                        to: args.sellToken,
+                        data: (0, viem_1.encodeFunctionData)({
+                            abi: viem_1.erc20Abi,
+                            functionName: "approve",
+                            args: [utils_1.PERMIT2_ADDRESS, viem_1.maxUint256],
+                        }),
+                    });
+                    await walletProvider.waitForTransactionReceipt(approvalTxHash);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        success: false,
+                        error: `Error approving token: ${error}`,
+                    });
+                }
+            }
+            // Fetch the swap quote
+            const quoteUrl = new URL("https://api.0x.org/swap/permit2/quote");
+            quoteUrl.searchParams.append("chainId", chainId.toString());
+            quoteUrl.searchParams.append("sellToken", args.sellToken);
+            quoteUrl.searchParams.append("buyToken", args.buyToken);
+            quoteUrl.searchParams.append("sellAmount", sellAmount);
+            quoteUrl.searchParams.append("taker", walletAddress);
+            quoteUrl.searchParams.append("slippageBps", args.slippageBps.toString());
+            if (args.swapFeeRecipient) {
+                quoteUrl.searchParams.append("swapFeeRecipient", args.swapFeeRecipient);
+                quoteUrl.searchParams.append("swapFeeBps", args.swapFeeBps.toString());
+                quoteUrl.searchParams.append("swapFeeToken", args.sellToken);
+            }
+            const quoteResponse = await fetch(quoteUrl.toString(), {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    "0x-api-key": __classPrivateFieldGet(this, _ZeroXActionProvider_apiKey, "f"),
+                    "0x-version": "v2",
+                },
+            });
+            if (!quoteResponse.ok) {
+                const errorText = await quoteResponse.text();
+                return JSON.stringify({
+                    success: false,
+                    error: `Error fetching swap quote: ${quoteResponse.status} ${quoteResponse.statusText} - ${errorText}`,
+                });
+            }
+            const quoteData = await quoteResponse.json();
+            // Sign Permit2.eip712 returned from quote
+            let signature;
+            if (quoteData.permit2?.eip712) {
+                try {
+                    // For LegacyCdpWalletProvider, remove EIP712Domain to avoid ambiguous primary types
+                    const types = walletProvider instanceof wallet_providers_1.LegacyCdpWalletProvider
+                        ? (() => {
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                            const { EIP712Domain, ...rest } = quoteData.permit2.eip712.types;
+                            return rest;
+                        })()
+                        : quoteData.permit2.eip712.types;
+                    const typedData = {
+                        domain: quoteData.permit2.eip712.domain,
+                        types,
+                        primaryType: quoteData.permit2.eip712.primaryType,
+                        message: quoteData.permit2.eip712.message,
+                    };
+                    signature = await walletProvider.signTypedData(typedData);
+                    // Append sig length and sig data to transaction.data
+                    if (signature && quoteData.transaction?.data) {
+                        const signatureLengthInHex = (0, viem_1.numberToHex)((0, viem_1.size)(signature), {
+                            signed: false,
+                            size: 32,
+                        });
+                        const transactionData = quoteData.transaction.data;
+                        const sigLengthHex = signatureLengthInHex;
+                        const sig = signature;
+                        quoteData.transaction.data = (0, viem_1.concat)([transactionData, sigLengthHex, sig]);
+                    }
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        success: false,
+                        error: `Error signing permit2 message: ${error}`,
+                    });
+                }
+            }
+            // Execute swap
+            try {
+                // Prepare transaction parameters
+                const txParams = {
+                    to: quoteData.transaction.to,
+                    data: quoteData.transaction.data,
+                    ...(quoteData?.transaction.gas ? { gas: BigInt(quoteData.transaction.gas) } : {}),
+                    ...(quoteData.transaction.value ? { value: BigInt(quoteData.transaction.value) } : {}),
+                };
+                // Send transaction
+                const txHash = await walletProvider.sendTransaction(txParams);
+                const receipt = await walletProvider.waitForTransactionReceipt(txHash);
+                if (receipt.status !== "complete" && receipt.status !== "success") {
+                    return JSON.stringify({
+                        success: false,
+                        ...(approvalTxHash ? { approvalTxHash } : {}),
+                        transactionHash: receipt.transactionHash,
+                        error: `Swap transaction failed`,
+                    });
+                }
+                // Format the response
+                const formattedResponse = {
+                    success: true,
+                    ...(approvalTxHash ? { approvalTxHash } : {}),
+                    transactionHash: receipt.transactionHash,
+                    sellAmount: (0, viem_1.formatUnits)(BigInt(sellAmount), sellTokenDecimals),
+                    sellTokenName: sellTokenName,
+                    sellToken: args.sellToken,
+                    buyAmount: (0, viem_1.formatUnits)(quoteData.buyAmount, buyTokenDecimals),
+                    minBuyAmount: quoteData.minBuyAmount
+                        ? (0, viem_1.formatUnits)(quoteData.minBuyAmount, buyTokenDecimals)
+                        : null,
+                    buyTokenName: buyTokenName,
+                    buyToken: args.buyToken,
+                    slippageBps: args.slippageBps,
+                    network: network.networkId,
+                };
+                return JSON.stringify(formattedResponse);
+            }
+            catch (error) {
+                return JSON.stringify({
+                    success: false,
+                    error: `Error sending swap transaction: ${error}`,
+                    ...(approvalTxHash ? { approvalTxHash } : {}),
+                });
+            }
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: `Error executing swap: ${error}`,
+            });
+        }
+    }
+}
+exports.ZeroXActionProvider = ZeroXActionProvider;
+_ZeroXActionProvider_apiKey = new WeakMap();
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_swap_price_quote_from_0x",
+        description: `
+This tool fetches a price quote for swapping between two tokens using the 0x API.
+
+It takes the following inputs:
+- sellToken: The contract address of the token to sell
+- buyToken: The contract address of the token to buy
+- sellAmount: The amount of sellToken to swap in whole units (e.g. 1 ETH or 10 USDC)
+- slippageBps: (Optional) Maximum allowed slippage in basis points (100 = 1%)
+- swapFeeRecipient: (Optional) The wallet address to receive affiliate trading fees
+- swapFeeBps: The amount in basis points (0-1000) to charge as affiliate fees (defaults to 100 = 1%), only used if swapFeeRecipient is provided
+
+Important notes:
+- The contract address for native ETH is "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+- This only fetches a price quote and does not execute a swap
+- Supported on all EVM networks compatible with 0x API
+- Use sellToken units exactly as provided, do not convert to wei or any other units
+`,
+        schema: schemas_1.GetSwapPriceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZeroXActionProvider.prototype, "getSwapPrice", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "execute_swap_on_0x",
+        description: `
+This tool executes a token swap between two tokens using the 0x API.
+
+It takes the following inputs:
+- sellToken: The contract address of the token to sell
+- buyToken: The contract address of the token to buy
+- sellAmount: The amount of sellToken to swap in whole units (e.g. 1 ETH or 10 USDC)
+- slippageBps: (Optional) Maximum allowed slippage in basis points (100 = 1%)
+- swapFeeRecipient: (Optional) The wallet address to receive affiliate trading fees
+- swapFeeBps: The amount in basis points (0-1000) to charge as affiliate fees (defaults to 100 = 1%), only used if swapFeeRecipient is provided
+
+Important notes:
+- The contract address for native ETH is "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+- This will execute an actual swap transaction that sends tokens from your wallet
+- If needed, it will automatically approve the permit2 contract to spend the sell token
+- The approval transaction is only needed once per token
+- Ensure you have sufficient balance of the sell token before executing
+- The trade size might influence the excecution price depending on available liquidity 
+- First fetch a price quote and only execute swap if you are happy with the indicated price
+- Supported on all EVM networks compatible with 0x API
+- Use sellToken units exactly as provided, do not convert to wei or any other units
+`,
+        schema: schemas_1.ExecuteSwapSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZeroXActionProvider.prototype, "executeSwap", null);
+/**
+ * Creates a new ZeroXActionProvider with the provided configuration.
+ *
+ * @param config - Optional configuration for the provider.
+ * @returns A new ZeroXActionProvider.
+ */
+const zeroXActionProvider = (config) => new ZeroXActionProvider(config);
+exports.zeroXActionProvider = zeroXActionProvider;

package/dist/action-providers/zeroX/zeroXActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/zeroX/zeroXActionProvider.test.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zeroXActionProvider_1 = require("./zeroXActionProvider");
+const schemas_1 = require("./schemas");
+// Mock the fetch function
+global.fetch = jest.fn();
+describe("ZeroX Schema Validation", () => {
+    it("should validate GetSwapPrice schema with valid input", () => {
+        const validInput = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+    });
+    it("should fail validation with invalid address format", () => {
+        const invalidInput = {
+            sellToken: "invalid-address",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should use default slippageBps when not provided", () => {
+        const inputWithoutSlippage = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithoutSlippage);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.slippageBps).toBe(100); // Default value from schema
+        }
+    });
+    it("should validate swap fee parameters when both provided", () => {
+        const inputWithSwapFees = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            swapFeeBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithSwapFees);
+        expect(result.success).toBe(true);
+    });
+    it("should validate when only swapFeeRecipient provided (swapFeeBps defaults to 100)", () => {
+        const inputWithOnlyRecipient = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeBps: 100,
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithOnlyRecipient);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.swapFeeBps).toBe(100); // Default value
+        }
+    });
+    it("should fail validation when swapFeeBps exceeds maximum", () => {
+        const inputWithInvalidSwapFeeBps = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            swapFeeBps: 1500, // Exceeds maximum of 1000
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithInvalidSwapFeeBps);
+        expect(result.success).toBe(false);
+    });
+    it("should validate ExecuteSwap schema with valid input", () => {
+        const validInput = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.ExecuteSwapSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+    });
+});
+describe("ZeroX Action Provider", () => {
+    let provider;
+    let mockWalletProvider;
+    const MOCK_SELL_TOKEN = "0x1234567890123456789012345678901234567890";
+    const MOCK_BUY_TOKEN = "0x0987654321098765432109876543210987654321";
+    const MOCK_SELL_AMOUNT = "1.5";
+    const MOCK_CHAIN_ID = 1;
+    const MOCK_ADDRESS = "0xabcdef1234567890abcdef1234567890abcdef12";
+    beforeEach(() => {
+        provider = (0, zeroXActionProvider_1.zeroXActionProvider)({ apiKey: "test-api-key" });
+        mockWalletProvider = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                chainId: MOCK_CHAIN_ID,
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            }),
+            readContract: jest.fn(),
+            getPublicClient: jest.fn().mockReturnValue({
+                multicall: jest.fn(),
+            }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            signTypedData: jest.fn(),
+        };
+        // Reset mocks
+        global.fetch.mockReset();
+    });
+    describe("getSwapPrice", () => {
+        beforeEach(() => {
+            // Mock multicall for token details (decimals and names)
+            const mockMulticallResults = [
+                { status: "success", result: 18 }, // sellToken decimals
+                { status: "success", result: "TEST" }, // sellToken name
+                { status: "success", result: 6 }, // buyToken decimals
+                { status: "success", result: "USDC" }, // buyToken name
+            ];
+            mockWalletProvider.getPublicClient().multicall.mockResolvedValue(mockMulticallResults);
+            // Mock fetch for price API
+            const mockPriceResponse = {
+                buyAmount: "1000000", // 1 USDC with 6 decimals
+                minBuyAmount: "990000", // 0.99 USDC with 6 decimals
+                totalNetworkFee: "100000000000000", // 0.0001 ETH
+                issues: { balance: null },
+                liquidityAvailable: true,
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+        });
+        it("should get swap price successfully", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            // Verify fetch was called with correct URL params
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            expect(global.fetch.mock.calls[0][0]).toContain("api.0x.org/swap/permit2/price");
+            expect(global.fetch.mock.calls[0][0]).toContain(`chainId=${MOCK_CHAIN_ID}`);
+            expect(global.fetch.mock.calls[0][0]).toContain(`sellToken=${MOCK_SELL_TOKEN}`);
+            expect(global.fetch.mock.calls[0][0]).toContain(`buyToken=${MOCK_BUY_TOKEN}`);
+            // Verify response formatting
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.sellToken).toBe(MOCK_SELL_TOKEN);
+            expect(parsedResponse.sellTokenName).toBe("TEST");
+            expect(parsedResponse.buyToken).toBe(MOCK_BUY_TOKEN);
+            expect(parsedResponse.buyTokenName).toBe("USDC");
+            expect(parsedResponse.liquidityAvailable).toBe(true);
+            expect(parsedResponse.balanceEnough).toBe(true);
+            expect(parsedResponse.slippageBps).toBe(50);
+            expect(parsedResponse.buyAmount).toBeDefined();
+            expect(parsedResponse.minBuyAmount).toBeDefined();
+        });
+        it("should handle API errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: "Bad Request",
+                text: jest.fn().mockResolvedValueOnce("Invalid request parameters"),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should handle fetch errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockRejectedValueOnce(new Error("Network error"));
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should include swap fee parameters in API call when provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+                swapFeeBps: 100,
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called with swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(fetchUrl).toContain("swapFeeBps=100");
+            expect(fetchUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+        it("should not include swap fee parameters when not provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called without swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).not.toContain("swapFeeRecipient");
+            expect(fetchUrl).not.toContain("swapFeeBps");
+            expect(fetchUrl).not.toContain("swapFeeToken");
+        });
+        it("should include swap fee parameters with default swapFeeBps when only recipient provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called with swap fee parameters including default swapFeeBps
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(fetchUrl).toContain("swapFeeBps=100"); // Default value
+            expect(fetchUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+    });
+    describe("executeSwap", () => {
+        const MOCK_TX_HASH = "0xtxhash123456";
+        beforeEach(() => {
+            // Mock multicall for token details (decimals and names)
+            const mockMulticallResults = [
+                { status: "success", result: 18 }, // sellToken decimals
+                { status: "success", result: "TEST" }, // sellToken name
+                { status: "success", result: 6 }, // buyToken decimals
+                { status: "success", result: "USDC" }, // buyToken name
+            ];
+            mockWalletProvider.getPublicClient().multicall.mockResolvedValue(mockMulticallResults);
+            // Mock API responses
+            const mockPriceResponse = {
+                buyAmount: "1000000", // 1 USDC with 6 decimals
+                minBuyAmount: "990000", // 0.99 USDC with 6 decimals
+                totalNetworkFee: "100000000000000", // 0.0001 ETH
+                issues: null,
+                liquidityAvailable: true,
+            };
+            const mockQuoteResponse = {
+                buyAmount: "1000000",
+                minBuyAmount: "990000",
+                totalNetworkFee: "100000000000000",
+                transaction: {
+                    to: "0x0000000000000000000000000000000000000001",
+                    data: "0x12345678",
+                    value: "1500000000000000000", // 1.5 ETH
+                    gas: "300000",
+                    gasPrice: "20000000000",
+                },
+            };
+            // First fetch for price
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+            // Second fetch for quote
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockQuoteResponse),
+            });
+            // Mock transaction functions
+            mockWalletProvider.sendTransaction.mockResolvedValueOnce(MOCK_TX_HASH);
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({
+                transactionHash: MOCK_TX_HASH,
+                status: "success",
+            });
+        });
+        it("should execute swap successfully", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            // Verify API calls
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            expect(global.fetch.mock.calls[0][0]).toContain("api.0x.org/swap/permit2/price");
+            expect(global.fetch.mock.calls[1][0]).toContain("api.0x.org/swap/permit2/quote");
+            // Verify transaction was sent
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledTimes(1);
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            // Verify response formatting
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.sellToken).toBe(MOCK_SELL_TOKEN);
+            expect(parsedResponse.sellTokenName).toBe("TEST");
+            expect(parsedResponse.buyToken).toBe(MOCK_BUY_TOKEN);
+            expect(parsedResponse.buyTokenName).toBe("USDC");
+            expect(parsedResponse.transactionHash).toBe(MOCK_TX_HASH);
+            expect(parsedResponse.slippageBps).toBe(50);
+            expect(parsedResponse.network).toBe("ethereum-mainnet");
+        });
+        it("should handle price API errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: "Bad Request",
+                text: jest.fn().mockResolvedValueOnce("Invalid request parameters"),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should handle no liquidity available", async () => {
+            global.fetch.mockReset();
+            const mockPriceResponse = {
+                liquidityAvailable: false,
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("No liquidity available");
+        });
+        it("should include swap fee parameters in both API calls when provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+                swapFeeBps: 100,
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls include swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(priceUrl).toContain("swapFeeBps=100");
+            expect(priceUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(quoteUrl).toContain("swapFeeBps=100");
+            expect(quoteUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+        it("should not include swap fee parameters when not provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls exclude swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).not.toContain("swapFeeRecipient");
+            expect(priceUrl).not.toContain("swapFeeBps");
+            expect(priceUrl).not.toContain("swapFeeToken");
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).not.toContain("swapFeeRecipient");
+            expect(quoteUrl).not.toContain("swapFeeBps");
+            expect(quoteUrl).not.toContain("swapFeeToken");
+        });
+        it("should include swap fee parameters with default swapFeeBps when only recipient provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls include swap fee parameters with default swapFeeBps
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(priceUrl).toContain("swapFeeBps=100"); // Default value
+            expect(priceUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(quoteUrl).toContain("swapFeeBps=100"); // Default value
+            expect(quoteUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for evm networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false for non-evm networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.0.0-nightly-20250831210403",
+  "version": "0.0.0-nightly-20250902210403",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",