@coinbase/agentkit 0.2.3-nightly.20250227.18 → 0.2.3-nightly.20250227.19

package/dist/action-providers/compound/compoundActionProvider.test.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const compoundActionProvider_1 = require("./compoundActionProvider");
+const constants_1 = require("./constants");
+const utils_1 = require("../../utils");
+jest.mock("../../utils");
+const mockApprove = utils_1.approve;
+describe("Compound Action Provider", () => {
+    const actionProvider = new compoundActionProvider_1.CompoundActionProvider();
+    let mockWallet;
+    const MOCK_NETWORK = { protocolFamily: "evm", networkId: "base-mainnet" };
+    const MOCK_COMET_ADDRESS = constants_1.COMET_ADDRESSES["base-mainnet"];
+    const MOCK_WETH_ADDRESS = constants_1.ASSET_ADDRESSES["base-mainnet"]["weth"];
+    const MOCK_USDC_ADDRESS = constants_1.ASSET_ADDRESSES["base-mainnet"]["usdc"];
+    const MOCK_TX_HASH = "0xtesttxhash";
+    const MOCK_RECEIPT = { status: 1, blockNumber: 123456 };
+    const MOCK_WALLET_BALANCE = BigInt("10000000000000000000"); // 10 tokens in wei
+    const MOCK_TOKEN_SYMBOL = "WETH";
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockResolvedValue("0xMockAddress"),
+            getNetwork: jest.fn().mockReturnValue(MOCK_NETWORK),
+            sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+            readContract: jest.fn().mockImplementation(async ({ functionName, address }) => {
+                // Basic ERC20 mocks
+                if (functionName === "decimals") {
+                    return address === MOCK_USDC_ADDRESS ? 6 : 18;
+                }
+                if (functionName === "symbol") {
+                    return address === MOCK_USDC_ADDRESS ? "USDC" : "WETH";
+                }
+                if (functionName === "balanceOf") {
+                    return address === MOCK_USDC_ADDRESS ? BigInt("1000000") : (0, viem_1.parseEther)("10");
+                }
+                // Comet contract mocks
+                if (functionName === "collateralBalanceOf") {
+                    return (0, viem_1.parseEther)("5");
+                }
+                if (functionName === "borrowBalanceOf") {
+                    return (0, viem_1.parseUnits)("1000", 6);
+                }
+                if (functionName === "baseToken") {
+                    return MOCK_USDC_ADDRESS;
+                }
+                if (functionName === "baseTokenPriceFeed") {
+                    return "0xMockPriceFeed";
+                }
+                if (functionName === "numAssets") {
+                    return 1;
+                }
+                if (functionName === "getAssetInfo") {
+                    return {
+                        offset: 0,
+                        asset: MOCK_WETH_ADDRESS,
+                        priceFeed: "0xMockPriceFeed",
+                        scale: BigInt(0),
+                        borrowCollateralFactor: (0, viem_1.parseEther)("0.8"),
+                        liquidateCollateralFactor: BigInt(0),
+                        liquidationFactor: BigInt(0),
+                        supplyCap: BigInt(0),
+                    };
+                }
+                if (functionName === "latestRoundData") {
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                }
+                throw new Error(`Unmocked contract call: ${functionName}`);
+            }),
+        };
+        jest.clearAllMocks();
+        mockApprove.mockResolvedValue("Approval successful");
+    });
+    describe("supply", () => {
+        it("should successfully supply assets", async () => {
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.supply(mockWallet, args);
+            expect(mockApprove).toHaveBeenCalledWith(mockWallet, MOCK_WETH_ADDRESS, MOCK_COMET_ADDRESS, (0, viem_1.parseEther)("1.0"));
+            const expectedTxData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "supply",
+                args: [MOCK_WETH_ADDRESS, (0, viem_1.parseEther)("1.0")],
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_COMET_ADDRESS,
+                data: expectedTxData,
+            });
+            expect(response).toContain("Supplied 1.0 WETH to Compound");
+            expect(response).toContain(MOCK_TX_HASH);
+        });
+        it("should return error if approval fails", async () => {
+            mockApprove.mockResolvedValueOnce("Error: Approval failed");
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.supply(mockWallet, args);
+            expect(response).toContain("Error approving token: Error: Approval failed");
+        });
+        it("should return error if wallet balance is insufficient", async () => {
+            mockWallet.readContract = jest.fn().mockImplementation(async ({ functionName }) => {
+                if (functionName === "decimals")
+                    return 18;
+                if (functionName === "balanceOf")
+                    return BigInt("500000000000000000"); // 0.5 tokens
+                return MOCK_WALLET_BALANCE;
+            });
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.supply(mockWallet, args);
+            expect(response).toContain("Error: Insufficient balance. You have 0.5, but trying to supply 1.0");
+        });
+        it("should handle errors during the supply transaction", async () => {
+            mockWallet.sendTransaction.mockRejectedValueOnce(new Error("Failed TX"));
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.supply(mockWallet, args);
+            expect(response).toContain("Error supplying to Compound: Failed TX");
+        });
+    });
+    describe("withdraw", () => {
+        it("should successfully withdraw assets", async () => {
+            // Patch readContract so that borrow balance is 0 (healthy condition)
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, args, abi }) => {
+                if (functionName === "borrowBalanceOf")
+                    return BigInt(0); // No borrows
+                if (functionName === "collateralBalanceOf")
+                    return (0, viem_1.parseEther)("5"); // 5 WETH supplied
+                if (functionName === "latestRoundData")
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                return originalReadContract({ functionName, address, abi, args: args ?? [] });
+            });
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.withdraw(mockWallet, args);
+            const expectedTxData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "withdraw",
+                args: [MOCK_WETH_ADDRESS, (0, viem_1.parseEther)("1.0")],
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_COMET_ADDRESS,
+                data: expectedTxData,
+            });
+            expect(response).toContain("Withdrawn 1.0 WETH from Compound");
+            expect(response).toContain(MOCK_TX_HASH);
+        });
+        it("should return error if collateral balance is insufficient", async () => {
+            mockWallet.readContract = jest.fn().mockImplementation(async ({ functionName }) => {
+                if (functionName === "decimals")
+                    return 18;
+                if (functionName === "collateralBalanceOf")
+                    return (0, viem_1.parseEther)("0.5"); // Less than we're trying to withdraw
+                if (functionName === "symbol")
+                    return MOCK_TOKEN_SYMBOL;
+                return MOCK_WALLET_BALANCE;
+            });
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(response).toContain("Error: Insufficient balance. Trying to withdraw 1.0, but only have 0.5 supplied");
+        });
+        it("should handle errors during withdrawal", async () => {
+            // Patch readContract to yield a healthy condition so the TX is attempted
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, args, abi }) => {
+                if (functionName === "borrowBalanceOf")
+                    return BigInt(0);
+                if (functionName === "collateralBalanceOf")
+                    return (0, viem_1.parseEther)("5");
+                if (functionName === "latestRoundData")
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                return originalReadContract({ functionName, address, abi, args: args ?? [] });
+            });
+            mockWallet.sendTransaction.mockRejectedValueOnce(new Error("Withdraw TX Failed"));
+            const args = { assetId: "weth", amount: "1.0" };
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(response).toContain("Error withdrawing from Compound: Error: Withdraw TX Failed");
+        });
+    });
+    describe("borrow", () => {
+        it("should successfully borrow assets", async () => {
+            // For a healthy borrow, override:
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, abi }) => {
+                if (functionName === "borrowBalanceOf")
+                    return BigInt(0);
+                if (functionName === "collateralBalanceOf")
+                    return (0, viem_1.parseEther)("5000");
+                if (functionName === "baseToken")
+                    return MOCK_USDC_ADDRESS;
+                if (functionName === "baseTokenPriceFeed")
+                    return "0xMockPriceFeed";
+                if (functionName === "latestRoundData") {
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                }
+                if (functionName === "getAssetInfo") {
+                    return {
+                        offset: 0,
+                        asset: MOCK_WETH_ADDRESS,
+                        priceFeed: "0xMockPriceFeed",
+                        scale: BigInt(0),
+                        borrowCollateralFactor: (0, viem_1.parseEther)("0.8"),
+                        liquidateCollateralFactor: BigInt(0),
+                        liquidationFactor: BigInt(0),
+                        supplyCap: BigInt(0),
+                    };
+                }
+                return originalReadContract({ functionName, address, abi, args: [] });
+            });
+            const args = { assetId: "usdc", amount: "1000" };
+            const response = await actionProvider.borrow(mockWallet, args);
+            const expectedTxData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "withdraw",
+                args: [MOCK_USDC_ADDRESS, (0, viem_1.parseUnits)("1000", 6)],
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_COMET_ADDRESS,
+                data: expectedTxData,
+            });
+            expect(response).toContain("Borrowed 1000 USDC from Compound");
+        });
+        it("should handle errors during borrowing", async () => {
+            // Set up the same mocks as the success case first
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, abi }) => {
+                if (functionName === "borrowBalanceOf")
+                    return BigInt(0);
+                if (functionName === "collateralBalanceOf")
+                    return (0, viem_1.parseEther)("5000");
+                if (functionName === "baseToken")
+                    return MOCK_USDC_ADDRESS;
+                if (functionName === "baseTokenPriceFeed")
+                    return "0xMockPriceFeed";
+                if (functionName === "latestRoundData") {
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                }
+                if (functionName === "getAssetInfo") {
+                    return {
+                        offset: 0,
+                        asset: MOCK_WETH_ADDRESS,
+                        priceFeed: "0xMockPriceFeed",
+                        scale: BigInt(0),
+                        borrowCollateralFactor: (0, viem_1.parseEther)("0.8"),
+                        liquidateCollateralFactor: BigInt(0),
+                        liquidationFactor: BigInt(0),
+                        supplyCap: BigInt(0),
+                    };
+                }
+                return originalReadContract({ functionName, address, abi, args: [] });
+            });
+            mockWallet.sendTransaction.mockRejectedValueOnce(new Error("Borrow TX Failed"));
+            const args = { assetId: "usdc", amount: "1000" };
+            const response = await actionProvider.borrow(mockWallet, args);
+            expect(response).toContain("Error borrowing from Compound: Error: Borrow TX Failed");
+        });
+    });
+    describe("repay", () => {
+        it("should successfully repay assets", async () => {
+            // Override token balance for USDC to be sufficient for repayment.
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, args, abi }) => {
+                if (functionName === "balanceOf" && address === MOCK_USDC_ADDRESS) {
+                    // Return 2000 USDC in atomic units (for 6 decimals, 2000 USDC = 2000 * 10^6)
+                    return BigInt("2000000000");
+                }
+                if (functionName === "latestRoundData")
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                return originalReadContract({ functionName, address, args, abi });
+            });
+            const args = { assetId: "usdc", amount: "1000" };
+            const response = await actionProvider.repay(mockWallet, args);
+            expect(mockApprove).toHaveBeenCalledWith(mockWallet, MOCK_USDC_ADDRESS, MOCK_COMET_ADDRESS, (0, viem_1.parseUnits)("1000", 6));
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_COMET_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.COMET_ABI,
+                    functionName: "supply",
+                    args: [MOCK_USDC_ADDRESS, (0, viem_1.parseUnits)("1000", 6)],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toContain(`Repaid ${args.amount} USDC to Compound`);
+        });
+        it("should return error if wallet balance is insufficient for repay", async () => {
+            mockWallet.readContract = jest.fn().mockImplementation(async ({ functionName }) => {
+                if (functionName === "decimals")
+                    return 6;
+                if (functionName === "balanceOf")
+                    return BigInt("500000"); // 0.5 USDC
+                return MOCK_WALLET_BALANCE;
+            });
+            const args = { assetId: "usdc", amount: "1000" };
+            const response = await actionProvider.repay(mockWallet, args);
+            expect(response).toContain("Error: Insufficient balance. You have 0.5, but trying to repay 1000");
+        });
+        it("should handle errors during repayment", async () => {
+            // Override token balance to be sufficient, but make transaction fail
+            const originalReadContract = mockWallet.readContract;
+            mockWallet.readContract = jest
+                .fn()
+                .mockImplementation(async ({ functionName, address, args, abi }) => {
+                if (functionName === "balanceOf" && address === MOCK_USDC_ADDRESS) {
+                    // Return 2000 USDC in atomic units (sufficient balance)
+                    return BigInt("2000000000");
+                }
+                if (functionName === "latestRoundData")
+                    return [BigInt(1), (0, viem_1.parseUnits)("1", 8), BigInt(0), BigInt(1000), BigInt(1)];
+                return originalReadContract({ functionName, address, args, abi });
+            });
+            mockApprove.mockResolvedValueOnce("Approval successful");
+            mockWallet.sendTransaction.mockRejectedValueOnce(new Error("Repay TX Failed"));
+            const args = { assetId: "usdc", amount: "1000" };
+            const response = await actionProvider.repay(mockWallet, args);
+            expect(response).toContain("Error repaying to Compound: Error: Repay TX Failed");
+        });
+    });
+    describe("getPortfolio", () => {
+        it("should return portfolio details in markdown format", async () => {
+            const response = await actionProvider.getPortfolio(mockWallet, {});
+            expect(response).toContain("# Portfolio Details");
+            expect(response).toContain("## Supply Details");
+            expect(response).toContain("## Borrow Details");
+            expect(response).toContain("## Overall Health");
+        });
+        it("should handle errors during portfolio retrieval", async () => {
+            mockWallet.readContract.mockRejectedValueOnce(new Error("Failed to fetch"));
+            const response = await actionProvider.getPortfolio(mockWallet, {});
+            expect(response).toContain("Error getting portfolio details: Failed to fetch");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported network", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false for unsupported network", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,180 @@
+import { Address } from "viem";
+import { abi as ERC20_ABI } from "../erc20/constants";
+export declare const SUPPORTED_NETWORKS: string[];
+export declare const COMET_ADDRESSES: Record<string, Address>;
+export declare const ASSET_ADDRESSES: Record<string, Record<string, Address>>;
+export { ERC20_ABI };
+export declare const COMET_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "supply";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "priceFeed";
+        readonly type: "address";
+    }];
+    readonly name: "getPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "borrowBalanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "numAssets";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "i";
+        readonly type: "uint8";
+    }];
+    readonly name: "getAssetInfo";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint8";
+            readonly name: "offset";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "address";
+            readonly name: "asset";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "priceFeed";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "scale";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "borrowCollateralFactor";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "liquidateCollateralFactor";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "liquidationFactor";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "uint128";
+            readonly name: "supplyCap";
+            readonly type: "uint128";
+        }];
+        readonly internalType: "struct CometCore.AssetInfo";
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "baseToken";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "baseTokenPriceFeed";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly name: "collateralBalanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint128";
+        readonly name: "balance";
+        readonly type: "uint128";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export declare const PRICE_FEED_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "latestRoundData";
+    readonly outputs: readonly [{
+        readonly name: "roundId";
+        readonly type: "uint80";
+    }, {
+        readonly name: "answer";
+        readonly type: "int256";
+    }, {
+        readonly name: "startedAt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "updatedAt";
+        readonly type: "uint256";
+    }, {
+        readonly name: "answeredInRound";
+        readonly type: "uint80";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRICE_FEED_ABI = exports.COMET_ABI = exports.ERC20_ABI = exports.ASSET_ADDRESSES = exports.COMET_ADDRESSES = exports.SUPPORTED_NETWORKS = void 0;
+const constants_1 = require("../erc20/constants");
+Object.defineProperty(exports, "ERC20_ABI", { enumerable: true, get: function () { return constants_1.abi; } });
+exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+exports.COMET_ADDRESSES = {
+    "base-mainnet": "0xb125E6687d4313864e53df431d5425969c15Eb2F",
+    "base-sepolia": "0x571621Ce60Cebb0c1D442B5afb38B1663C6Bf017",
+};
+exports.ASSET_ADDRESSES = {
+    "base-mainnet": {
+        weth: "0x4200000000000000000000000000000000000006",
+        cbeth: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+        cbbtc: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+        wsteth: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    },
+    "base-sepolia": {
+        weth: "0x4200000000000000000000000000000000000006",
+        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        wsteth: "0x774eD9EDB0C5202dF9A86183804b5D9E99dC6CA3",
+    },
+};
+exports.COMET_ABI = [
+    {
+        inputs: [
+            { internalType: "address", name: "asset", type: "address" },
+            { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "supply",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "asset", type: "address" },
+            { internalType: "uint256", name: "amount", type: "uint256" },
+        ],
+        name: "withdraw",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "priceFeed", type: "address" }],
+        name: "getPrice",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "borrowBalanceOf",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "numAssets",
+        outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint8", name: "i", type: "uint8" }],
+        name: "getAssetInfo",
+        outputs: [
+            {
+                components: [
+                    { internalType: "uint8", name: "offset", type: "uint8" },
+                    { internalType: "address", name: "asset", type: "address" },
+                    { internalType: "address", name: "priceFeed", type: "address" },
+                    { internalType: "uint64", name: "scale", type: "uint64" },
+                    { internalType: "uint64", name: "borrowCollateralFactor", type: "uint64" },
+                    { internalType: "uint64", name: "liquidateCollateralFactor", type: "uint64" },
+                    { internalType: "uint64", name: "liquidationFactor", type: "uint64" },
+                    { internalType: "uint128", name: "supplyCap", type: "uint128" },
+                ],
+                internalType: "struct CometCore.AssetInfo",
+                name: "",
+                type: "tuple",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "baseToken",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "baseTokenPriceFeed",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "account", type: "address" },
+            { internalType: "address", name: "asset", type: "address" },
+        ],
+        name: "collateralBalanceOf",
+        outputs: [{ internalType: "uint128", name: "balance", type: "uint128" }],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+exports.PRICE_FEED_ABI = [
+    {
+        inputs: [],
+        name: "latestRoundData",
+        outputs: [
+            { name: "roundId", type: "uint80" },
+            { name: "answer", type: "int256" },
+            { name: "startedAt", type: "uint256" },
+            { name: "updatedAt", type: "uint256" },
+            { name: "answeredInRound", type: "uint80" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];

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

@@ -0,0 +1 @@
+export * from "./compoundActionProvider";