@coinbase/agentkit 0.0.0-nightly-20251115210411 → 0.0.0-nightly-20251117210447

package/README.md

@@ -505,6 +505,23 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Sushi</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>find-token</code></td>
+    <td width="768">Searches the Sushi Data API for up to 10 matching tokens by symbol or address.</td>
+</tr>
+<tr>
+    <td width="200"><code>quote</code></td>
+    <td width="768">Fetches an off-chain swap quote between ERC20 or native assets using the Sushi Swap API.</td>
+</tr>
+<tr>
+    <td width="200"><code>swap</code></td>
+    <td width="768">Executes a Sushi-routed swap after validating balances and approvals, returning the transaction hash.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Twitter</strong></summary>
 <table width="100%">
 <tr>

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

@@ -22,6 +22,7 @@ export * from "./morpho";
 export * from "./opensea";
 export * from "./spl";
 export * from "./superfluid";
+export * from "./sushi";
 export * from "./truemarkets";
 export * from "./twitter";
 export * from "./wallet";

package/dist/action-providers/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./morpho"), exports);
 __exportStar(require("./opensea"), exports);
 __exportStar(require("./spl"), exports);
 __exportStar(require("./superfluid"), exports);
+__exportStar(require("./sushi"), exports);
 __exportStar(require("./truemarkets"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);

package/dist/action-providers/sushi/constants.d.ts

@@ -0,0 +1,35 @@
+export declare const routeProcessor9Abi_Route: readonly [{
+    readonly name: "Route";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "from";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "to";
+    }, {
+        readonly type: "address";
+        readonly name: "tokenIn";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "tokenOut";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amountIn";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amountOut";
+    }, {
+        readonly type: "int256";
+        readonly name: "slippage";
+    }, {
+        readonly type: "uint32";
+        readonly name: "referralCode";
+        readonly indexed: true;
+    }, {
+        readonly type: "bytes32";
+        readonly name: "diagnosticsFirst32";
+    }];
+}];

package/dist/action-providers/sushi/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeProcessor9Abi_Route = void 0;
+const viem_1 = require("viem");
+exports.routeProcessor9Abi_Route = (0, viem_1.parseAbi)([
+    "event Route(address indexed from, address to, address indexed tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut, int256 slippage, uint32 indexed referralCode, bytes32 diagnosticsFirst32)",
+]);

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

@@ -0,0 +1,4 @@
+export * from "./sushiDataSchemas";
+export * from "./sushiDataActionProvider";
+export * from "./sushiRouterSchemas";
+export * from "./sushiRouterActionProvider";

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

@@ -0,0 +1,20 @@
+"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("./sushiDataSchemas"), exports);
+__exportStar(require("./sushiDataActionProvider"), exports);
+__exportStar(require("./sushiRouterSchemas"), exports);
+__exportStar(require("./sushiRouterActionProvider"), exports);

package/dist/action-providers/sushi/sushiDataActionProvider.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { FindTokenSchema } from "./sushiDataSchemas";
+/**
+ * SushiDataActionProvider is an action provider for Sushi.
+ *
+ * This provider is used for any action that uses the Sushi Data API.
+ */
+export declare class SushiDataActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SushiDataActionProvider class.
+     */
+    constructor();
+    /**
+     * Swaps a specified amount of a from token to a to token for the wallet.
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the swap details.
+     */
+    findToken(walletProvider: EvmWalletProvider, args: z.infer<typeof FindTokenSchema>): Promise<string>;
+    /**
+     * Custom action providers are supported on all networks
+     *
+     * @param network - The network to checkpointSaver
+     * @returns True if the network is supported, false otherwise
+     */
+    supportsNetwork(network: Network): boolean;
+}
+export declare const sushiDataActionProvider: () => SushiDataActionProvider;

package/dist/action-providers/sushi/sushiDataActionProvider.js

