@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,91 @@
+import { z } from "zod";
+/**
+ * Input schema for address reputation check.
+ */
+export declare const AddressReputationSchema: z.ZodObject<{
+    address: z.ZodString;
+    network: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    network: string;
+}, {
+    address: string;
+    network: string;
+}>;
+/**
+ * Input schema for deploy contract action.
+ */
+export declare const DeployContractSchema: z.ZodObject<{
+    solidityVersion: z.ZodEnum<[string, ...string[]]>;
+    solidityInputJson: z.ZodString;
+    contractName: z.ZodString;
+    constructorArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    solidityVersion: string;
+    solidityInputJson: string;
+    contractName: string;
+    constructorArgs?: Record<string, any> | undefined;
+}, {
+    solidityVersion: string;
+    solidityInputJson: string;
+    contractName: string;
+    constructorArgs?: Record<string, any> | undefined;
+}>;
+/**
+ * Input schema for deploy NFT action
+ */
+export declare const DeployNftSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    baseURI: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    baseURI: string;
+}, {
+    symbol: string;
+    name: string;
+    baseURI: string;
+}>;
+/**
+ * Input schema for deploy token action.
+ */
+export declare const DeployTokenSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    totalSupply: z.ZodType<bigint, z.ZodTypeDef, bigint>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    totalSupply: bigint;
+}, {
+    symbol: string;
+    name: string;
+    totalSupply: bigint;
+}>;
+/**
+ * Input schema for request faucet funds action.
+ */
+export declare const RequestFaucetFundsSchema: z.ZodObject<{
+    assetId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    assetId?: string | undefined;
+}, {
+    assetId?: string | undefined;
+}>;
+/**
+ * Input schema for trade action.
+ */
+export declare const TradeSchema: z.ZodObject<{
+    amount: z.ZodType<bigint, z.ZodTypeDef, bigint>;
+    fromAssetId: z.ZodString;
+    toAssetId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: bigint;
+    fromAssetId: string;
+    toAssetId: string;
+}, {
+    amount: bigint;
+    fromAssetId: string;
+    toAssetId: string;
+}>;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeSchema = exports.RequestFaucetFundsSchema = exports.DeployTokenSchema = exports.DeployNftSchema = exports.DeployContractSchema = exports.AddressReputationSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("./constants");
+/**
+ * Input schema for address reputation check.
+ */
+exports.AddressReputationSchema = zod_1.z
+    .object({
+    address: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The Ethereum address to check"),
+    network: zod_1.z.string().describe("The network to check the address on"),
+})
+    .strip()
+    .describe("Input schema for address reputation check");
+/**
+ * Input schema for deploy contract action.
+ */
+exports.DeployContractSchema = zod_1.z
+    .object({
+    solidityVersion: zod_1.z
+        .enum(Object.keys(constants_1.SolidityVersions))
+        .describe("The solidity compiler version"),
+    solidityInputJson: zod_1.z.string().describe("The input json for the solidity compiler"),
+    contractName: zod_1.z.string().describe("The name of the contract class to be deployed"),
+    constructorArgs: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.any())
+        .describe("The constructor arguments for the contract")
+        .optional(),
+})
+    .strip()
+    .describe("Instructions for deploying an arbitrary contract");
+/**
+ * Input schema for deploy NFT action
+ */
+exports.DeployNftSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe("The name of the NFT collection"),
+    symbol: zod_1.z.string().describe("The symbol of the NFT collection"),
+    baseURI: zod_1.z.string().describe("The base URI for the token metadata"),
+})
+    .strip()
+    .describe("Instructions for deploying an NFT collection");
+/**
+ * Input schema for deploy token action.
+ */
+exports.DeployTokenSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe("The name of the token"),
+    symbol: zod_1.z.string().describe("The token symbol"),
+    totalSupply: zod_1.z.custom().describe("The total supply of tokens to mint"),
+})
+    .strip()
+    .describe("Instructions for deploying a token");
+/**
+ * Input schema for request faucet funds action.
+ */
+exports.RequestFaucetFundsSchema = zod_1.z
+    .object({
+    assetId: zod_1.z.string().optional().describe("The optional asset ID to request from faucet"),
+})
+    .strip()
+    .describe("Instructions for requesting faucet funds");
+/**
+ * Input schema for trade action.
+ */
+exports.TradeSchema = zod_1.z
+    .object({
+    amount: zod_1.z.custom().describe("The amount of the from asset to trade"),
+    fromAssetId: zod_1.z.string().describe("The from asset ID to trade"),
+    toAssetId: zod_1.z.string().describe("The to asset ID to receive from the trade"),
+})
+    .strip()
+    .describe("Instructions for trading assets");

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

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { Network } from "../../network";
+import { CompoundSupplySchema, CompoundWithdrawSchema, CompoundBorrowSchema, CompoundRepaySchema, CompoundPortfolioSchema } from "./schemas";
+/**
+ * CompoundActionProvider is an action provider for Compound protocol interactions.
+ */
+export declare class CompoundActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructs a new CompoundActionProvider instance.
+     */
+    constructor();
+    /**
+     * Supplies collateral assets to Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    supply(wallet: EvmWalletProvider, args: z.infer<typeof CompoundSupplySchema>): Promise<string>;
+    /**
+     * Withdraws collateral assets from Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    withdraw(wallet: EvmWalletProvider, args: z.infer<typeof CompoundWithdrawSchema>): Promise<string>;
+    /**
+     * Borrows base assets from Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    borrow(wallet: EvmWalletProvider, args: z.infer<typeof CompoundBorrowSchema>): Promise<string>;
+    /**
+     * Repays borrowed assets to Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    repay(wallet: EvmWalletProvider, args: z.infer<typeof CompoundRepaySchema>): Promise<string>;
+    /**
+     * Retrieves portfolio details from Compound.
+     *
+     * @param wallet - The wallet instance to fetch portfolio details.
+     * @param _ - No input is required for this action.
+     * @returns A Markdown formatted string with portfolio details or an error message.
+     */
+    getPortfolio(wallet: EvmWalletProvider, _: z.infer<typeof CompoundPortfolioSchema>): Promise<string>;
+    /**
+     * Checks if the Compound action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the network is supported, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+/**
+ * Factory function to create a new instance of CompoundActionProvider.
+ *
+ * @returns A new CompoundActionProvider instance.
+ */
+export declare const compoundActionProvider: () => CompoundActionProvider;

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

