@aave/cli 4.1.2 → 4.1.4

package/dist/commands/action/borrow.d.ts

@@ -0,0 +1,12 @@
+import { InvariantError, type SendWithError, type TimeoutError, type TransactionReceipt } from '@aave/client';
+import * as common from '../../common.js';
+export default class ActionBorrow extends common.V4Command {
+    static description: string;
+    static flags: {
+        'reserve-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        amount: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'private-key': import("@oclif/core/interfaces").OptionFlag<`0x${string}` | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private getBorrowRequest;
+    run(): Promise<TransactionReceipt | InvariantError | SendWithError | TimeoutError>;
+}

package/dist/commands/action/borrow.js

@@ -0,0 +1,81 @@
+import { bigDecimal, evmAddress, InvariantError, invariant, ok, ResultAsync, reserveId, } from '@aave/client';
+import { borrow, reserve } from '@aave/client/actions';
+import { sendWith, toViemChain } from '@aave/client/viem';
+import { Flags } from '@oclif/core';
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as common from '../../common.js';
+export default class ActionBorrow extends common.V4Command {
+    static description = 'Borrow ERC20 tokens from a reserve';
+    static flags = {
+        'reserve-id': Flags.string({
+            required: true,
+            description: 'Reserve ID of the reserve to borrow from',
+        }),
+        amount: Flags.string({
+            required: true,
+            description: 'Amount of the token to borrow',
+        }),
+        'private-key': common.privateKey({
+            required: false,
+        }),
+    };
+    getBorrowRequest() {
+        return ResultAsync.fromPromise(this.parse(ActionBorrow), (error) => new InvariantError(String(error))).andThen(({ flags }) => {
+            const privateKey = (flags['private-key'] ??
+                process.env.PRIVATE_KEY);
+            invariant(privateKey, 'Provide --private-key or PRIVATE_KEY environment variable');
+            const parsedReserveId = reserveId(flags['reserve-id']);
+            const amount = flags.amount.trim();
+            invariant(amount.length > 0, 'Amount cannot be empty');
+            const account = privateKeyToAccount(privateKey);
+            const sender = evmAddress(account.address);
+            return reserve(this.client, {
+                query: { reserveId: parsedReserveId },
+                user: sender,
+            }).andThen((reserveData) => {
+                invariant(reserveData, `Reserve not found: ${flags['reserve-id']}`);
+                return ok({
+                    request: {
+                        reserve: reserveData.id,
+                        amount: {
+                            erc20: {
+                                value: bigDecimal(amount),
+                            },
+                        },
+                        sender,
+                    },
+                    reserve: reserveData,
+                    amount,
+                    privateKey,
+                });
+            });
+        });
+    }
+    async run() {
+        const result = await this.getBorrowRequest().andThen(({ request, reserve, amount, privateKey }) => {
+            const wallet = createWalletClient({
+                account: privateKeyToAccount(privateKey),
+                chain: toViemChain(reserve.chain),
+                transport: http(reserve.chain.rpcUrl),
+            });
+            return borrow(this.client, request)
+                .andThen(sendWith(wallet))
+                .andTee((txResult) => this.log(`Borrow transaction sent with hash: ${txResult.txHash}`))
+                .andThen(this.client.waitForTransaction)
+                .map((txResult) => {
+                this.display([
+                    ['Reserve ID', reserve.id],
+                    ['Amount', `${amount} - ${reserve.asset.underlying.info.symbol}`],
+                    ['Transaction Hash', txResult.txHash],
+                    ['Url', `${reserve.chain.explorerUrl}/tx/${txResult.txHash}`],
+                ]);
+                return txResult;
+            });
+        });
+        if (result.isErr()) {
+            this.error(result.error);
+        }
+        return result.value;
+    }
+}

package/dist/commands/action/repay.d.ts

@@ -0,0 +1,12 @@
+import { InvariantError, type SendWithError, type TimeoutError, type TransactionReceipt } from '@aave/client';
+import * as common from '../../common.js';
+export default class ActionRepay extends common.V4Command {
+    static description: string;
+    static flags: {
+        'reserve-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        amount: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'private-key': import("@oclif/core/interfaces").OptionFlag<`0x${string}` | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private getRepayRequest;
+    run(): Promise<TransactionReceipt | InvariantError | SendWithError | TimeoutError>;
+}

package/dist/commands/action/repay.js

@@ -0,0 +1,83 @@
+import { bigDecimal, evmAddress, InvariantError, invariant, ok, ResultAsync, reserveId, } from '@aave/client';
+import { repay, reserve } from '@aave/client/actions';
+import { sendWith, toViemChain } from '@aave/client/viem';
+import { Flags } from '@oclif/core';
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as common from '../../common.js';
+export default class ActionRepay extends common.V4Command {
+    static description = 'Repay ERC20 debt to a reserve';
+    static flags = {
+        'reserve-id': Flags.string({
+            required: true,
+            description: 'Reserve ID of the reserve to repay',
+        }),
+        amount: Flags.string({
+            required: true,
+            description: 'Amount of the token to repay',
+        }),
+        'private-key': common.privateKey({
+            required: false,
+        }),
+    };
+    getRepayRequest() {
+        return ResultAsync.fromPromise(this.parse(ActionRepay), (error) => new InvariantError(String(error))).andThen(({ flags }) => {
+            const privateKey = (flags['private-key'] ??
+                process.env.PRIVATE_KEY);
+            invariant(privateKey, 'Provide --private-key or PRIVATE_KEY environment variable');
+            const parsedReserveId = reserveId(flags['reserve-id']);
+            const amount = flags.amount.trim();
+            invariant(amount.length > 0, 'Amount cannot be empty');
+            const account = privateKeyToAccount(privateKey);
+            const sender = evmAddress(account.address);
+            return reserve(this.client, {
+                query: { reserveId: parsedReserveId },
+                user: sender,
+            }).andThen((reserveData) => {
+                invariant(reserveData, `Reserve not found: ${flags['reserve-id']}`);
+                return ok({
+                    request: {
+                        reserve: reserveData.id,
+                        amount: {
+                            erc20: {
+                                value: {
+                                    exact: bigDecimal(amount),
+                                },
+                            },
+                        },
+                        sender,
+                    },
+                    reserve: reserveData,
+                    amount,
+                    privateKey,
+                });
+            });
+        });
+    }
+    async run() {
+        const result = await this.getRepayRequest().andThen(({ request, reserve, amount, privateKey }) => {
+            const wallet = createWalletClient({
+                account: privateKeyToAccount(privateKey),
+                chain: toViemChain(reserve.chain),
+                transport: http(reserve.chain.rpcUrl),
+            });
+            return repay(this.client, request)
+                .andThen(sendWith(wallet))
+                .andTee((txResult) => this.log(`Repay transaction sent with hash: ${txResult.txHash}`))
+                .andThen(this.client.waitForTransaction)
+                .map((txResult) => {
+                this.display([
+                    ['Reserve ID', reserve.id],
+                    ['Amount', `${amount} - ${reserve.asset.underlying.info.symbol}`],
+                    ['Transaction Hash', txResult.txHash],
+                    ['Url', `${reserve.chain.explorerUrl}/tx/${txResult.txHash}`],
+                ]);
+                return txResult;
+            });
+        });
+        if (result.isErr()) {
+            this.error(result.error);
+        }
+        return result.value;
+    }
+}

package/dist/commands/action/supply.d.ts

@@ -0,0 +1,13 @@
+import { InvariantError, type SendWithError, type TimeoutError, type TransactionReceipt } from '@aave/client';
+import * as common from '../../common.js';
+export default class ActionSupply extends common.V4Command {
+    static description: string;
+    static flags: {
+        'reserve-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        amount: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'private-key': import("@oclif/core/interfaces").OptionFlag<`0x${string}` | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'enable-collateral': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private getSupplyRequest;
+    run(): Promise<TransactionReceipt | InvariantError | SendWithError | TimeoutError>;
+}

package/dist/commands/action/supply.js

@@ -0,0 +1,89 @@
+import { bigDecimal, evmAddress, InvariantError, invariant, ok, ResultAsync, reserveId, } from '@aave/client';
+import { reserve, supply } from '@aave/client/actions';
+import { sendWith, toViemChain } from '@aave/client/viem';
+import { Flags } from '@oclif/core';
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as common from '../../common.js';
+export default class ActionSupply extends common.V4Command {
+    static description = 'Supply ERC20 tokens to a reserve';
+    static flags = {
+        'reserve-id': Flags.string({
+            required: true,
+            description: 'Reserve ID of the reserve to supply',
+        }),
+        amount: Flags.string({
+            required: true,
+            description: 'Amount of the token to supply',
+        }),
+        'private-key': common.privateKey({
+            required: false,
+        }),
+        'enable-collateral': Flags.boolean({
+            required: false,
+            default: false,
+            description: 'If provided, the supplied position is enabled as collateral',
+        }),
+    };
+    getSupplyRequest() {
+        return ResultAsync.fromPromise(this.parse(ActionSupply), (error) => new InvariantError(String(error))).andThen(({ flags }) => {
+            const privateKey = (flags['private-key'] ??
+                process.env.PRIVATE_KEY);
+            invariant(privateKey, 'Provide --private-key or PRIVATE_KEY environment variable');
+            const parsedReserveId = reserveId(flags['reserve-id']);
+            const amount = flags.amount.trim();
+            const collateralEnabled = flags['enable-collateral'];
+            invariant(amount.length > 0, 'Amount cannot be empty');
+            const account = privateKeyToAccount(privateKey);
+            const sender = evmAddress(account.address);
+            return reserve(this.client, {
+                query: { reserveId: parsedReserveId },
+                user: sender,
+            }).andThen((reserveData) => {
+                invariant(reserveData, `Reserve not found: ${flags['reserve-id']}`);
+                return ok({
+                    request: {
+                        reserve: reserveData.id,
+                        amount: {
+                            erc20: {
+                                value: bigDecimal(amount),
+                            },
+                        },
+                        sender,
+                        enableCollateral: collateralEnabled ? true : null,
+                    },
+                    reserve: reserveData,
+                    amount,
+                    collateralEnabled,
+                    privateKey,
+                });
+            });
+        });
+    }
+    async run() {
+        const result = await this.getSupplyRequest().andThen(({ request, reserve, amount, privateKey }) => {
+            const wallet = createWalletClient({
+                account: privateKeyToAccount(privateKey),
+                chain: toViemChain(reserve.chain),
+                transport: http(reserve.chain.rpcUrl),
+            });
+            return supply(this.client, request)
+                .andThen(sendWith(wallet))
+                .andTee((txResult) => this.log(`Supply transaction sent with hash: ${txResult.txHash}`))
+                .andThen(this.client.waitForTransaction)
+                .map((txResult) => {
+                this.display([
+                    ['Reserve ID', reserve.id],
+                    ['Amount', `${amount} - ${reserve.asset.underlying.info.symbol}`],
+                    ['Transaction Hash', txResult.txHash],
+                    ['Url', `${reserve.chain.explorerUrl}/tx/${txResult.txHash}`],
+                ]);
+                return txResult;
+            });
+        });
+        if (result.isErr()) {
+            this.error(result.error);
+        }
+        return result.value;
+    }
+}

package/dist/commands/action/withdraw.d.ts

@@ -0,0 +1,12 @@
+import { InvariantError, type SendWithError, type TimeoutError, type TransactionReceipt } from '@aave/client';
+import * as common from '../../common.js';
+export default class ActionWithdraw extends common.V4Command {
+    static description: string;
+    static flags: {
+        'reserve-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        amount: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'private-key': import("@oclif/core/interfaces").OptionFlag<`0x${string}` | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private getWithdrawRequest;
+    run(): Promise<TransactionReceipt | InvariantError | SendWithError | TimeoutError>;
+}

package/dist/commands/action/withdraw.js

@@ -0,0 +1,81 @@
+import { bigDecimal, evmAddress, InvariantError, invariant, ok, ResultAsync, reserveId, } from '@aave/client';
+import { reserve, withdraw } from '@aave/client/actions';
+import { sendWith, toViemChain } from '@aave/client/viem';
+import { Flags } from '@oclif/core';
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as common from '../../common.js';
+export default class ActionWithdraw extends common.V4Command {
+    static description = 'Withdraw ERC20 tokens from a reserve';
+    static flags = {
+        'reserve-id': Flags.string({
+            required: true,
+            description: 'Reserve ID of the reserve to withdraw from',
+        }),
+        amount: Flags.string({
+            required: true,
+            description: 'Amount of the token to withdraw',
+        }),
+        'private-key': common.privateKey({
+            required: false,
+        }),
+    };
+    getWithdrawRequest() {
+        return ResultAsync.fromPromise(this.parse(ActionWithdraw), (error) => new InvariantError(String(error))).andThen(({ flags }) => {
+            const privateKey = (flags['private-key'] ??
+                process.env.PRIVATE_KEY);
+            invariant(privateKey, 'Provide --private-key or PRIVATE_KEY environment variable');
+            const parsedReserveId = reserveId(flags['reserve-id']);
+            const amount = flags.amount.trim();
+            invariant(amount.length > 0, 'Amount cannot be empty');
+            const account = privateKeyToAccount(privateKey);
+            const sender = evmAddress(account.address);
+            return reserve(this.client, {
+                query: { reserveId: parsedReserveId },
+                user: sender,
+            }).andThen((reserveData) => {
+                invariant(reserveData, `Reserve not found: ${flags['reserve-id']}`);
+                return ok({
+                    request: {
+                        reserve: reserveData.id,
+                        amount: {
+                            erc20: {
+                                exact: bigDecimal(amount),
+                            },
+                        },
+                        sender,
+                    },
+                    reserve: reserveData,
+                    amount,
+                    privateKey,
+                });
+            });
+        });
+    }
+    async run() {
+        const result = await this.getWithdrawRequest().andThen(({ request, reserve, amount, privateKey }) => {
+            const wallet = createWalletClient({
+                account: privateKeyToAccount(privateKey),
+                chain: toViemChain(reserve.chain),
+                transport: http(reserve.chain.rpcUrl),
+            });
+            return withdraw(this.client, request)
+                .andThen(sendWith(wallet))
+                .andTee((txResult) => this.log(`Withdraw transaction sent with hash: ${txResult.txHash}`))
+                .andThen(this.client.waitForTransaction)
+                .map((txResult) => {
+                this.display([
+                    ['Reserve ID', reserve.id],
+                    ['Amount', `${amount} - ${reserve.asset.underlying.info.symbol}`],
+                    ['Transaction Hash', txResult.txHash],
+                    ['Url', `${reserve.chain.explorerUrl}/tx/${txResult.txHash}`],
+                ]);
+                return txResult;
+            });
+        });
+        if (result.isErr()) {
+            this.error(result.error);
+        }
+        return result.value;
+    }
+}

package/dist/common.d.ts

@@ -17,6 +17,10 @@ export declare const address: import("@oclif/core/interfaces").FlagDefinition<Ev
     multiple: false;
     requiredOrDefaulted: false;
 }>;
+export declare const privateKey: import("@oclif/core/interfaces").FlagDefinition<`0x${string}`, import("@oclif/core/interfaces").CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
 export declare abstract class V4Command extends Command {
     protected headers: TtyTable.Header[];
     static enableJsonFlag: boolean;

package/dist/common.js

@@ -26,6 +26,13 @@ export const address = Flags.custom({
     parse: async (input) => evmAddress(input),
     helpValue: '<evm-address>',
 });
+export const privateKey = Flags.custom({
+    char: 'k',
+    name: 'private-key',
+    description: 'Private key to sign transactions (overrides PRIVATE_KEY env var)',
+    parse: async (input) => (input.startsWith('0x') ? input : `0x${input}`),
+    helpValue: '<private-key>',
+});
 function convertBigIntsToStrings(obj) {
     if (typeof obj === 'bigint') {
         return obj.toString();

package/oclif.manifest.json

@@ -1,5 +1,260 @@
 {
   "commands": {
+    "action:borrow": {
+      "aliases": [],
+      "args": {},
+      "description": "Borrow ERC20 tokens from a reserve",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "staging": {
+          "description": "Use staging environment",
+          "hidden": true,
+          "name": "staging",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "reserve-id": {
+          "description": "Reserve ID of the reserve to borrow from",
+          "name": "reserve-id",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "amount": {
+          "description": "Amount of the token to borrow",
+          "name": "amount",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "private-key": {
+          "char": "k",
+          "description": "Private key to sign transactions (overrides PRIVATE_KEY env var)",
+          "name": "private-key",
+          "required": false,
+          "hasDynamicHelp": false,
+          "helpValue": "<private-key>",
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "action:borrow",
+      "pluginAlias": "@aave/cli",
+      "pluginName": "@aave/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "action",
+        "borrow.js"
+      ]
+    },
+    "action:repay": {
+      "aliases": [],
+      "args": {},
+      "description": "Repay ERC20 debt to a reserve",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "staging": {
+          "description": "Use staging environment",
+          "hidden": true,
+          "name": "staging",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "reserve-id": {
+          "description": "Reserve ID of the reserve to repay",
+          "name": "reserve-id",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "amount": {
+          "description": "Amount of the token to repay",
+          "name": "amount",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "private-key": {
+          "char": "k",
+          "description": "Private key to sign transactions (overrides PRIVATE_KEY env var)",
+          "name": "private-key",
+          "required": false,
+          "hasDynamicHelp": false,
+          "helpValue": "<private-key>",
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "action:repay",
+      "pluginAlias": "@aave/cli",
+      "pluginName": "@aave/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "action",
+        "repay.js"
+      ]
+    },
+    "action:supply": {
+      "aliases": [],
+      "args": {},
+      "description": "Supply ERC20 tokens to a reserve",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "staging": {
+          "description": "Use staging environment",
+          "hidden": true,
+          "name": "staging",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "reserve-id": {
+          "description": "Reserve ID of the reserve to supply",
+          "name": "reserve-id",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "amount": {
+          "description": "Amount of the token to supply",
+          "name": "amount",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "private-key": {
+          "char": "k",
+          "description": "Private key to sign transactions (overrides PRIVATE_KEY env var)",
+          "name": "private-key",
+          "required": false,
+          "hasDynamicHelp": false,
+          "helpValue": "<private-key>",
+          "multiple": false,
+          "type": "option"
+        },
+        "enable-collateral": {
+          "description": "If provided, the supplied position is enabled as collateral",
+          "name": "enable-collateral",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "action:supply",
+      "pluginAlias": "@aave/cli",
+      "pluginName": "@aave/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "action",
+        "supply.js"
+      ]
+    },
+    "action:withdraw": {
+      "aliases": [],
+      "args": {},
+      "description": "Withdraw ERC20 tokens from a reserve",
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "staging": {
+          "description": "Use staging environment",
+          "hidden": true,
+          "name": "staging",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "reserve-id": {
+          "description": "Reserve ID of the reserve to withdraw from",
+          "name": "reserve-id",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "amount": {
+          "description": "Amount of the token to withdraw",
+          "name": "amount",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "private-key": {
+          "char": "k",
+          "description": "Private key to sign transactions (overrides PRIVATE_KEY env var)",
+          "name": "private-key",
+          "required": false,
+          "hasDynamicHelp": false,
+          "helpValue": "<private-key>",
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "action:withdraw",
+      "pluginAlias": "@aave/cli",
+      "pluginName": "@aave/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "action",
+        "withdraw.js"
+      ]
+    },
     "borrows:list": {
       "aliases": [],
       "args": {},
@@ -429,5 +684,5 @@
       ]
     }
   },
-  "version": "4.1.2"
+  "version": "4.1.4"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aave/cli",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "description": "CLI to interact with AaveKit API",
   "keywords": [
     "aave",
@@ -30,7 +30,8 @@
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
     "tty-table": "^5.0.0",
-    "@aave/client": "4.0.2"
+    "viem": "^2.47.0",
+    "@aave/client": "4.0.4"
   },
   "devDependencies": {
     "@oclif/test": "^4",
@@ -46,6 +47,9 @@
     "commands": "./dist/commands",
     "topicSeparator": " ",
     "topics": {
+      "action": {
+        "description": "Actions to perform in the Aave v4 protocol"
+      },
       "hubs": {
         "description": "List available liquidity hubs"
       },