@coinbase/agentkit 0.1.1 → 0.2.0

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/erc20/schemas.d.ts

@@ -7,12 +7,12 @@ export declare const TransferSchema: z.ZodObject<{
     contractAddress: z.ZodString;
     destination: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    amount: bigint;
     contractAddress: string;
+    amount: bigint;
     destination: string;
 }, {
-    amount: bigint;
     contractAddress: string;
+    amount: bigint;
     destination: string;
 }>;
 /**

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

@@ -1,13 +1,16 @@
 export * from "./actionDecorator";
 export * from "./actionProvider";
-export * from "./pyth";
+export * from "./customActionProvider";
+export * from "./alchemy";
+export * from "./basename";
 export * from "./cdp";
-export * from "./weth";
 export * from "./erc20";
 export * from "./erc721";
-export * from "./morpho";
-export * from "./basename";
 export * from "./farcaster";
+export * from "./pyth";
+export * from "./moonwell";
+export * from "./morpho";
+export * from "./spl";
 export * from "./twitter";
 export * from "./wallet";
-export * from "./customActionProvider";
+export * from "./weth";

package/dist/action-providers/index.js

@@ -16,14 +16,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./actionDecorator"), exports);
 __exportStar(require("./actionProvider"), exports);
-__exportStar(require("./pyth"), exports);
+__exportStar(require("./customActionProvider"), exports);
+__exportStar(require("./alchemy"), exports);
+__exportStar(require("./basename"), exports);
 __exportStar(require("./cdp"), exports);
-__exportStar(require("./weth"), exports);
 __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
-__exportStar(require("./morpho"), exports);
-__exportStar(require("./basename"), exports);
 __exportStar(require("./farcaster"), exports);
+__exportStar(require("./pyth"), exports);
+__exportStar(require("./moonwell"), exports);
+__exportStar(require("./morpho"), exports);
+__exportStar(require("./spl"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);
-__exportStar(require("./customActionProvider"), exports);
+__exportStar(require("./weth"), 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;
+}[];

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MTOKEN_ABI = exports.ETH_ROUTER_ABI = exports.MTOKENS_UNDERLYING_DECIMALS = exports.TOKEN_DECIMALS = exports.WETH_ROUTER_ADDRESS = exports.MOONWELL_BASE_SEPOLIA_ADDRESSES = exports.MOONWELL_BASE_ADDRESSES = void 0;
+exports.MOONWELL_BASE_ADDRESSES = {
+    "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22": "MOONWELL_USDC",
+    "0x73b06D8d18De422E269645eaCe15400DE7462417": "MOONWELL_DAI",
+    "0x628ff693426583D9a7FB391E54366292F509D457": "MOONWELL_WETH",
+    "0x3bf93770f2d4a794c3d9EBEfBAeBAE2a8f09A5E5": "MOONWELL_cbETH",
+    "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b": "MOONWELL_wstETH",
+    "0x73902f619CEB9B31FD8EFecf435CbDf89E369Ba6": "MOONWELL_AERO",
+    "0xb8051464C8c92209C92F3a4CD9C73746C4c3CFb3": "MOONWELL_weETH",
+    "0xF877ACaFA28c19b96727966690b2f44d35aD5976": "MOONWELL_cbBTC",
+    "0xb682c840B5F4FC58B20769E691A6fa1305A501a2": "MOONWELL_EURC",
+    "0xfC41B49d064Ac646015b459C522820DB9472F4B5": "MOONWELL_wrsETH",
+    "0xdC7810B47eAAb250De623F0eE07764afa5F71ED1": "MOONWELL_WELL",
+    "0xb6419c6C2e60c4025D6D06eE4F913ce89425a357": "MOONWELL_USDS",
+    "0x9A858ebfF1bEb0D3495BB0e2897c1528eD84A218": "MOONWELL_TBTC",
+    "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9": "WETH_ROUTER",
+};
+exports.MOONWELL_BASE_SEPOLIA_ADDRESSES = {
+    "0x876852425331a113d8E432eFFB3aC5BEf38f033a": "MOONWELL_USDBC",
+    "0x5302EbD8BC32435C823c2e22B04Cd6c45f593e89": "MOONWELL_cbETH",
+    "0x2F39a349A79492a70E152760ce7123A1933eCf28": "MOONWELL_WETH",
+};
+exports.WETH_ROUTER_ADDRESS = "0x70778cfcFC475c7eA0f24cC625Baf6EaE475D0c9";
+// Token decimals mapping
+exports.TOKEN_DECIMALS = {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 6, // USDC
+    "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42": 6, // EURC
+    "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A": 18, // weETH
+    "0xEDfa23602D0EC14714057867A78d01e94176BEA0": 18, // wrsETH
+    "0x236aa50979D5f3De3Bd1Eeb40E81137F22ab794b": 18, // tBTC
+    "0xA88594D404727625A9437C3f886C7643872296AE": 18, // WELL
+    "0x820C137fa70C8691f0e44Dc420a5e53c168921Dc": 18, // USDS
+    "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": 18, // DAI
+    "0x4200000000000000000000000000000000000006": 18, // WETH
+    "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22": 18, // cbETH
+    "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452": 18, // wstETH
+    "0x940181a94a35a4569e4529a3cdfb74e38fd98631": 18, // AERO
+    "0x0000000000000000000000000000000000000000": 18, // ETH (native)
+};
+exports.MTOKENS_UNDERLYING_DECIMALS = {
+    MOONWELL_USDC: 6,
+    MOONWELL_DAI: 18,
+    MOONWELL_WETH: 18,
+    MOONWELL_cbETH: 18,
+    MOONWELL_wstETH: 18,
+    MOONWELL_AERO: 18,
+    MOONWELL_weETH: 18,
+    MOONWELL_cbBTC: 18,
+    MOONWELL_EURC: 6,
+    MOONWELL_wrsETH: 18,
+    MOONWELL_WELL: 18,
+    MOONWELL_USDS: 18,
+    MOONWELL_TBTC: 18,
+};
+exports.ETH_ROUTER_ABI = [
+    {
+        name: "mint",
+        inputs: [
+            {
+                internalType: "address",
+                name: "receiver",
+                type: "address",
+            },
+        ],
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+];
+exports.MTOKEN_ABI = [
+    {
+        type: "function",
+        name: "mint",
+        inputs: [
+            {
+                name: "mintAmount",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "redeemUnderlying",
+        inputs: [
+            {
+                name: "redeemAmount",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+];

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

@@ -0,0 +1 @@
+export { moonwellActionProvider } from "./moonwellActionProvider";

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moonwellActionProvider = void 0;
+var moonwellActionProvider_1 = require("./moonwellActionProvider");
+Object.defineProperty(exports, "moonwellActionProvider", { enumerable: true, get: function () { return moonwellActionProvider_1.moonwellActionProvider; } });

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { MintSchema, RedeemSchema } from "./schemas";
+import { Network } from "../../network";
+export declare const SUPPORTED_NETWORKS: string[];
+/**
+ * MoonwellActionProvider is an action provider for Moonwell MToken interactions.
+ */
+export declare class MoonwellActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the MoonwellActionProvider class.
+     */
+    constructor();
+    /**
+     * Deposits assets into a Moonwell MToken
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    mint(wallet: EvmWalletProvider, args: z.infer<typeof MintSchema>): Promise<string>;
+    /**
+     * Redeems assets from a Moonwell MToken
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    redeem(wallet: EvmWalletProvider, args: z.infer<typeof RedeemSchema>): Promise<string>;
+    /**
+     * Checks if the Moonwell action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Moonwell action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const moonwellActionProvider: () => MoonwellActionProvider;