@@ -0,0 +1,365 @@
+"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.compoundActionProvider = exports.CompoundActionProvider = void 0;
+const zod_1 = require("zod");
+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");
+const utils_2 = require("./utils");
+/**
+ * CompoundActionProvider is an action provider for Compound protocol interactions.
+ */
+class CompoundActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructs a new CompoundActionProvider instance.
+     */
+    constructor() {
+        super("compound", []);
+        /**
+         * Checks if the Compound action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the network is supported, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" &&
+            (network.networkId === "base-mainnet" || network.networkId === "base-sepolia");
+    }
+    /**
+     * Supplies collateral assets to Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    async supply(wallet, args) {
+        try {
+            const network = wallet.getNetwork();
+            const cometAddress = (0, utils_2.getCometAddress)(network);
+            const tokenAddress = (0, utils_2.getAssetAddress)(network, args.assetId);
+            if (!tokenAddress) {
+                throw new Error(`Token address undefined for assetId ${args.assetId}`);
+            }
+            const decimals = await (0, utils_2.getTokenDecimals)(wallet, tokenAddress);
+            const amountAtomic = (0, viem_1.parseUnits)(args.amount, decimals);
+            // Check wallet balance before proceeding
+            const walletBalance = await (0, utils_2.getTokenBalance)(wallet, tokenAddress);
+            if (walletBalance < amountAtomic) {
+                const humanBalance = (0, viem_1.formatUnits)(walletBalance, decimals);
+                return `Error: Insufficient balance. You have ${humanBalance}, but trying to supply ${args.amount}`;
+            }
+            // Get current health ratio for reference
+            const currentHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            // Approve Compound to spend tokens
+            const approvalResult = await (0, utils_1.approve)(wallet, tokenAddress, cometAddress, amountAtomic);
+            if (approvalResult.startsWith("Error")) {
+                return `Error approving token: ${approvalResult}`;
+            }
+            // Supply tokens to Compound
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "supply",
+                args: [tokenAddress, amountAtomic],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: cometAddress,
+                data,
+            });
+            await wallet.waitForTransactionReceipt(txHash);
+            // Get new health ratio and token symbol
+            const newHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const tokenSymbol = await (0, utils_2.getTokenSymbol)(wallet, tokenAddress);
+            // Only add the health ratio message if at least one of the values is not Infinity
+            const healthMessage = currentHealth.eq(Infinity) && newHealth.eq(Infinity)
+                ? ""
+                : `\nHealth ratio changed from ${currentHealth.toFixed(2)} to ${newHealth.toFixed(2)}`;
+            return `Supplied ${args.amount} ${tokenSymbol} to Compound.\nTransaction hash: ${txHash}${healthMessage}`;
+        }
+        catch (error) {
+            return `Error supplying to Compound: ${error instanceof Error
+                ? error.message
+                : error && typeof error === "object" && "message" in error
+                    ? `Error: ${error.message}`
+                    : error}`;
+        }
+    }
+    /**
+     * Withdraws collateral assets from Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    async withdraw(wallet, args) {
+        try {
+            const cometAddress = (0, utils_2.getCometAddress)(wallet.getNetwork());
+            const tokenAddress = (0, utils_2.getAssetAddress)(wallet.getNetwork(), args.assetId);
+            const decimals = await (0, utils_2.getTokenDecimals)(wallet, tokenAddress);
+            const amountAtomic = (0, viem_1.parseUnits)(args.amount, decimals);
+            // Check that there is enough collateral supplied to withdraw
+            const collateralBalance = await (0, utils_2.getCollateralBalance)(wallet, cometAddress, tokenAddress);
+            if (amountAtomic > collateralBalance) {
+                const humanBalance = (0, viem_1.formatUnits)(collateralBalance, decimals);
+                return `Error: Insufficient balance. Trying to withdraw ${args.amount}, but only have ${humanBalance} supplied`;
+            }
+            // Check if position would be healthy after withdrawal
+            const projectedHealthRatio = await (0, utils_2.getHealthRatioAfterWithdraw)(wallet, cometAddress, tokenAddress, amountAtomic);
+            if (projectedHealthRatio.lessThan(1)) {
+                return `Error: Withdrawing ${args.amount} would result in an unhealthy position. Health ratio would be ${projectedHealthRatio.toFixed(2)}`;
+            }
+            // Withdraw from Compound
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "withdraw",
+                args: [tokenAddress, amountAtomic],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: cometAddress,
+                data,
+            });
+            await wallet.waitForTransactionReceipt(txHash);
+            // Get current and new health ratios and token symbol
+            const currentHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const newHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const tokenSymbol = await (0, utils_2.getTokenSymbol)(wallet, tokenAddress);
+            return (`Withdrawn ${args.amount} ${tokenSymbol} from Compound.\n` +
+                `Transaction hash: ${txHash}\n` +
+                `Health ratio changed from ${currentHealth.toFixed(2)} to ${newHealth.toFixed(2)}`);
+        }
+        catch (error) {
+            return `Error withdrawing from Compound: ${error instanceof Error ? error : error && typeof error === "object" && "message" in error ? `Error: ${error.message}` : error}`;
+        }
+    }
+    /**
+     * Borrows base assets from Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    async borrow(wallet, args) {
+        try {
+            const cometAddress = (0, utils_2.getCometAddress)(wallet.getNetwork());
+            const baseTokenAddress = await (0, utils_2.getBaseTokenAddress)(wallet, cometAddress);
+            const decimals = await (0, utils_2.getTokenDecimals)(wallet, baseTokenAddress);
+            // Convert human-readable amount to atomic units
+            const amountAtomic = (0, viem_1.parseUnits)(args.amount, decimals);
+            // Get current health ratio for reference
+            const currentHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const currentHealthStr = currentHealth.eq(Infinity) ? "Inf.%" : currentHealth.toFixed(2);
+            // Check if position would be healthy after borrow
+            const projectedHealthRatio = await (0, utils_2.getHealthRatioAfterBorrow)(wallet, cometAddress, amountAtomic);
+            if (projectedHealthRatio.lessThan(1)) {
+                return `Error: Borrowing ${args.amount} USDC would result in an unhealthy position. Health ratio would be ${projectedHealthRatio.toFixed(2)}`;
+            }
+            // Use the withdraw method to borrow from Compound
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "withdraw",
+                args: [baseTokenAddress, amountAtomic],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: cometAddress,
+                data,
+            });
+            await wallet.waitForTransactionReceipt(txHash);
+            // Get new health ratio
+            const newHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const newHealthStr = newHealth.eq(Infinity) ? "Inf.%" : newHealth.toFixed(2);
+            return (`Borrowed ${args.amount} USDC from Compound.\n` +
+                `Transaction hash: ${txHash}\n` +
+                `Health ratio changed from ${currentHealthStr} to ${newHealthStr}`);
+        }
+        catch (error) {
+            return `Error borrowing from Compound: ${error instanceof Error ? error : error && typeof error === "object" && "message" in error ? `Error: ${error.message}` : error}`;
+        }
+    }
+    /**
+     * Repays borrowed assets to Compound.
+     *
+     * @param wallet - The wallet instance to perform the transaction.
+     * @param args - The input arguments including assetId and amount.
+     * @returns A message indicating success or an error message.
+     */
+    async repay(wallet, args) {
+        try {
+            const cometAddress = (0, utils_2.getCometAddress)(wallet.getNetwork());
+            const tokenAddress = (0, utils_2.getAssetAddress)(wallet.getNetwork(), args.assetId);
+            const tokenDecimals = await (0, utils_2.getTokenDecimals)(wallet, tokenAddress);
+            const amountAtomic = (0, viem_1.parseUnits)(args.amount, tokenDecimals);
+            const tokenBalance = await (0, utils_2.getTokenBalance)(wallet, tokenAddress);
+            if (tokenBalance < amountAtomic) {
+                const humanBalance = (0, viem_1.formatUnits)(tokenBalance, tokenDecimals);
+                return `Error: Insufficient balance. You have ${humanBalance}, but trying to repay ${args.amount}`;
+            }
+            // Get current health ratio for reference
+            const currentHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            // Approve Compound to spend tokens
+            const approvalResult = await (0, utils_1.approve)(wallet, tokenAddress, cometAddress, amountAtomic);
+            if (approvalResult.startsWith("Error")) {
+                return `Error approving token: ${approvalResult}`;
+            }
+            // Repay debt by supplying tokens to Compound
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.COMET_ABI,
+                functionName: "supply",
+                args: [tokenAddress, amountAtomic],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: cometAddress,
+                data,
+            });
+            await wallet.waitForTransactionReceipt(txHash);
+            // Get new health ratio and token symbol
+            const newHealth = await (0, utils_2.getHealthRatio)(wallet, cometAddress);
+            const tokenSymbol = await (0, utils_2.getTokenSymbol)(wallet, tokenAddress);
+            return (`Repaid ${args.amount} ${tokenSymbol} to Compound.\n` +
+                `Transaction hash: ${txHash}\n` +
+                `Health ratio improved from ${currentHealth.toFixed(2)} to ${newHealth.toFixed(2)}`);
+        }
+        catch (error) {
+            return `Error repaying to Compound: ${error instanceof Error ? error : error && typeof error === "object" && "message" in error ? `Error: ${error.message}` : error}`;
+        }
+    }
+    /**
+     * Retrieves portfolio details from Compound.
+     *
+     * @param wallet - The wallet instance to fetch portfolio details.
+     * @param _ - No input is required for this action.
+     * @returns A Markdown formatted string with portfolio details or an error message.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getPortfolio(wallet, _) {
+        try {
+            const cometAddress = (0, utils_2.getCometAddress)(wallet.getNetwork());
+            return await (0, utils_2.getPortfolioDetailsMarkdown)(wallet, cometAddress);
+        }
+        catch (error) {
+            return `Error getting portfolio details: ${error && typeof error === "object" && "message" in error ? error.message : error}`;
+        }
+    }
+}
+exports.CompoundActionProvider = CompoundActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "supply",
+        description: `
+This tool allows supplying collateral assets to Compound.
+It takes:
+- assetId: The asset to supply, one of 'weth', 'cbeth', 'cbbtc', 'wsteth', or 'usdc'
+- amount: The amount of tokens to supply in human-readable format
+Examples:
+- 1 WETH
+- 0.1 WETH
+- 0.01 WETH
+Important notes:
+- Use the exact amount provided
+- The token must be an approved collateral asset for the Compound market
+    `,
+        schema: schemas_1.CompoundSupplySchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CompoundActionProvider.prototype, "supply", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "withdraw",
+        description: `
+This tool allows withdrawing collateral assets from Compound.
+It takes:
+- assetId: The asset to withdraw, one of 'weth', 'cbeth', 'cbbtc', 'wsteth', or 'usdc'
+- amount: The amount of tokens to withdraw in human-readable format
+Examples:
+- 1 WETH
+- 0.1 WETH
+- 0.01 WETH
+Important notes:
+- Use the exact amount provided
+- The token must be a collateral asset you have supplied to the Compound market
+    `,
+        schema: schemas_1.CompoundWithdrawSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CompoundActionProvider.prototype, "withdraw", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "borrow",
+        description: `
+This tool allows borrowing base assets from Compound.
+It takes:
+- assetId: The asset to borrow, either 'weth' or 'usdc'
+- amount: The amount of base tokens to borrow in human-readable format
+Examples:
+- 1000 USDC
+- 0.5 WETH
+Important notes:
+- Use the exact amount provided
+- Ensure you have sufficient collateral to borrow
+    `,
+        schema: schemas_1.CompoundBorrowSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CompoundActionProvider.prototype, "borrow", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "repay",
+        description: `
+This tool allows repaying borrowed assets to Compound.
+It takes:
+- assetId: The asset to repay, either 'weth' or 'usdc'
+- amount: The amount of tokens to repay in human-readable format
+Examples:
+- 1000 USDC
+- 0.5 WETH
+Important notes:
+- Use the exact amount provided
+- Ensure you have sufficient balance of the asset to repay
+    `,
+        schema: schemas_1.CompoundRepaySchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CompoundActionProvider.prototype, "repay", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_portfolio",
+        description: `
+This tool allows getting portfolio details from Compound.
+Returns portfolio details including:
+- Collateral balances and USD values
+- Borrowed amounts and USD values
+Formatted in Markdown for readability.
+    `,
+        schema: schemas_1.CompoundPortfolioSchema,
+    })
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CompoundActionProvider.prototype, "getPortfolio", null);
+/**
+ * Factory function to create a new instance of CompoundActionProvider.
+ *
+ * @returns A new CompoundActionProvider instance.
+ */
+const compoundActionProvider = () => new CompoundActionProvider();
+exports.compoundActionProvider = compoundActionProvider;

package/dist/action-providers/compound/compoundActionProvider.test.d.ts

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