@@ -0,0 +1,113 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sushiDataActionProvider = exports.SushiDataActionProvider = void 0;
+const zod_1 = require("zod");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const sushiDataSchemas_1 = require("./sushiDataSchemas");
+const evm_1 = require("sushi/evm");
+const viem_1 = require("viem");
+/**
+ * SushiDataActionProvider is an action provider for Sushi.
+ *
+ * This provider is used for any action that uses the Sushi Data API.
+ */
+class SushiDataActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SushiDataActionProvider class.
+     */
+    constructor() {
+        super("sushi-data", []);
+    }
+    /**
+     * Swaps a specified amount of a from token to a to token for the wallet.
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the swap details.
+     */
+    async findToken(walletProvider, args) {
+        try {
+            const chainId = Number((await walletProvider.getNetwork()).chainId);
+            if (!(0, evm_1.isEvmChainId)(chainId)) {
+                return `Unsupported chainId: ${chainId}`;
+            }
+            const request = await fetch(`${evm_1.SUSHI_DATA_API_HOST}/graphql`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+                body: `{"query":"query { tokenList(chainId: ${chainId}, first: 10, search: \\"${args.search}\\") { address symbol name decimals } }"}`,
+            });
+            const response = await request.json();
+            const schema = zod_1.z.object({
+                data: zod_1.z.object({
+                    tokenList: zod_1.z.array(zod_1.z.object({
+                        address: zod_1.z.string().refine(val => (0, viem_1.isAddress)(val, { strict: false })),
+                        symbol: zod_1.z.string(),
+                        name: zod_1.z.string(),
+                        decimals: zod_1.z.number(),
+                    })),
+                }),
+            });
+            const result = schema.safeParse(response);
+            if (!result.success) {
+                return `Error parsing response: ${result.error.message}`;
+            }
+            const tokens = result.data.data.tokenList;
+            const chain = (0, evm_1.getEvmChainById)(chainId);
+            let message = `Found ${tokens.length} tokens on ${chain.shortName}:`;
+            tokens.forEach(token => {
+                message += `\n- ${token.symbol} (${token.name}) - ${token.address}`;
+            });
+            return message;
+        }
+        catch (error) {
+            return `Error finding tokens: ${error}`;
+        }
+    }
+    /**
+     * Custom action providers are supported on all networks
+     *
+     * @param network - The network to checkpointSaver
+     * @returns True if the network is supported, false otherwise
+     */
+    supportsNetwork(network) {
+        if (network.protocolFamily !== "evm" || !network.chainId) {
+            return false;
+        }
+        return (0, evm_1.isEvmChainId)(Number(network.chainId));
+    }
+}
+exports.SushiDataActionProvider = SushiDataActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "find-token",
+        description: `This tool finds tokens (erc20) using the Sushi Data API
+It takes the following inputs:
+- Search: Either the token symbol (either full or partial) or token address to search for
+
+Important notes:
+- Only returns the first 10 tokens found
+- Always use the full token symbol for better results
+- Always use this tool to verify the token address if you are not sure about the address
+`,
+        schema: sushiDataSchemas_1.FindTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SushiDataActionProvider.prototype, "findToken", null);
+const sushiDataActionProvider = () => new SushiDataActionProvider();
+exports.sushiDataActionProvider = sushiDataActionProvider;

package/dist/action-providers/sushi/sushiDataSchemas.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Input schema for find token action
+ */
+export declare const FindTokenSchema: z.ZodObject<{
+    search: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    search: string;
+}, {
+    search: string;
+}>;

package/dist/action-providers/sushi/sushiDataSchemas.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for find token action
+ */
+exports.FindTokenSchema = zod_1.z
+    .object({
+    search: zod_1.z
+        .string()
+        .min(2)
+        .describe("Either the (partial or complete) symbol OR the address of the token to find"),
+})
+    .strip()
+    .describe("Instructions for finding a token");

