@coinbase/agentkit 0.1.1 → 0.1.2

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;

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

@@ -0,0 +1,249 @@
+"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.moonwellActionProvider = exports.MoonwellActionProvider = exports.SUPPORTED_NETWORKS = void 0;
+const zod_1 = require("zod");
+const decimal_js_1 = require("decimal.js");
+const viem_1 = require("viem");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const utils_1 = require("../../utils");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * MoonwellActionProvider is an action provider for Moonwell MToken interactions.
+ */
+class MoonwellActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the MoonwellActionProvider class.
+     */
+    constructor() {
+        super("moonwell", []);
+        /**
+         * 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.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && exports.SUPPORTED_NETWORKS.includes(network.networkId);
+    }
+    /**
+     * 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
+     */
+    async mint(wallet, args) {
+        const assets = new decimal_js_1.Decimal(args.assets);
+        if (assets.comparedTo(new decimal_js_1.Decimal(0.0)) != 1) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        const network = wallet.getNetwork();
+        const networkObject = network.networkId === "base-mainnet"
+            ? constants_1.MOONWELL_BASE_ADDRESSES
+            : constants_1.MOONWELL_BASE_SEPOLIA_ADDRESSES;
+        if (!networkObject[args.mTokenAddress]) {
+            return "Error: Invalid MToken address";
+        }
+        try {
+            // Handle different token decimals
+            let atomicAssets;
+            const userAddress = wallet.getAddress();
+            if (network.networkId === "base-mainnet" &&
+                "MOONWELL_WETH" === networkObject[args.mTokenAddress]) {
+                // For ETH minting, use parseEther (18 decimals)
+                atomicAssets = (0, viem_1.parseEther)(args.assets);
+            }
+            else {
+                // For other tokens, use the correct decimals
+                const decimals = constants_1.TOKEN_DECIMALS[args.tokenAddress];
+                if (!decimals) {
+                    return `Error: Unsupported token address ${args.tokenAddress}. Please verify the token address is correct.`;
+                }
+                atomicAssets = (0, viem_1.parseUnits)(args.assets, decimals);
+            }
+            // Check if this is a WETH mint on mainnet
+            if (network.networkId === "base-mainnet" &&
+                "MOONWELL_WETH" === networkObject[args.mTokenAddress]) {
+                // Use the router for ETH mints - no approval needed since we're sending native ETH
+                const data = (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.ETH_ROUTER_ABI,
+                    functionName: "mint",
+                    args: [userAddress],
+                });
+                const txHash = await wallet.sendTransaction({
+                    to: constants_1.WETH_ROUTER_ADDRESS,
+                    data,
+                    value: atomicAssets,
+                });
+                const receipt = await wallet.waitForTransactionReceipt(txHash);
+                return `Deposited ${args.assets} ETH to Moonwell WETH via router with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt, (_, value) => (typeof value === "bigint" ? value.toString() : value))}`;
+            }
+            else {
+                // For all other tokens, we need approval first
+                const approvalResult = await (0, utils_1.approve)(wallet, args.tokenAddress, args.mTokenAddress, atomicAssets);
+                if (approvalResult.startsWith("Error")) {
+                    return `Error approving Moonwell MToken as spender: ${approvalResult}`;
+                }
+                const data = (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.MTOKEN_ABI,
+                    functionName: "mint",
+                    args: [atomicAssets],
+                });
+                const txHash = await wallet.sendTransaction({
+                    to: args.mTokenAddress,
+                    data,
+                    value: 0n,
+                });
+                const receipt = await wallet.waitForTransactionReceipt(txHash);
+                if (!receipt) {
+                    throw new Error("No receipt received for mint transaction");
+                }
+                if (receipt.status !== "success") {
+                    throw new Error(`Mint transaction failed with status ${receipt.status}`);
+                }
+                return `Deposited ${args.assets} to Moonwell MToken ${args.mTokenAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt, (_, value) => (typeof value === "bigint" ? value.toString() : value))}`;
+            }
+        }
+        catch (error) {
+            console.error("DEBUG - Mint error:", error);
+            if (error instanceof Error) {
+                return `Error minting Moonwell MToken: ${error.message}`;
+            }
+            return `Error minting Moonwell MToken: ${error}`;
+        }
+    }
+    /**
+     * 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
+     */
+    async redeem(wallet, args) {
+        const assets = new decimal_js_1.Decimal(args.assets);
+        if (assets.comparedTo(new decimal_js_1.Decimal(0.0)) != 1) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        const network = wallet.getNetwork();
+        const networkObject = network.networkId === "base-mainnet"
+            ? constants_1.MOONWELL_BASE_ADDRESSES
+            : constants_1.MOONWELL_BASE_SEPOLIA_ADDRESSES;
+        if (!networkObject[args.mTokenAddress]) {
+            return "Error: Invalid MToken address";
+        }
+        try {
+            // Handle different token decimals
+            const decimals = constants_1.MTOKENS_UNDERLYING_DECIMALS[constants_1.MOONWELL_BASE_ADDRESSES[args.mTokenAddress]];
+            if (!decimals) {
+                return `Error: Unsupported token address ${args.mTokenAddress}. Please verify the token address is correct.`;
+            }
+            const atomicAssets = (0, viem_1.parseUnits)(args.assets, decimals);
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.MTOKEN_ABI,
+                functionName: "redeemUnderlying",
+                args: [atomicAssets],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.mTokenAddress,
+                data,
+                value: 0n,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            if (!receipt) {
+                throw new Error("No receipt received for redeem transaction");
+            }
+            if (receipt.status !== "success") {
+                throw new Error(`Redeem transaction failed with status ${receipt.status}`);
+            }
+            return `Redeemed ${args.assets} from Moonwell MToken ${args.mTokenAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt, (_, value) => (typeof value === "bigint" ? value.toString() : value))}`;
+        }
+        catch (error) {
+            console.error("DEBUG - Redeem error:", error);
+            if (error instanceof Error) {
+                return `Error redeeming from Moonwell MToken: ${error.message}`;
+            }
+            return `Error redeeming from Moonwell MToken: ${error}`;
+        }
+    }
+}
+exports.MoonwellActionProvider = MoonwellActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "mint",
+        description: `
+This tool allows minting assets into a Moonwell MToken. 
+
+It takes:
+- mTokenAddress: The address of the Moonwell MToken to mint to
+- assets: The amount of assets that will be approved to spend by the mToken in whole units
+  Examples for WETH:
+  - 1 WETH
+  - 0.1 WETH
+  - 0.01 WETH
+  Examples for cbETH:
+  - 1 cbETH
+  - 0.1 cbETH
+  - 0.01 cbETH
+  Examples for USDC:
+  - 1 USDC
+  - 0.1 USDC
+  - 0.01 USDC
+- tokenAddress: The address of the token to approve
+
+Important notes:
+- Make sure to use the exact amount provided. Do not convert units for assets for this action.
+- Please use a token address (example 0x4200000000000000000000000000000000000006) for the tokenAddress field.
+- This tool handles token approval. If requested to mint on Moonwell, do not use any other actions to approve tokens.
+`,
+        schema: schemas_1.MintSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MoonwellActionProvider.prototype, "mint", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "redeem",
+        description: `
+This tool allows redeeming assets from a Moonwell MToken. 
+
+It takes:
+- mTokenAddress: The address of the Moonwell MToken to redeem from
+- assets: The amount of assets to redeem in whole units
+  Examples for WETH:
+  - 1 WETH
+  - 0.1 WETH
+  - 0.01 WETH
+  Examples for cbETH:
+  - 1 cbETH
+  - 0.1 cbETH
+  - 0.01 cbETH
+  Examples for USDC:
+  - 1 USDC
+  - 0.1 USDC
+  - 0.01 USDC
+
+Important notes:
+- Make sure to use the exact amount provided. Do not convert units for assets for this action.
+- Please use a token address (example 0x4200000000000000000000000000000000000006) for the tokenAddress field.
+`,
+        schema: schemas_1.RedeemSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MoonwellActionProvider.prototype, "redeem", null);
+const moonwellActionProvider = () => new MoonwellActionProvider();
+exports.moonwellActionProvider = moonwellActionProvider;

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

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