@coinbase/agentkit 0.1.1 → 0.1.2

package/README.md

@@ -12,6 +12,10 @@ AgentKit is a framework for easily enabling AI agents to take actions onchain. I
   - [Create an AgentKit instance with a specified wallet provider](#create-an-agentkit-instance-with-a-specified-wallet-provider)
   - [Create an AgentKit instance with a specified action providers](#create-an-agentkit-instance-with-a-specified-action-providers)
   - [Use the agent's actions with a framework extension. For example, using LangChain + OpenAI](#use-the-agents-actions-with-a-framework-extension-for-example-using-langchain--openai)
+- [Creating an Action Provider](#creating-an-action-provider)
+  - [Adding Actions to your Action Provider](#adding-actions-to-your-action-provider)
+  - [Adding Actions to your Action Provider that use a Wallet Provider](#adding-actions-to-your-action-provider-that-use-a-wallet-provider)
+  - [Adding an Action Provider to your AgentKit instance](#adding-an-action-provider-to-your-agentkit-instance)
 - [Wallet Providers](#wallet-providers)
   - [CdpWalletProvider](#cdpwalletprovider)
     - [Network Configuration](#network-configuration)
@@ -127,6 +131,21 @@ class MyActionProvider extends ActionProvider<WalletProvider> {
 
 Actions are defined as instance methods on the action provider class with the `@CreateAction` decorator. Actions can use a wallet provider or not and always return a Promise that resolves to a string.
 
+#### Required Typescript Compiler Options
+
+Creating actions with the `@CreateAction` decorator requires the following compilerOptions to be included in your project's `tsconfig.json`.
+
+```json
+{
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true
+    }
+} 
+```
+
+#### Steps to create an action
+
 1. Define the action schema. Action schemas are defined using the `zod` library.
 
 ```typescript

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { AlchemyTokenPricesBySymbolSchema, AlchemyTokenPricesByAddressSchema } from "./schemas";
+/**
+ * Configuration options for the AlchemyTokenPricesActionProvider.
+ */
+export interface AlchemyTokenPricesActionProviderConfig {
+    /**
+     * Alchemy API Key
+     */
+    apiKey?: string;
+}
+/**
+ * AlchemyTokenPricesActionProvider is an action provider for fetching token prices via the Alchemy Prices API.
+ * This provider enables querying current and historical token prices using symbols or addresses.
+ *
+ */
+export declare class AlchemyTokenPricesActionProvider extends ActionProvider {
+    private readonly apiKey;
+    private readonly baseUrl;
+    /**
+     * Creates a new instance of AlchemyTokenPricesActionProvider
+     *
+     * @param config - Configuration options including the API key
+     */
+    constructor(config?: AlchemyTokenPricesActionProviderConfig);
+    /**
+     * Fetch current token prices for one or more token symbols.
+     *
+     * @param args - The arguments containing an array of token symbols.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    tokenPricesBySymbol(args: z.infer<typeof AlchemyTokenPricesBySymbolSchema>): Promise<string>;
+    /**
+     * Fetch current token prices for one or more tokens identified by network and address pairs.
+     *
+     * @param args - The arguments containing an array of token network/address pairs.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    tokenPricesByAddress(args: z.infer<typeof AlchemyTokenPricesByAddressSchema>): Promise<string>;
+    /**
+     * Checks if the Alchemy Prices action provider supports the given network.
+     * Since the API works with multiple networks, this always returns true.
+     *
+     * @returns Always returns true.
+     */
+    supportsNetwork(): boolean;
+}
+/**
+ * Factory function to create a new AlchemyTokenPricesActionProvider instance.
+ *
+ * @param config - The configuration options for the provider.
+ * @returns A new instance of AlchemyTokenPricesActionProvider.
+ */
+export declare const alchemyTokenPricesActionProvider: (config?: AlchemyTokenPricesActionProviderConfig) => AlchemyTokenPricesActionProvider;

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.js

@@ -0,0 +1,173 @@
+"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.alchemyTokenPricesActionProvider = exports.AlchemyTokenPricesActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+/**
+ * AlchemyTokenPricesActionProvider is an action provider for fetching token prices via the Alchemy Prices API.
+ * This provider enables querying current and historical token prices using symbols or addresses.
+ *
+ */
+class AlchemyTokenPricesActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates a new instance of AlchemyTokenPricesActionProvider
+     *
+     * @param config - Configuration options including the API key
+     */
+    constructor(config = {}) {
+        super("alchemyTokenPrices", []);
+        config.apiKey || (config.apiKey = process.env.ALCHEMY_API_KEY);
+        if (!config.apiKey) {
+            throw new Error("ALCHEMY_API_KEY is not configured.");
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = "https://api.g.alchemy.com/prices/v1";
+    }
+    /**
+     * Fetch current token prices for one or more token symbols.
+     *
+     * @param args - The arguments containing an array of token symbols.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    async tokenPricesBySymbol(args) {
+        try {
+            // Build query parameters: for each symbol add a separate query parameter
+            const params = new URLSearchParams();
+            for (const symbol of args.symbols) {
+                params.append("symbols", symbol);
+            }
+            const url = `${this.baseUrl}/${this.apiKey}/tokens/by-symbol?${params.toString()}`;
+            const response = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            return `Successfully fetched token prices by symbol:\n${JSON.stringify(data, null, 2)}`;
+        }
+        catch (error) {
+            return `Error fetching token prices by symbol: ${error}`;
+        }
+    }
+    /**
+     * Fetch current token prices for one or more tokens identified by network and address pairs.
+     *
+     * @param args - The arguments containing an array of token network/address pairs.
+     * @returns A JSON string with the token prices or an error message.
+     */
+    async tokenPricesByAddress(args) {
+        try {
+            const url = `${this.baseUrl}/${this.apiKey}/tokens/by-address`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(args),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            return `Successfully fetched token prices by address:\n${JSON.stringify(data, null, 2)}`;
+        }
+        catch (error) {
+            return `Error fetching token prices by address: ${error}`;
+        }
+    }
+    /**
+     * Checks if the Alchemy Prices action provider supports the given network.
+     * Since the API works with multiple networks, this always returns true.
+     *
+     * @returns Always returns true.
+     */
+    supportsNetwork() {
+        return true;
+    }
+}
+exports.AlchemyTokenPricesActionProvider = AlchemyTokenPricesActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "token_prices_by_symbol",
+        description: `
+This tool will fetch current prices for one or more tokens using their symbols via the Alchemy Prices API.
+
+A successful response will return a JSON payload similar to:
+{
+  "data": [
+    {
+      "symbol": "ETH",
+      "prices": [
+        {
+          "currency": "usd",
+          "value": "2873.490923459",
+          "lastUpdatedAt": "2025-02-03T23:46:40Z"
+        }
+      ]
+    }
+  ]
+}
+
+A failure response will return an error message with details.
+    `,
+        schema: schemas_1.AlchemyTokenPricesBySymbolSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlchemyTokenPricesActionProvider.prototype, "tokenPricesBySymbol", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "token_prices_by_address",
+        description: `
+This tool will fetch current prices for tokens using network and address pairs via the Alchemy Prices API.
+
+A successful response will return a JSON payload similar to:
+{
+  "data": [
+    {
+      "network": "eth-mainnet",
+      "address": "0xYourTokenAddress",
+      "prices": [
+        {
+          "currency": "usd",
+          "value": "1234.56",
+          "lastUpdatedAt": "2025-02-03T23:46:40Z"
+        }
+      ]
+    }
+  ]
+}
+
+A failure response will return an error message with details.
+    `,
+        schema: schemas_1.AlchemyTokenPricesByAddressSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], AlchemyTokenPricesActionProvider.prototype, "tokenPricesByAddress", null);
+/**
+ * Factory function to create a new AlchemyTokenPricesActionProvider instance.
+ *
+ * @param config - The configuration options for the provider.
+ * @returns A new instance of AlchemyTokenPricesActionProvider.
+ */
+const alchemyTokenPricesActionProvider = (config) => new AlchemyTokenPricesActionProvider(config);
+exports.alchemyTokenPricesActionProvider = alchemyTokenPricesActionProvider;

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.test.d.ts

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

package/dist/action-providers/alchemy/alchemyTokenPricesActionProvider.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alchemyTokenPricesActionProvider_1 = require("./alchemyTokenPricesActionProvider");
+const MOCK_API_KEY = "alch-demo";
+// Sample responses for each action
+const MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE = {
+    data: [
+        {
+            symbol: "ETH",
+            prices: [
+                {
+                    currency: "usd",
+                    value: "2873.490923459",
+                    lastUpdatedAt: "2025-02-03T23:46:40Z",
+                },
+            ],
+        },
+    ],
+};
+const MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE = {
+    data: [
+        {
+            network: "eth-mainnet",
+            address: "0x1234567890abcdef",
+            prices: [
+                {
+                    currency: "usd",
+                    value: "1234.56",
+                    lastUpdatedAt: "2025-02-03T23:46:40Z",
+                },
+            ],
+        },
+    ],
+};
+describe("AlchemyTokenPricesActionProvider", () => {
+    let provider;
+    beforeEach(() => {
+        process.env.ALCHEMY_API_KEY = MOCK_API_KEY;
+        provider = (0, alchemyTokenPricesActionProvider_1.alchemyTokenPricesActionProvider)({ apiKey: MOCK_API_KEY });
+        jest.restoreAllMocks();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("tokenPricesBySymbol", () => {
+        it("should successfully fetch token prices by symbol", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE,
+            });
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH", "BTC"] });
+            // Verify the URL has the correct API key and query parameters.
+            const expectedUrlPart = `${provider["baseUrl"]}/${MOCK_API_KEY}/tokens/by-symbol`;
+            expect(fetchMock).toHaveBeenCalled();
+            const calledUrl = fetchMock.mock.calls[0][0];
+            expect(calledUrl).toContain(expectedUrlPart);
+            expect(calledUrl).toContain("symbols=ETH");
+            expect(calledUrl).toContain("symbols=BTC");
+            expect(response).toContain("Successfully fetched token prices by symbol");
+            expect(response).toContain(JSON.stringify(MOCK_TOKEN_PRICES_BY_SYMBOL_RESPONSE, null, 2));
+        });
+        it("should handle non-ok response for token prices by symbol", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 400,
+            });
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH"] });
+            expect(response).toContain("Error fetching token prices by symbol");
+            expect(response).toContain("400");
+        });
+        it("should handle fetch error for token prices by symbol", async () => {
+            const error = new Error("Fetch error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const response = await provider.tokenPricesBySymbol({ symbols: ["ETH"] });
+            expect(response).toContain("Error fetching token prices by symbol");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("tokenPricesByAddress", () => {
+        it("should successfully fetch token prices by address", async () => {
+            const fetchMock = jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: true,
+                json: async () => MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE,
+            });
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(fetchMock).toHaveBeenCalled();
+            // Verify that fetch was called with the correct POST URL and options.
+            const expectedUrl = `${provider["baseUrl"]}/${MOCK_API_KEY}/tokens/by-address`;
+            expect(fetchMock).toHaveBeenCalledWith(expectedUrl, expect.objectContaining({
+                method: "POST",
+                headers: expect.objectContaining({
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                }),
+                body: JSON.stringify(payload),
+            }));
+            expect(response).toContain("Successfully fetched token prices by address");
+            expect(response).toContain(JSON.stringify(MOCK_TOKEN_PRICES_BY_ADDRESS_RESPONSE, null, 2));
+        });
+        it("should handle non-ok response for token prices by address", async () => {
+            jest.spyOn(global, "fetch").mockResolvedValue({
+                ok: false,
+                status: 429,
+            });
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(response).toContain("Error fetching token prices by address");
+            expect(response).toContain("429");
+        });
+        it("should handle fetch error for token prices by address", async () => {
+            const error = new Error("Fetch error");
+            jest.spyOn(global, "fetch").mockRejectedValue(error);
+            const payload = {
+                addresses: [{ network: "eth-mainnet", address: "0x1234567890abcdef" }],
+            };
+            const response = await provider.tokenPricesByAddress(payload);
+            expect(response).toContain("Error fetching token prices by address");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should always return true", () => {
+            expect(provider.supportsNetwork()).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from "./alchemyTokenPricesActionProvider";
+export * from "./schemas";

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

@@ -0,0 +1,18 @@
+"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("./alchemyTokenPricesActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+/**
+ * Input schema for fetching token prices by symbol.
+ *
+ * The API expects a list of token symbols.
+ */
+export declare const AlchemyTokenPricesBySymbolSchema: z.ZodObject<{
+    symbols: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    symbols: string[];
+}, {
+    symbols: string[];
+}>;
+/**
+ * Input schema for fetching token prices by address.
+ *
+ * The API expects an object with an array of addresses, where each address contains
+ * a network identifier and a token contract address.
+ */
+export declare const AlchemyTokenPricesByAddressSchema: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodObject<{
+        network: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        network: string;
+    }, {
+        address: string;
+        network: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    addresses: {
+        address: string;
+        network: string;
+    }[];
+}, {
+    addresses: {
+        address: string;
+        network: string;
+    }[];
+}>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlchemyTokenPricesByAddressSchema = exports.AlchemyTokenPricesBySymbolSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for fetching token prices by symbol.
+ *
+ * The API expects a list of token symbols.
+ */
+exports.AlchemyTokenPricesBySymbolSchema = zod_1.z
+    .object({
+    symbols: zod_1.z
+        .array(zod_1.z.string())
+        .min(1, "At least one token symbol is required. Example: ETH, BTC, SOL, etc.")
+        .max(25, "A maximum of 25 token symbols can be provided."),
+})
+    .describe("Input schema for fetching token prices by symbol from Alchemy");
+/**
+ * Input schema for fetching token prices by address.
+ *
+ * The API expects an object with an array of addresses, where each address contains
+ * a network identifier and a token contract address.
+ */
+exports.AlchemyTokenPricesByAddressSchema = zod_1.z
+    .object({
+    addresses: zod_1.z
+        .array(zod_1.z.object({
+        network: zod_1.z.string().describe("Network identifier (e.g., eth-mainnet, base-mainnet etc.)"),
+        address: zod_1.z.string().describe("Token contract address"),
+    }))
+        .min(1, "At least one address is required.")
+        .max(25, "A maximum of 25 addresses can be provided."),
+})
+    .describe("Input schema for fetching token prices by address from Alchemy");

package/dist/action-providers/basename/basenameActionProvider.d.ts

@@ -6,7 +6,7 @@ import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * Action provider for registering Basenames.
  */
-export declare class BasenameActionProvider extends ActionProvider {
+export declare class BasenameActionProvider extends ActionProvider<EvmWalletProvider> {
     /**
      * Constructs a new BasenameActionProvider.
      */

package/dist/action-providers/cdp/cdpApiActionProvider.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiActionProvider = exports.CdpApiActionProvider = void 0;
+const package_json_1 = require("../../../package.json");
 const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
 const zod_1 = require("zod");
 const actionDecorator_1 = require("../actionDecorator");
@@ -37,7 +38,12 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
          */
         this.supportsNetwork = (_) => true;
         if (config.apiKeyName && config.apiKeyPrivateKey) {
-            coinbase_sdk_1.Coinbase.configure({ apiKeyName: config.apiKeyName, privateKey: config.apiKeyPrivateKey });
+            coinbase_sdk_1.Coinbase.configure({
+                apiKeyName: config.apiKeyName,
+                privateKey: config.apiKeyPrivateKey,
+                source: "agentkit",
+                sourceVersion: package_json_1.version,
+            });
         }
         else {
             coinbase_sdk_1.Coinbase.configureFromJson();

package/dist/action-providers/erc20/erc20ActionProvider.d.ts

@@ -6,7 +6,7 @@ import { EvmWalletProvider } from "../../wallet-providers";
 /**
  * ERC20ActionProvider is an action provider for ERC20 tokens.
  */
-export declare class ERC20ActionProvider extends ActionProvider {
+export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvider> {
     /**
      * Constructor for the ERC20ActionProvider.
      */

package/dist/action-providers/erc721/erc721ActionProvider.d.ts

@@ -6,7 +6,7 @@ import { Network } from "../../network";
 /**
  * Erc721ActionProvider is an action provider for Erc721 contract interactions.
  */
-export declare class Erc721ActionProvider extends ActionProvider {
+export declare class Erc721ActionProvider extends ActionProvider<EvmWalletProvider> {
     /**
      * Constructor for the Erc721ActionProvider class.
      */

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

@@ -11,3 +11,5 @@ export * from "./farcaster";
 export * from "./twitter";
 export * from "./wallet";
 export * from "./customActionProvider";
+export * from "./alchemy";
+export * from "./moonwell";

package/dist/action-providers/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./farcaster"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./customActionProvider"), exports);
+__exportStar(require("./alchemy"), exports);
+__exportStar(require("./moonwell"), exports);

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

@@ -0,0 +1,78 @@
+export declare const MOONWELL_BASE_ADDRESSES: {
+    "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22": string;
+    "0x73b06D8d18De422E269645eaCe15400DE7462417": string;
+    "0x628ff693426583D9a7FB391E54366292F509D457": string;
+    "0x3bf93770f2d4a794c3d9EBEfBAeBAE2a8f09A5E5": string;
+    "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b": string;
+    "0x73902f619CEB9B31FD8EFecf435CbDf89E369Ba6": string;
+    "0xb8051464C8c92209C92F3a4CD9C73746C4c3CFb3": string;
+    "0xF877ACaFA28c19b96727966690b2f44d35aD5976": string;
+    "0xb682c840B5F4FC58B20769E691A6fa1305A501a2": string;
+    "0xfC41B49d064Ac646015b459C522820DB9472F4B5": string;
+    "0xdC7810B47eAAb250De623F0eE07764afa5F71ED1": string;
+    "0xb6419c6C2e60c4025D6D06eE4F913ce89425a357": string;
+    "0x9A858ebfF1bEb0D3495BB0e2897c1528eD84A218": string;
+    "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9": string;
+};
+export declare const MOONWELL_BASE_SEPOLIA_ADDRESSES: {
+    "0x876852425331a113d8E432eFFB3aC5BEf38f033a": string;
+    "0x5302EbD8BC32435C823c2e22B04Cd6c45f593e89": string;
+    "0x2F39a349A79492a70E152760ce7123A1933eCf28": string;
+};
+export declare const WETH_ROUTER_ADDRESS = "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9";
+export declare const TOKEN_DECIMALS: {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": number;
+    "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42": number;
+    "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A": number;
+    "0xEDfa23602D0EC14714057867A78d01e94176BEA0": number;
+    "0x236aa50979D5f3De3Bd1Eeb40E81137F22ab794b": number;
+    "0xA88594D404727625A9437C3f886C7643872296AE": number;
+    "0x820C137fa70C8691f0e44Dc420a5e53c168921Dc": number;
+    "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": number;
+    "0x4200000000000000000000000000000000000006": number;
+    "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22": number;
+    "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452": number;
+    "0x940181a94a35a4569e4529a3cdfb74e38fd98631": number;
+    "0x0000000000000000000000000000000000000000": number;
+};
+export declare const MTOKENS_UNDERLYING_DECIMALS: {
+    MOONWELL_USDC: number;
+    MOONWELL_DAI: number;
+    MOONWELL_WETH: number;
+    MOONWELL_cbETH: number;
+    MOONWELL_wstETH: number;
+    MOONWELL_AERO: number;
+    MOONWELL_weETH: number;
+    MOONWELL_cbBTC: number;
+    MOONWELL_EURC: number;
+    MOONWELL_wrsETH: number;
+    MOONWELL_WELL: number;
+    MOONWELL_USDS: number;
+    MOONWELL_TBTC: number;
+};
+export declare const ETH_ROUTER_ABI: {
+    name: string;
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const MTOKEN_ABI: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];