package/dist/action-providers/sushi/sushiRouterActionProvider.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ActionProvider } from "../actionProvider";
+import { SushiQuoteSchema, SushiSwapSchema } from "./sushiRouterSchemas";
+import { Network } from "../../network";
+/**
+ * SushiRouterActionProvider is an action provider for Sushi.
+ *
+ * This provider is used for any action that uses the Sushi Router API.
+ */
+export declare class SushiRouterActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SushiRouterActionProvider class.
+     */
+    constructor();
+    /**
+     * Swaps a specified amount of a from token to a to token for the wallet.
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the swap details.
+     */
+    swap(walletProvider: EvmWalletProvider, args: z.infer<typeof SushiSwapSchema>): Promise<string>;
+    /**
+     * Gets a quote for a specified amount of a from token to a to token
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the quote details.
+     */
+    quote(walletProvider: EvmWalletProvider, args: z.infer<typeof SushiQuoteSchema>): Promise<string>;
+    /**
+     * Custom action providers are supported on all networks
+     *
+     * @param network - The network to checkpointSaver
+     * @returns True if the network is supported, false otherwise
+     */
+    supportsNetwork(network: Network): boolean;
+}
+export declare const sushiRouterActionProvider: () => SushiRouterActionProvider;

package/dist/action-providers/sushi/sushiRouterActionProvider.js

