@coinbase/agentkit 0.9.1 → 0.10.1

package/dist/action-providers/zerion/zerionActionProvider.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { Network } from "../../network";
+import { ActionProvider } from "../actionProvider";
+import { GetWalletPortfolioSchema } from "./schemas";
+/**
+ * Configuration options for the ZerionActionProvider.
+ */
+export interface ZerionActionProviderConfig {
+    /**
+     * Zerion API Key. Request new at https://zerion.io/api
+     */
+    apiKey?: string;
+}
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+export declare class ZerionActionProvider extends ActionProvider {
+    private readonly apiKey;
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config?: ZerionActionProviderConfig);
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getPortfolioOverview(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getFungiblePositions(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+export declare const zerionActionProvider: (config?: ZerionActionProviderConfig) => ZerionActionProvider;

package/dist/action-providers/zerion/zerionActionProvider.js

@@ -0,0 +1,159 @@
+"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.zerionActionProvider = exports.ZerionActionProvider = void 0;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+class ZerionActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config = {}) {
+        super("zerion", []);
+        const apiKey = config.apiKey || process.env.ZERION_API_KEY;
+        if (!apiKey) {
+            throw new Error("ZERION_API_KEY is not configured.");
+        }
+        const encodedKey = Buffer.from(`${apiKey}:`).toString("base64");
+        this.apiKey = encodedKey;
+    }
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getPortfolioOverview(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/portfolio?filter[positions]=no_filter&currency=usd`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPortfolioData)(data);
+        }
+        catch (error) {
+            return `Error fetching portfolio overview for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getFungiblePositions(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/positions?filter[positions]=no_filter&currency=usd&filter[trash]=only_non_trash&sort=value`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPositionsData)(data);
+        }
+        catch (error) {
+            return `Error fetching fungible positions for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        // all protocol networks
+        return network.protocolFamily === "evm";
+    }
+}
+exports.ZerionActionProvider = ZerionActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_portfolio_overview",
+        description: `
+    Fetches and summarizes a crypto wallet's portfolio in USD. 
+    The tool returns a human-readable overview of the wallet's total value, value distribution across blockchains, position types (e.g., staked, deposited), and 24-hour performance change. 
+    Useful for providing quick insights into a wallet's DeFi and cross-chain holdings.
+    Input:
+    - walletAddress: The wallet address to fetch portfolio overview for.
+    Output a structured text summary with:
+    - Total portfolio value in USD
+    - 24h percentage change in value
+    - Breakdown of value by position types (e.g., wallet, deposited, staked, locked, borrowed)
+    - Top 5 chains by value distribution
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getPortfolioOverview", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_fungible_positions",
+        description: `
+    Retrieves and summarizes a wallet's fungible token holdings. 
+    For each token, it includes metadata such as symbol, name, holding value, associated protocol (if applicable), and the type of position (e.g., deposit, wallet, reward). 
+    The summary also reports the total USD value of all qualifying token positions.
+    Input:
+    - walletAddress: The wallet address to fetch fungible positions for.
+    Output a readable text summary including:
+    - All token positions
+    - For each: token name, symbol, USD value, chain, position type
+    - If applicable: protocol used and type of action (e.g. staked, deposited via protocol)
+    - A final total value in USD across all included positions
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getFungiblePositions", null);
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+const zerionActionProvider = (config) => new ZerionActionProvider(config);
+exports.zerionActionProvider = zerionActionProvider;

package/dist/action-providers/zerion/zerionActionProvider.test.d.ts

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

package/dist/action-providers/zerion/zerionActionProvider.test.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zerionActionProvider_1 = require("./zerionActionProvider");
+const utils_1 = require("./utils");
+// Mocks for fetch and utils
+global.fetch = jest.fn();
+jest.mock("./utils", () => ({
+    formatPortfolioData: jest.fn(() => "formatted portfolio"),
+    formatPositionsData: jest.fn(() => "formatted positions"),
+}));
+describe("ZerionActionProvider", () => {
+    const mockApiKey = "test-api-key";
+    const originalEnv = process.env.ZERION_API_KEY;
+    const mockFungiblePositionResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/positions/",
+        },
+        data: [
+            {
+                type: "positions",
+                id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                attributes: {
+                    parent: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                    protocol: null,
+                    pool_address: "0x109830a1aaad605bbf02a9dfa7b0b92ec2fb7daa",
+                    name: "Asset",
+                    group_id: "0a771a0064dad468045899032c7fb01a971f973f7dff0a5cdc3ce199f45e94d7",
+                    position_type: "deposit",
+                    quantity: {
+                        int: "12345678",
+                        decimals: 5,
+                        float: 123.45678,
+                        numeric: "123.45678",
+                    },
+                    value: 5.384656557642683,
+                    price: 0.043615722,
+                    changes: {
+                        absolute_1d: 0.272309794,
+                        percent_1d: 5.326512552079021,
+                    },
+                    fungible_info: {
+                        name: "Bankless BED Index",
+                        symbol: "BED",
+                        description: "The BED index is meant to track crypto’s top 3 investab...",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        flags: {
+                            verified: true,
+                        },
+                        implementations: [
+                            {
+                                chain_id: "ethereum",
+                                address: "0x2af1df3ab0ab157e1e2ad8f88a7d04fbea0c7dc6",
+                                decimals: 18,
+                            },
+                        ],
+                    },
+                    flags: {
+                        displayable: true,
+                        is_trash: true,
+                    },
+                    updated_at: "2023-11-10T23:00:00Z",
+                    updated_at_block: 0,
+                    application_metadata: {
+                        name: "AAVE",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        url: "https://app.aave.com/",
+                    },
+                },
+                relationships: {
+                    chain: {
+                        links: {
+                            related: "https://api.zerion.io/v1/chains/polygon",
+                        },
+                        data: {
+                            type: "chains",
+                            id: "polygon",
+                        },
+                    },
+                    fungible: {
+                        links: {
+                            related: "https://api.zerion.io/v1/fungibles/0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                        data: {
+                            type: "fungibles",
+                            id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                    },
+                    dapp: {
+                        data: {
+                            type: "dapps",
+                            id: "aave-v3",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+    const mockPortfolioResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/portfolio",
+        },
+        data: {
+            type: "portfolio",
+            id: "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990",
+            attributes: {
+                positions_distribution_by_type: {
+                    wallet: 1864.774102420957,
+                    deposited: 78.04192492782934,
+                    borrowed: 0.9751475798305564,
+                    locked: 5.780032725068765,
+                    staked: 66.13183205505294,
+                },
+                positions_distribution_by_chain: {
+                    arbitrum: 458.3555051522226,
+                    aurora: 72.01031337463428,
+                    avalanche: 17.128850607339444,
+                    base: 55.01550749900544,
+                    "binance-smart-chain": 5.561075880033699,
+                    celo: 31.293849330045006,
+                    ethereum: 1214.009900354964,
+                    fantom: 84.58514074264951,
+                    linea: 8.258227109505139,
+                    optimism: 573.032664994399,
+                    polygon: 64.31407562634853,
+                    xdai: 113.1679493137936,
+                    "zksync-era": 9.451002156306377,
+                },
+                total: {
+                    positions: 2017.4858230069574,
+                },
+                changes: {
+                    absolute_1d: 102.0271468171374,
+                    percent_1d: 5.326512552079021,
+                },
+            },
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.ZERION_API_KEY = mockApiKey;
+    });
+    afterAll(() => {
+        process.env.ZERION_API_KEY = originalEnv;
+    });
+    it("should throw if no API key is provided", () => {
+        delete process.env.ZERION_API_KEY;
+        expect(() => new zerionActionProvider_1.ZerionActionProvider()).toThrow("ZERION_API_KEY is not configured.");
+    });
+    it("should use provided API key from config", () => {
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: "foo" });
+        expect(provider).toBeDefined();
+    });
+    // supportsNetwork tests
+    const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+    it("should support the protocol family", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+    });
+    it("should not support other protocol families", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "other-protocol-family" })).toBe(false);
+    });
+    it("should handle invalid network objects", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "invalid-protocol" })).toBe(false);
+        expect(provider.supportsNetwork({})).toBe(false);
+    });
+    describe("getPortfolioOverview", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getPortfolioOverview({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockPortfolioResponse),
+            });
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(utils_1.formatPortfolioData).toHaveBeenCalledWith(mockPortfolioResponse.data);
+            expect(result).toBe("formatted portfolio");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching portfolio overview/);
+        });
+    });
+    describe("getFungiblePositions", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getFungiblePositions({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockFungiblePositionResponse),
+            });
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(utils_1.formatPositionsData).toHaveBeenCalledWith(mockFungiblePositionResponse.data);
+            expect(result).toBe("formatted positions");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching fungible positions/);
+        });
+    });
+});

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