@@ -0,0 +1,386 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sushiRouterActionProvider = exports.SushiRouterActionProvider = void 0;
+const zod_1 = require("zod");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const sushiRouterSchemas_1 = require("./sushiRouterSchemas");
+const evm_1 = require("sushi/evm");
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+/**
+ * SushiRouterActionProvider is an action provider for Sushi.
+ *
+ * This provider is used for any action that uses the Sushi Router API.
+ */
+class SushiRouterActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SushiRouterActionProvider class.
+     */
+    constructor() {
+        super("sushi-router", []);
+    }
+    /**
+     * Swaps a specified amount of a from token to a to token for the wallet.
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the swap details.
+     */
+    async swap(walletProvider, args) {
+        try {
+            const chainId = Number((await walletProvider.getNetwork()).chainId);
+            // Compatible chainId is expected since it should be pre-checked in supportsNetwork
+            if (!(0, evm_1.isSwapApiSupportedChainId)(chainId)) {
+                return `Unsupported chainId: ${chainId}`;
+            }
+            const chain = (0, evm_1.getEvmChainById)(chainId);
+            const decimalsIn = await fetchDecimals({ walletProvider, token: args.fromAssetAddress });
+            if (!decimalsIn.success) {
+                return decimalsIn.message;
+            }
+            const amountIn = (0, viem_1.parseUnits)(args.amount, decimalsIn.decimals);
+            // First fetch to see if the swap is even possible
+            const firstSwap = await handleGetSwap({
+                amount: amountIn,
+                chainId,
+                tokenIn: args.fromAssetAddress,
+                tokenOut: args.toAssetAddress,
+                maxSlippage: args.maxSlippage,
+                recipient: walletProvider.getAddress(),
+            });
+            if (firstSwap.swap.status !== evm_1.RouteStatus.Success) {
+                return firstSwap.message;
+            }
+            // Check if the wallet has enough balance to perform the swap
+            const balance = await handleBalance({
+                walletProvider,
+                token: firstSwap.swap.tokenFrom,
+                minAmount: amountIn,
+            });
+            if (!balance.success) {
+                return balance.message;
+            }
+            const approval = await handleApproval({
+                walletProvider,
+                token: args.fromAssetAddress,
+                to: firstSwap.swap.tx.to,
+                amount: amountIn,
+            });
+            if (!approval.success) {
+                return approval.message;
+            }
+            // Refetch in case the route changed during approval
+            const secondSwap = await handleGetSwap({
+                amount: amountIn,
+                chainId,
+                tokenIn: args.fromAssetAddress,
+                tokenOut: args.toAssetAddress,
+                maxSlippage: args.maxSlippage,
+                recipient: walletProvider.getAddress(),
+            });
+            if (secondSwap.swap.status !== evm_1.RouteStatus.Success) {
+                return secondSwap.message;
+            }
+            const swapHash = await walletProvider.sendTransaction({
+                from: secondSwap.swap.tx.from,
+                to: secondSwap.swap.tx.to,
+                data: secondSwap.swap.tx.data,
+                value: BigInt(secondSwap.swap.tx.value || 0),
+            });
+            const swapReceipt = await walletProvider.waitForTransactionReceipt(swapHash);
+            if (swapReceipt.status === "reverted" || swapReceipt.status === "failed") {
+                return `Swap failed: Transaction Reverted.\n - Transaction hash: ${swapHash}\n - Transaction link: ${chain.getTransactionUrl(swapHash)}`;
+            }
+            // Find the Route event log, which includes the actual amountOut
+            const [routeLog] = swapReceipt.logs
+                .filter(log => (0, viem_1.encodeEventTopics)({
+                abi: constants_1.routeProcessor9Abi_Route,
+                eventName: "Route",
+            })[0] === log.topics[0])
+                .map(log => (0, viem_1.decodeEventLog)({
+                abi: constants_1.routeProcessor9Abi_Route,
+                data: log.data,
+                topics: log.topics,
+            }));
+            return `Swapped ${(0, viem_1.formatUnits)(routeLog.args.amountIn, secondSwap.swap.tokenFrom.decimals)} of ${secondSwap.swap.tokenFrom.symbol} (${args.fromAssetAddress}) for ${(0, viem_1.formatUnits)(routeLog.args.amountOut, secondSwap.swap.tokenTo.decimals)} of ${secondSwap.swap.tokenTo.symbol} (${args.toAssetAddress}) on ${chain.shortName}
+ - Transaction hash: ${swapHash}
+ - Transaction link: ${chain.getTransactionUrl(swapHash)}`;
+        }
+        catch (error) {
+            return `Error swapping tokens: ${error}`;
+        }
+    }
+    /**
+     * Gets a quote for a specified amount of a from token to a to token
+     *
+     * @param walletProvider - The wallet provider to swap the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the quote details.
+     */
+    async quote(walletProvider, args) {
+        try {
+            const chainId = Number((await walletProvider.getNetwork()).chainId);
+            // Compatible chainId is expected since it should be pre-checked in supportsNetwork
+            if (!(0, evm_1.isSwapApiSupportedChainId)(chainId)) {
+                return `Unsupported chainId: ${chainId}`;
+            }
+            const decimalsIn = await fetchDecimals({ walletProvider, token: args.fromAssetAddress });
+            if (!decimalsIn.success) {
+                return decimalsIn.message;
+            }
+            const amountIn = (0, viem_1.parseUnits)(args.amount, decimalsIn.decimals);
+            const swap = await handleGetSwap({
+                amount: amountIn,
+                chainId,
+                tokenIn: args.fromAssetAddress,
+                tokenOut: args.toAssetAddress,
+                maxSlippage: 0.0005, // 0.05%
+                recipient: walletProvider.getAddress(),
+            });
+            return swap.message;
+        }
+        catch (error) {
+            return `Error quoting for tokens: ${error}`;
+        }
+    }
+    /**
+     * Custom action providers are supported on all networks
+     *
+     * @param network - The network to checkpointSaver
+     * @returns True if the network is supported, false otherwise
+     */
+    supportsNetwork(network) {
+        if (network.protocolFamily !== "evm" || !network.chainId) {
+            return false;
+        }
+        return (0, evm_1.isSwapApiSupportedChainId)(Number(network.chainId));
+    }
+}
+exports.SushiRouterActionProvider = SushiRouterActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "swap",
+        description: `This tool will swap a specified amount of a 'from token' (erc20) to a 'to token' (erc20) for the wallet.
+It takes the following inputs:
+- The human-readable amount of the 'from token' to swap
+- The from token address to trade
+- The token address to receive from the swap
+- The maximum slippage allowed for the swap, where 0 is 0% and 1 is 100%, the default is 0.005 (0.05%)
+
+Important notes:
+- The native asset (ie 'eth' on 'ethereum-mainnet') is represented by ${evm_1.nativeAddress} (not the wrapped native asset!)
+- Fetch a quote first before the swap action. Stop, ask the user if they want to proceed. If the user answers affirmatively, then swap
+- If you are not absolutely sure about token addresses, either use an action to fetch the token address or ask the user
+`,
+        schema: sushiRouterSchemas_1.SushiSwapSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SushiRouterActionProvider.prototype, "swap", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "quote",
+        description: `This tool will fetch a quote for a specified amount of a 'from token' (erc20 or native ETH) to a 'to token' (erc20 or native ETH).
+It takes the following inputs:
+- The human-readable amount of the 'from token' to fetch a quote for
+- The from token address to fetch a quote for
+- The token address to receive from the quoted swap
+
+Important notes:
+- The native asset (ie 'eth' on 'ethereum-mainnet') is represented by ${evm_1.nativeAddress} (not the wrapped native asset!)
+- This action does not require any on-chain transactions or gas
+- If you are not 100% certain about token addresses, use an action to fetch the token address first or ask the user
+- NEVER assume that tokens have the same address on across networks (ie the address of 'usdc' on 'ethereum-mainnet' is different from 'usdc' on 'base-mainnet')
+`,
+        schema: sushiRouterSchemas_1.SushiQuoteSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SushiRouterActionProvider.prototype, "quote", null);
+/**
+ * Fetches the number of decimals for the token
+ *
+ * @param root0 - The input arguments for the action
+ * @param root0.walletProvider - The wallet provider to fetch the decimals from
+ * @param root0.token - The token address to fetch the decimals for
+ *
+ * @returns The number of decimals for the token
+ */
+async function fetchDecimals({ walletProvider, token, }) {
+    const chainId = Number((await walletProvider.getNetwork()).chainId);
+    if (!(0, evm_1.isSwapApiSupportedChainId)(chainId)) {
+        return {
+            success: false,
+            message: `Unsupported chainId: ${chainId}`,
+        };
+    }
+    if (token === evm_1.nativeAddress) {
+        return { success: true, decimals: evm_1.EvmNative.fromChainId(chainId).decimals };
+    }
+    const decimals = (await walletProvider.readContract({
+        address: token,
+        abi: viem_1.erc20Abi,
+        functionName: "decimals",
+    }));
+    return { success: true, decimals };
+}
+/**
+ * Checks if the wallet has enough balance to perform the swap
+ *
+ * @param root0 - The input arguments for the action
+ * @param root0.walletProvider - The wallet provider to fetch the balance from
+ * @param root0.token - The token address to fetch the balance for
+ * @param root0.token.address - The token address to fetch the balance for
+ * @param root0.token.symbol - The token symbol to fetch the balance for
+ * @param root0.token.decimals - The token decimals to fetch the balance for
+ * @param root0.minAmount - The minimum amount to check for
+ *
+ * @returns The balance of the wallet
+ */
+async function handleBalance({ walletProvider, token, minAmount, }) {
+    let balance;
+    if (token.address.toLowerCase() === evm_1.nativeAddress) {
+        balance = await walletProvider.getBalance();
+    }
+    else {
+        balance = (await walletProvider.readContract({
+            address: token.address,
+            abi: viem_1.erc20Abi,
+            functionName: "balanceOf",
+            args: [walletProvider.getAddress()],
+        }));
+    }
+    if (balance < minAmount) {
+        return {
+            success: false,
+            message: `Swap failed: Insufficient balance for ${token.symbol} (${token.address})
+ - Balance: ${(0, viem_1.formatUnits)(balance, token.decimals)}
+ - Required: ${(0, viem_1.formatUnits)(minAmount, token.decimals)}`,
+        };
+    }
+    return {
+        success: true,
+    };
+}
+/**
+ *
+ * Wraps the getSwap function, providing messages for possible states
+ *
+ * @param root0 - The input arguments for the action
+ * @param root0.amount - The amount to swap
+ * @param root0.chainId - The chainId to swap on
+ * @param root0.tokenIn - The input token address
+ * @param root0.tokenOut - The output token address
+ * @param root0.maxSlippage - The maximum slippage allowed
+ * @param root0.recipient - The recipient of the swap
+ *
+ * @returns The result of the swap and a message
+ */
+async function handleGetSwap({ amount, chainId, tokenIn, tokenOut, maxSlippage, recipient, }) {
+    if (!(0, evm_1.isRedSnwapperChainId)(chainId)) {
+        return {
+            swap: { status: evm_1.RouteStatus.NoWay },
+            message: `Unsupported chainId: ${chainId}`,
+        };
+    }
+    const swap = await (0, evm_1.getSwap)({
+        amount,
+        chainId,
+        tokenIn,
+        tokenOut,
+        maxSlippage,
+        sender: recipient,
+        recipient,
+    });
+    const chain = (0, evm_1.getEvmChainById)(chainId);
+    if (swap.status === evm_1.RouteStatus.NoWay) {
+        return {
+            swap,
+            message: `No route found to swap ${amount} of ${tokenIn} for ${tokenOut} on ${chain.shortName}`,
+        };
+    }
+    if (swap.status === evm_1.RouteStatus.Partial) {
+        return {
+            swap,
+            message: `Found a partial quote for ${swap.tokenFrom.symbol} -> ${swap.tokenTo.symbol}. Swapping the full amount is not possible.
+ - AmountIn: ${(0, viem_1.formatUnits)(BigInt(swap.amountIn), swap.tokenFrom.decimals)}
+ - AmountOut: ${(0, viem_1.formatUnits)(BigInt(swap.assumedAmountOut), swap.tokenTo.decimals)}`,
+        };
+    }
+    return {
+        swap,
+        message: `Found a quote for ${swap.tokenFrom.symbol} (${swap.tokenFrom.address}) -> ${swap.tokenTo.symbol} (${swap.tokenTo.address})
+ - AmountIn: ${(0, viem_1.formatUnits)(BigInt(swap.amountIn), swap.tokenFrom.decimals)} ${swap.tokenFrom.symbol}
+ - AmountOut: ${(0, viem_1.formatUnits)(BigInt(swap.assumedAmountOut), swap.tokenTo.decimals)} ${swap.tokenTo.symbol}`,
+    };
+}
+/**
+ *
+ * Handles the approval for the token
+ *
+ * @param root0 - The input arguments for the action
+ * @param root0.walletProvider - The wallet provider to handle the approval with
+ * @param root0.token - The token address to approve
+ * @param root0.to - The address to approve the token to
+ * @param root0.amount - The amount to approve
+ *
+ * @returns Either success: true on success or success: false with a message containing the reason for failure
+ */
+async function handleApproval({ walletProvider, token, to, amount, }) {
+    // No need to approve if the token is the native token
+    if (token.toLowerCase() === evm_1.nativeAddress) {
+        return { success: true };
+    }
+    // Check if the wallet already has enough allowance
+    const allowance = (await walletProvider.readContract({
+        address: token,
+        abi: viem_1.erc20Abi,
+        functionName: "allowance",
+        args: [walletProvider.getAddress(), to],
+    }));
+    if (allowance >= amount) {
+        return { success: true };
+    }
+    // Exact approval
+    const approvalHash = await walletProvider.sendTransaction({
+        to: token,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: viem_1.erc20Abi,
+            functionName: "approve",
+            args: [to, BigInt(amount)],
+        }),
+    });
+    const approvalReceipt = await walletProvider.waitForTransactionReceipt(approvalHash);
+    const chainId = Number((await walletProvider.getNetwork()).chainId);
+    if (!(0, evm_1.isSwapApiSupportedChainId)(chainId)) {
+        return {
+            success: false,
+            message: `Unsupported chainId: ${chainId}`,
+        };
+    }
+    const chain = (0, evm_1.getEvmChainById)(chainId);
+    if (approvalReceipt.status === "reverted") {
+        return {
+            success: false,
+            message: `Swap failed: Approval Reverted.
+ - Transaction hash: ${approvalHash}
+ - Transaction link: ${chain.getTransactionUrl(approvalHash)}`,
+        };
+    }
+    return { success: true };
+}
+const sushiRouterActionProvider = () => new SushiRouterActionProvider();
+exports.sushiRouterActionProvider = sushiRouterActionProvider;

package/dist/action-providers/sushi/sushiRouterActionProvider.test.d.ts

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

package/dist/action-providers/sushi/sushiRouterActionProvider.test.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sushiRouterSchemas_1 = require("./sushiRouterSchemas");
+const evm_1 = require("sushi/evm");
+const sushiRouterActionProvider_1 = require("./sushiRouterActionProvider");
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+// Mock the entire module
+jest.mock("sushi/evm", () => {
+    const originalModule = jest.requireActual("sushi/evm");
+    return {
+        __esModule: true,
+        ...originalModule,
+        getSwap: jest.fn(originalModule.getSwap),
+    };
+});
+const mockedGetSwap = evm_1.getSwap;
+describe("Sushi Action Provider Input Schemas", () => {
+    describe("Swap Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid fromAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "invalid-address",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid toAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "invalid-address",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid maxSlippage (>1)", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 1.1,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid maxSlippage (<0)", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: -1.1,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("Quote Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid fromAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "invalid-address",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid toAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "invalid-address",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+});
+describe("Sushi Action Provider", () => {
+    let actionProvider;
+    let mockWallet;
+    const amountIn = BigInt(1000000);
+    const amountOut = BigInt(500000);
+    const nativeToken = {
+        address: evm_1.nativeAddress,
+        symbol: "ETH",
+        name: "Ether",
+        decimals: 18,
+    };
+    const tokenIn = {
+        address: "0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa",
+        symbol: "TIN",
+        name: "Token In",
+        decimals: 18,
+    };
+    const tokenOut = {
+        address: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
+        symbol: "TOU",
+        name: "Token Out",
+        decimals: 18,
+    };
+    const user = "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF";
+    const txHash = "0xhash";
+    const chainId = 1;
+    const getRouteLog = ({ tokenIn, tokenOut, amountIn, amountOut, }) => [
+        {
+            data: (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("address to, address tokenOut, uint256 amountIn, uint256 amountOut, int256 slippage, bytes32 diagnosticsFirst32"), [user, tokenOut.address, amountIn, amountOut, 0n, `0x${"00".repeat(32)}`]),
+            topics: (0, viem_1.encodeEventTopics)({
+                abi: constants_1.routeProcessor9Abi_Route,
+                eventName: "Route",
+                args: {
+                    from: user,
+                    tokenIn: tokenIn.address,
+                    referralCode: 0,
+                },
+            }),
+        },
+    ];
+    const getSuccessfullSwapResponse = async ({ tokenIn, amountIn, tokenOut, amountOut, }) => ({
+        amountIn: String(amountIn),
+        assumedAmountOut: String(amountOut),
+        priceImpact: 0,
+        status: evm_1.RouteStatus.Success,
+        swapPrice: 1,
+        tokens: [tokenIn, tokenOut],
+        tokenFrom: tokenIn,
+        tokenTo: tokenOut,
+        tx: {
+            to: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+            data: "0x",
+            from: user,
+            value: BigInt(0),
+            gas: "1000000",
+            gasPrice: 1000000000,
+        },
+    });
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new sushiRouterActionProvider_1.SushiRouterActionProvider();
+        mockWallet = {
+            readContract: jest.fn(),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getBalance: jest.fn(),
+            getNetwork: jest.fn().mockResolvedValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+                chainId: String(chainId),
+            }),
+            getAddress: jest.fn().mockReturnValue(user),
+        };
+    });
+    describe("swap", () => {
+        it("should successfully perform a swap (token -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             * 3. Mock the readContract which checks for the approval (0, not approved)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn)
+                .mockResolvedValueOnce(BigInt(0));
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            /*
+             * 1. Mock the waitForTransactionReceipt to return success for the approval tx
+             * 2. Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+             */
+            mockWallet.waitForTransactionReceipt
+                .mockResolvedValueOnce({
+                status: "success",
+            })
+                .mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(3); // Decimals + Balance + Approval
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(2); // Approval + Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped ${(0, viem_1.formatUnits)(amountIn, tokenIn.decimals)} of ${tokenIn.symbol} (${tokenIn.address}) for ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)} of ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`Transaction hash: ${txHash}`);
+            expect(result).toContain(`Transaction link: ${(0, evm_1.getEvmChainById)(chainId).getTransactionUrl(txHash)}`);
+            expect(result).toContain(`on ${(0, evm_1.getEvmChainById)(chainId).shortName}`);
+        });
+        it("should successfully perform a swap (native -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: nativeToken.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            // Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+            mockWallet.getBalance.mockResolvedValue(amountIn);
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            // Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+            mockWallet.waitForTransactionReceipt.mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn: nativeToken,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn: nativeToken,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(1);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(0); // No balance check nor approval
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(1); // Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped ${(0, viem_1.formatUnits)(amountIn, nativeToken.decimals)} of ${nativeToken.symbol} (${nativeToken.address}) for ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)} of ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`Transaction hash: ${txHash}`);
+            expect(result).toContain(`Transaction link: ${(0, evm_1.getEvmChainById)(chainId).getTransactionUrl(txHash)}`);
+            expect(result).toContain(`on ${(0, evm_1.getEvmChainById)(chainId).shortName}`);
+        });
+        it("should fail if there isn't enough balance (native)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: nativeToken.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            // Mock the readContract which checks for the balance of the fromAssetAddress token (99, not enough balance)
+            mockWallet.getBalance.mockResolvedValue(amountIn - BigInt(1));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(1);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(0);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Swap failed: Insufficient balance for ${nativeToken.symbol} (${nativeToken.address})`);
+        });
+        it("should fail if there isn't enough balance (token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             */
+            mockWallet.readContract.mockResolvedValueOnce(18).mockResolvedValue(amountIn - BigInt(1));
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(2);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Swap failed: Insufficient balance for ${tokenIn.symbol} (${tokenIn.address})`);
+        });
+        it("should not approve if already approved", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             * 3. Mock the readContract which checks for the approval (1000000, approved)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn)
+                .mockResolvedValueOnce(amountIn);
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            // Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+            mockWallet.waitForTransactionReceipt.mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(3); // Decimals + Balance + Allowance
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(1); // Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped`);
+        });
+        it("should fail if there's no route", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks for decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn);
+            mockedGetSwap.mockReturnValue(new Promise(r => r({
+                status: evm_1.RouteStatus.NoWay,
+            })));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(1); // Decimals
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`No route found to swap ${amountIn} of ${tokenIn.address} for ${tokenOut.address}`);
+        });
+    });
+    describe("quote", () => {
+        it("should successfully fetch a quote (token -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+            };
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.quote(mockWallet, args);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Found a quote for ${tokenIn.symbol} (${tokenIn.address}) -> ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`AmountIn: ${(0, viem_1.formatUnits)(amountIn, tokenIn.decimals)}`);
+            expect(result).toContain(`AmountOut: ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)}`);
+        });
+    });
+});

package/dist/action-providers/sushi/sushiRouterSchemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for asset swap action
+ */
+export declare const SushiSwapSchema: z.ZodObject<{
+    fromAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    amount: z.ZodString;
+    toAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    maxSlippage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    fromAssetAddress: `0x${string}`;
+    toAssetAddress: `0x${string}`;
+    maxSlippage: number;
+}, {
+    amount: string;
+    fromAssetAddress: string;
+    toAssetAddress: string;
+    maxSlippage?: number | undefined;
+}>;
+/**
+ * Input schema for quote action
+ */
+export declare const SushiQuoteSchema: z.ZodObject<{
+    fromAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    amount: z.ZodString;
+    toAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    fromAssetAddress: `0x${string}`;
+    toAssetAddress: `0x${string}`;
+}, {
+    amount: string;
+    fromAssetAddress: string;
+    toAssetAddress: string;
+}>;

package/dist/action-providers/sushi/sushiRouterSchemas.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SushiQuoteSchema = exports.SushiSwapSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for asset swap action
+ */
+exports.SushiSwapSchema = zod_1.z
+    .object({
+    fromAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the input asset"),
+    amount: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Invalid number format")
+        .describe("The amount of the input asset to swap, in the human readable format"),
+    toAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the output asset"),
+    maxSlippage: zod_1.z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .default(0.005) // 0.05%
+        .describe("The maximum slippage allowed for the swap, where 0 is 0% and 1 is 100%"),
+})
+    .strip()
+    .describe("Instructions for trading assets");
+/**
+ * Input schema for quote action
+ */
+exports.SushiQuoteSchema = zod_1.z
+    .object({
+    fromAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the input asset"),
+    amount: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Invalid number format")
+        .describe("The amount of the input asset to get a quote for"),
+    toAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the output asset"),
+})
+    .strip()
+    .describe("Instructions for fetching a quote for a trade");

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-20251115210411",
+  "version": "0.0.0-nightly-20251117210447",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -48,6 +48,7 @@
     "md5": "^2.3.0",
     "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
+    "sushi": "6.2.1",
     "@ensofinance/sdk": "^2.0.6",
     "twitter-api-v2": "^1.18.2",
     "viem": "^2.22.16",