@suzaku-network/suzaku-cli 1.0.2

package/dist/cli.js

@@ -0,0 +1,3183 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Temporarly rm warning from SafeSDK dependencies
+const _originalWarn = console.warn.bind(console);
+console.warn = function (...args) {
+    const msg = args.join(" ");
+    if (msg.includes("gelatonetwork")) {
+        return;
+    }
+    return _originalWarn(...args);
+};
+const extra_typings_1 = require("@commander-js/extra-typings");
+const viem_1 = require("viem");
+const l1_1 = require("./l1");
+const operator_1 = require("./operator");
+const config_1 = require("./config");
+const client_1 = require("./client");
+const logger_1 = require("./lib/logger");
+const vaultManager_1 = require("./vaultManager");
+const vault_1 = require("./vault");
+const delegator_1 = require("./delegator");
+const middleware_1 = require("./middleware");
+const operatorOptIn_1 = require("./operatorOptIn");
+const balancer_1 = require("./balancer");
+const uptime_1 = require("./uptime");
+const rewards_1 = require("./rewards");
+const transferUtils_1 = require("./lib/transferUtils");
+const utils_1 = require("./lib/utils");
+const keyStore_1 = require("./keyStore");
+const cliParser_1 = require("./lib/cliParser");
+const pChainUtils_1 = require("./lib/pChainUtils");
+const ts_belt_1 = require("@mobily/ts-belt");
+const securityModule_1 = require("./securityModule");
+const kiteStaking_1 = require("./kiteStaking");
+const stakingVault_1 = require("./stakingVault");
+const avalanchejs_1 = require("@avalabs/avalanchejs");
+const justification_1 = require("./lib/justification");
+const autoCompletion_1 = require("./lib/autoCompletion");
+const accessControl_1 = require("./accessControl");
+const viemUtils_1 = require("./lib/viemUtils");
+require("./lib/commandUtils");
+const child_process_1 = require("child_process");
+const chainList_1 = require("./lib/chainList");
+const fs_1 = require("fs");
+const package_json_1 = __importDefault(require("../package.json"));
+// Main function to set up the CLI commands
+async function main() {
+    const program = new extra_typings_1.Command()
+        .name('suzaku-cli')
+        .addOption(new extra_typings_1.Option('-n, --network <network>')
+        .choices(Object.keys(chainList_1.chainList))
+        .default('mainnet'))
+        .addOption(new extra_typings_1.Option('-r, --rpc-url <rpcUrl>', 'RPC URL for a custom network (automatically sets --network to custom)'))
+        .addOption(new extra_typings_1.Option('-k, --private-key <privateKey>', 'Private key in Hex format')
+        .env('PK').argParser(cliParser_1.ParserPrivateKey).conflicts(['secretName', 'ledger']))
+        .addOption(new extra_typings_1.Option('-s, --secret-name <secretName>', 'The keystore secret name containing the private key')
+        .conflicts(['privateKey', 'ledger'])
+        .argParser(cliParser_1.parseSecretName))
+        .addOption(new extra_typings_1.Option('-l, --ledger', 'Use Ledger hardware wallet for signing').conflicts(['privateKey', 'secretName']))
+        .addOption(new extra_typings_1.Option('-w, --wait <confirmations>', 'Number of confirmations to wait after a write transaction')
+        .default(2)
+        .argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--json", "Output logs in JSON format"))
+        .addOption(new extra_typings_1.Option('-y, --yes', 'Automatic yes to prompts'))
+        .addOption((0, cliParser_1.OptAddress)('--safe <address>', 'Use safe smart account for transactions'))
+        .addOption(new extra_typings_1.Option('--skip-abi-validation', 'Skip the ABI validation for used contract'))
+        .addOption(new extra_typings_1.Option('--cast', 'Output equivalent Foundry cast commands instead of executing write transactions').conflicts(['safe']))
+        .version(package_json_1.default.version)
+        .configureOutput({
+        writeOut: (str) => process.stdout.write(str),
+        writeErr: (str) => { str.includes('Usage: suzaku-cli') ? process.stdout.write(str) : process.stderr.write(str); },
+    });
+    // Set cast mode and handle --rpc-url/custom network before any command runs
+    program.hook('preSubcommand', async (thisCommand) => {
+        const opts = program.opts();
+        if (opts.cast)
+            (0, viemUtils_1.setCastMode)(true);
+        // Block manually private key on mainnet
+        if (opts.privateKey && chainList_1.chainList[opts.network].testnet === false) {
+            logger_1.logger.error("Using private key on mainnet is not allowed. Use the secret keystore or a ledger instead.");
+            process.exit(1);
+        }
+        if (opts.rpcUrl) {
+            await (0, chainList_1.setCustomChainRpcUrl)(opts.rpcUrl);
+            thisCommand.setOptionValue('network', 'custom');
+        }
+        else if (opts.network === 'custom') {
+            logger_1.logger.error('Error: --rpc-url is required when using --network custom');
+            process.exit(1);
+        }
+        // Activate json output if --json is provided
+        logger_1.logger.setJsonMode(opts.json);
+    });
+    program.hook("preAction", () => {
+        const opts = program.opts();
+        // Ensure privateKey is set if opts.secret or ledger is provided
+        if (opts.secretName) {
+            program.setOptionValue('privateKey', opts.secretName);
+        }
+        else if (opts.ledger) {
+            program.setOptionValue('privateKey', 'ledger');
+        }
+    });
+    program
+        .command('verify-abi')
+        .description('Verify that a contract at a given address matches the expected Suzaku ABI (5% tolerance)')
+        .addArgument((0, cliParser_1.ArgAddress)("address", "Contract address to test"))
+        .argument('abi', 'ABI name to test')
+        .asyncAction(async (config, address, abi) => {
+        await config.contracts[abi](address);
+        logger_1.logger.log(`Verified ABI for contract ${abi} at address ${address} ✅`);
+    });
+    /* --------------------------------------------------
+    * Common Args
+    * -------------------------------------------------- */
+    // Contract
+    const argValidatorManagerAddress = (0, cliParser_1.ArgAddress)("validatorManagerAddress", "L1 validator manager contract address");
+    const argBalancerAddress = (0, cliParser_1.ArgAddress)("balancerAddress", "Balancer validator manager contract address");
+    const argPoaSecurityModuleAddress = (0, cliParser_1.ArgAddress)("poaSecurityModuleAddress", "POA Security Module contract address");
+    const argMiddlewareAddress = (0, cliParser_1.ArgAddress)("middlewareAddress", "Middleware contract address");
+    const argMiddlewareVaultManagerAddress = (0, cliParser_1.ArgAddress)("middlewareVaultManagerAddress", "Middleware vault manager contract address");
+    const argVaultAddress = (0, cliParser_1.ArgAddress)("vaultAddress", "Vault contract address");
+    const argUptimeTrackerAddress = (0, cliParser_1.ArgAddress)("uptimeTrackerAddress", "UptimeTracker contract address");
+    const argRewardsAddress = (0, cliParser_1.ArgAddress)("rewardsAddress", "Rewards contract address");
+    const argRewardTokenAddress = (0, cliParser_1.ArgAddress)("rewardTokenAddress", "Reward token contract address");
+    const optKiteStakingManagerAddress = (0, cliParser_1.OptAddress)("--staking-manager-address <address>", "KiteStakingManager contract address");
+    const optStakingVaultAddress = (0, cliParser_1.OptAddress)("--staking-vault-address <address>", "Staking vault contract address");
+    const argAccessControlAddress = (0, cliParser_1.ArgAddress)("accessControlAddress", "A contract address with AccessControl functionalities");
+    // EOA
+    const argOperatorAddress = (0, cliParser_1.ArgAddress)("operator", "Operator address");
+    /* --------------------------------------------------
+    * Generic L1 Commands
+    * -------------------------------------------------- */
+    // topUpAllOperatorNodes
+    program
+        .command("top-up-l1-validators")
+        .description("Top up all/selected l1 validators to meet a target continuous fee balance")
+        .addArgument((0, cliParser_1.ArgCB58)("subnetID", "Subnet ID of the L1"))
+        .argument("targetBalance", "Target continuous fee balance per validator (in AVAX)")
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Add a validator to be topped up").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .asyncAction({ signer: true }, async (config, subnetID, targetBalance, options) => {
+        const opts = program.opts();
+        const client = await (0, client_1.generateClient)(opts.network, opts.privateKey, opts.safe);
+        const targetBalanceWei = (0, viem_1.parseUnits)(targetBalance, 9); // AVAX has 9 decimals
+        if (targetBalanceWei <= BigInt(1e7)) { // 0.01 AVAX min
+            throw new Error("Target balance must be greater than 0.01 AVAX");
+        }
+        const validators = await (0, pChainUtils_1.getCurrentValidators)(config.client, subnetID);
+        const validatorsToTopUp = validators.reduce((acc, validator) => {
+            if (options.nodeId && options.nodeId.length > 0 && !options.nodeId.includes(validator.nodeID)) {
+                return acc;
+            }
+            if (validator.balance < Number(targetBalanceWei) - 1e7) { // 0.01 AVAX min diff
+                acc.push({
+                    validationId: validator.validationID,
+                    topup: targetBalanceWei - BigInt(validator.balance),
+                });
+            }
+            return acc;
+        }, []);
+        const totalTopUp = validatorsToTopUp.reduce((acc, v) => acc + v.topup, 0n);
+        if (validatorsToTopUp.length === 0) {
+            logger_1.logger.log("All l1 validators have sufficient balance. No top-up needed.");
+            logger_1.logger.addData('total_amount', 0);
+            logger_1.logger.addData('validators', []);
+            return;
+        }
+        logger_1.logger.log(`${validatorsToTopUp.length} validators to top-up:`);
+        await (0, transferUtils_1.requirePChainBallance)(config.client, totalTopUp + BigInt(2e4) * BigInt(validatorsToTopUp.length), opts.yes); // extra 20000 for fees
+        if (!opts.yes) {
+            const response = await logger_1.logger.prompt(`Proceed with topping up validators? (y/n): `);
+            if (response.toLowerCase() !== 'y') {
+                logger_1.logger.log("Operation cancelled by user.");
+                process.exit(0);
+            }
+        }
+        for (const { validationId, topup } of validatorsToTopUp) {
+            logger_1.logger.log(`\nTopping up validator ${validationId}`);
+            const amount = Number(topup) / 1e9;
+            (0, ts_belt_1.pipe)(await (0, pChainUtils_1.increasePChainValidatorBalance)(config.client, amount, validationId, false), ts_belt_1.R.tapError(err => { logger_1.logger.error(err); process.exit(1); }));
+        }
+        logger_1.logger.log("\nCompleted top-up of validators.");
+        logger_1.logger.addData('total_amount', totalTopUp);
+        logger_1.logger.addData('validators', validatorsToTopUp);
+    });
+    /* --------------------------------------------------
+   * L1 REGISTRY COMMANDS
+   * -------------------------------------------------- */
+    const l1RegistryCmd = program
+        .command("l1-registry")
+        .description("Commands to interact with the Suzaku L1 Registry contract");
+    l1RegistryCmd
+        .command("register")
+        .description("Register a new L1 in the L1 registry")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgURI)("metadataUrl", "Metadata URL for the L1"))
+        .asyncAction({ signer: true }, async (config, l1Middleware, metadataUrl) => {
+        const middleware = await config.contracts.L1Middleware(l1Middleware);
+        const balancerAddress = await middleware.read.BALANCER();
+        // instantiate L1Registry and call
+        const l1Registry = await config.contracts.L1Registry();
+        await (0, l1_1.registerL1)(l1Registry, balancerAddress, l1Middleware, metadataUrl, config.client.account);
+    });
+    l1RegistryCmd
+        .command("get-all")
+        .description("List all L1s registered in the L1 registry")
+        .asyncAction(async (config) => {
+        const l1Registry = await config.contracts.L1Registry();
+        const l1s = await l1Registry.read.getAllL1s();
+        // l1s: [balancerAddress[], middleware[], metadataUrl[]]
+        const data = [];
+        for (let i = 0; i < l1s[0].length; i++) {
+            data.push({
+                MetadataUrl: l1s[2][i],
+                Balancer: l1s[0][i],
+                Middleware: l1s[1][i],
+            });
+        }
+        logger_1.logger.logJsonTree(data);
+    });
+    l1RegistryCmd
+        .command("set-metadata-url")
+        .description("Set metadata URL for an L1 in the L1 registry")
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgURI)("metadataUrl", "New metadata URL"))
+        .asyncAction({ signer: true }, async (config, l1Address, metadataUrl) => {
+        const l1Reg = await config.contracts.L1Registry();
+        await (0, l1_1.setL1MetadataUrl)(l1Reg, l1Address, metadataUrl);
+    });
+    l1RegistryCmd
+        .command("set-middleware")
+        .description("Set middleware address for an L1 in the L1 registry")
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("l1Middleware", "New L1 middleware address"))
+        .asyncAction({ signer: true }, async (config, l1Address, l1Middleware) => {
+        const l1Reg2 = await config.contracts.L1Registry();
+        await (0, l1_1.setL1Middleware)(l1Reg2, l1Address, l1Middleware);
+    });
+    /* --------------------------------------------------
+    * OPERATOR REGISTRY COMMANDS
+    * -------------------------------------------------- */
+    const operatorRegistryCmd = program
+        .command("operator-registry")
+        .description("Commands to interact with the Suzaku Operator Registry contract");
+    operatorRegistryCmd
+        .command("register")
+        .description("Register a new operator in the operator registry")
+        .addArgument((0, cliParser_1.ArgURI)("metadataUrl", "Operator metadata URL"))
+        .asyncAction({ signer: true }, async (config, metadataUrl) => {
+        const opReg = await config.contracts.OperatorRegistry();
+        await (0, operator_1.registerOperator)(opReg, metadataUrl);
+    });
+    operatorRegistryCmd
+        .command("get-all")
+        .description("List all operators registered in the operator registry")
+        .asyncAction(async (config) => {
+        const opReg2 = await config.contracts.OperatorRegistry();
+        await (0, operator_1.listOperators)(opReg2);
+    });
+    /* --------------------------------------------------
+    * VAULT MANAGER
+    * -------------------------------------------------- */
+    const vaultManagerCmd = program
+        .command("vault-manager")
+        .description("Commands to interact with the Vault Manager contract of an L1");
+    vaultManagerCmd
+        .command("register-vault-l1")
+        .description("Register a vault for L1 staking")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .argument("maxLimit", "Maximum limit (in decimal format)")
+        .asyncAction({ signer: true }, async (config, middlewareVaultManagerAddress, vaultAddress, collateralClass, maxLimit) => {
+        // instantiate VaultManager contract
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManagerAddress);
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const maxLimitWei = (0, viem_1.parseUnits)(maxLimit, await vault.read.decimals());
+        await (0, vaultManager_1.registerVaultL1)(vaultManager, vaultAddress, collateralClass, maxLimitWei, config.client.account);
+    });
+    vaultManagerCmd
+        .command("update-vault-max-l1-limit")
+        .description("Update the maximum L1 limit for a vault")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .argument("maxLimit", "Maximum limit")
+        .asyncAction({ signer: true }, async (config, middlewareVaultManagerAddress, vaultAddress, collateralClass, maxLimit) => {
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManagerAddress);
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const maxLimitWei = (0, viem_1.parseUnits)(maxLimit, await vault.read.decimals());
+        await (0, vaultManager_1.updateVaultMaxL1Limit)(vaultManager, vaultAddress, collateralClass, maxLimitWei, config.client.account);
+    });
+    vaultManagerCmd
+        .command("remove-vault")
+        .description("Remove a vault from L1 staking")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument(argVaultAddress)
+        .asyncAction({ signer: true }, async (config, middlewareVaultManager, vaultAddress) => {
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManager);
+        await (0, vaultManager_1.removeVault)(vaultManager, vaultAddress, config.client.account);
+    });
+    vaultManagerCmd
+        .command("get-vault-count")
+        .description("Get the number of vaults registered for L1 staking")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .asyncAction(async (config, middlewareVaultManager) => {
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManager);
+        await (0, vaultManager_1.getVaultCount)(vaultManager);
+    });
+    vaultManagerCmd
+        .command("get-vault-at-with-times")
+        .description("Get the vault address at a specific index along with its registration and removal times")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("index", "Vault index"))
+        .asyncAction(async (config, middlewareVaultManager, index) => {
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManager);
+        await (0, vaultManager_1.getVaultAtWithTimes)(vaultManager, index);
+    });
+    vaultManagerCmd
+        .command("get-vault-collateral-class")
+        .description("Get the collateral class ID associated with a vault")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, middlewareVaultManager, vaultAddress) => {
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManager);
+        await (0, vaultManager_1.getVaultCollateralClass)(vaultManager, vaultAddress);
+    });
+    /* --------------------------------------------------
+    * VAULT DEPOSIT/WITHDRAW/CLAIM/GRANT
+    * -------------------------------------------------- */
+    const vaultCmd = program
+        .command("vault")
+        .description("Commands to interact with a Vault and L1 Re-stake Delegator contracts");
+    vaultCmd
+        .command("deposit")
+        .description("Deposit tokens into the vault")
+        .addArgument(argVaultAddress)
+        .argument("amount", "Amount of token to deposit in the vault")
+        .addOption(new extra_typings_1.Option("--onBehalfOf <behalfOf>", "Optional onBehalfOf address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, amount, options) => {
+        const onBehalfOf = options.onBehalfOf ?? config.client.account.address;
+        await (0, vault_1.depositVault)(config, vaultAddress, onBehalfOf, amount);
+    });
+    vaultCmd
+        .command("withdraw")
+        .description("Withdraw tokens from the vault")
+        .addArgument(argVaultAddress)
+        .argument("amount", "Amount of token to withdraw in the vault")
+        .addOption(new extra_typings_1.Option("--claimer <claimer>", "Optional claimer").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, amount, options) => {
+        const claimer = options.claimer ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const amountWei = (0, viem_1.parseUnits)(amount, await vault.read.decimals());
+        await (0, vault_1.withdrawVault)(vault, claimer, amountWei);
+    });
+    vaultCmd
+        .command("claim")
+        .description("Claim withdrawn tokens from the vault for a specific epoch")
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("epoch", "Epoch number"))
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, epoch, options) => {
+        const recipient = options.recipient ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.claimVault)(vault, recipient, epoch);
+    });
+    vaultCmd
+        .command("grant-staker-role")
+        .description("Grant staker role on a vault to an account")
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account to grant the role to"))
+        .asyncAction({ signer: true }, async (config, vaultAddress, account) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await vault.safeWrite.grantRole([await vault.read.DEPOSITOR_WHITELIST_ROLE(), account], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Granted staker role to ${account} on vault (${await vault.read.name()}) ${vaultAddress}`);
+    });
+    vaultCmd
+        .command("revoke-staker-role")
+        .description("Revoke staker role on a vault from an account")
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account to revoke the role from"))
+        .asyncAction({ signer: true }, async (config, vaultAddress, account) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await vault.safeWrite.revokeRole([await vault.read.DEPOSITOR_WHITELIST_ROLE(), account], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Revoked staker role from ${account} on vault (${await vault.read.name()}) ${vaultAddress}`);
+    });
+    vaultCmd
+        .command("collateral-deposit")
+        .description("Approve and deposit tokens into the collateral contract associated with a vault")
+        .addArgument((0, cliParser_1.ArgAddress)("collateralAddress", "Collateral contract address"))
+        .argument("amount", "Amount of token to deposit in the collateral")
+        .asyncAction({ signer: true }, async (_, collateralAddress, amount) => {
+        const opts = program.opts();
+        const client = await (0, client_1.generateClient)(opts.network, opts.privateKey, opts.safe);
+        const config = (0, config_1.getConfig)(client, opts.wait, true); // skip abi validation as erc20 are commonly different
+        await (0, vault_1.approveAndDepositCollateral)(config, collateralAddress, amount);
+    });
+    // setIsDepositLimit
+    vaultCmd
+        .command("set-deposit-limit")
+        .description("Set deposit limit for a vault (0 will disable the limit)")
+        .addArgument(argVaultAddress)
+        .argument("limit", "Deposit limit amount")
+        .asyncAction({ signer: true }, async (config, vaultAddress, limit) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const limitWei = (0, viem_1.parseUnits)(limit, await vault.read.decimals());
+        const isLimitShouldBeEnabled = limitWei > 0n;
+        const isLimitEnabled = await vault.read.isDepositLimit();
+        if (isLimitShouldBeEnabled !== isLimitEnabled) {
+            await vault.safeWrite.setIsDepositLimit([isLimitShouldBeEnabled], {
+                chain: null,
+                account: config.client.account,
+            });
+            logger_1.logger.log(`Set deposit limit enabled to ${isLimitShouldBeEnabled} for vault (${await vault.read.name()}) ${vaultAddress}`);
+        }
+        await vault.safeWrite.setDepositLimit([limitWei], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Set deposit limit to ${limit} for vault (${await vault.read.name()}) ${vaultAddress}`);
+    });
+    // increaseLimit of the collateral
+    vaultCmd
+        .command("collateral-increase-limit")
+        .description("Set deposit limit for a collateral")
+        .addArgument(argVaultAddress)
+        .argument("limit", "Deposit limit amount")
+        .asyncAction({ signer: true }, async (config, vaultAddress, limit) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const collateralAddress = await vault.read.collateral();
+        const collateral = await config.contracts.DefaultCollateral(collateralAddress);
+        const limitWei = (0, viem_1.parseUnits)(limit, await collateral.read.decimals());
+        await collateral.safeWrite.increaseLimit([limitWei], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Collateral (${collateralAddress}) limit increased to ${limit} (${await collateral.read.name()})`);
+    });
+    /* --------------------------------------------------
+    * VAULT READ COMMANDS
+    * -------------------------------------------------- */
+    vaultCmd
+        .command("get-collateral")
+        .description("Get the collateral token address of a vault")
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, vaultAddress) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultCollateral)(vault);
+    });
+    vaultCmd
+        .command("get-delegator")
+        .description("Get the delegator address of a vault")
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, vaultAddress) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const delegator = await (0, vault_1.getVaultDelegator)(vault);
+        logger_1.logger.log("Vault delegator:", delegator);
+    });
+    vaultCmd
+        .command("get-balance")
+        .description("Get vault token balance for an account")
+        .addArgument(argVaultAddress)
+        .addOption(new extra_typings_1.Option("--account <account>", "Account to check balance for").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, options) => {
+        const account = options.account ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultBalanceOf)(vault, account);
+    });
+    vaultCmd
+        .command("get-active-balance")
+        .description("Get active vault balance for an account")
+        .addArgument(argVaultAddress)
+        .addOption(new extra_typings_1.Option("--account <account>", "Account to check balance for").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, options) => {
+        const account = options.account ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultActiveBalanceOf)(vault, account);
+    });
+    vaultCmd
+        .command("get-total-supply")
+        .description("Get total supply of vault tokens")
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, vaultAddress) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultTotalSupply)(vault);
+    });
+    vaultCmd
+        .command("get-withdrawal-shares")
+        .description("Get withdrawal shares for an account at a specific epoch")
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("epoch", "Epoch number"))
+        .addOption(new extra_typings_1.Option("--account <account>", "Account to check").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, epoch, options) => {
+        const account = options.account ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultWithdrawalSharesOf)(vault, epoch, account);
+    });
+    vaultCmd
+        .command("get-withdrawals")
+        .description("Get withdrawal amount for an account at a specific epoch")
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("epoch", "Epoch number"))
+        .addOption(new extra_typings_1.Option("--account <account>", "Account to check").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, vaultAddress, epoch, options) => {
+        const account = options.account ?? config.client.account.address;
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        await (0, vault_1.getVaultWithdrawalsOf)(vault, epoch, account);
+    });
+    // Get deposit limit
+    vaultCmd
+        .command("get-deposit-limit")
+        .description("Get deposit limit for a vault")
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, vaultAddress) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const limit = await vault.read.depositLimit();
+        const isLimitEnabled = await vault.read.isDepositLimit();
+        logger_1.logger.log(`Deposit limit for vault ${vaultAddress}: ${(0, viem_1.formatUnits)(limit, await vault.read.decimals())} (enabled: ${isLimitEnabled})`);
+    });
+    /* --------------------------------------------------
+    * L1RestakeDelegator (set-l1-limit / set-operator-l1-shares)
+    * -------------------------------------------------- */
+    vaultCmd
+        .command("set-l1-limit")
+        .description("Set the L1 limit for a vault's delegator")
+        .addArgument(argVaultAddress)
+        .addArgument(argValidatorManagerAddress)
+        .argument("limit", "Limit amount")
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, vaultAddress, l1Address, limit, collateralClass) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const delegatorAddress = await vault.read.delegator();
+        // instantiate L1RestakeDelegator contract
+        const delegator = await config.contracts.L1RestakeDelegator(delegatorAddress);
+        const limitWei = (0, viem_1.parseUnits)(limit, await vault.read.decimals());
+        await (0, delegator_1.setL1Limit)(delegator, l1Address, collateralClass, limitWei);
+    });
+    vaultCmd
+        .command("set-operator-l1-shares")
+        .description("Set the L1 shares for an operator in a delegator")
+        .addArgument(argVaultAddress)
+        .addArgument(argValidatorManagerAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("shares", "Shares amount"))
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, vaultAddress, l1Address, operatorAddress, shares, collateralClass) => {
+        // instantiate L1RestakeDelegator contract
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const delegatorAddress = await vault.read.delegator();
+        const delegator = await config.contracts.L1RestakeDelegator(delegatorAddress);
+        await (0, delegator_1.setOperatorL1Shares)(delegator, l1Address, collateralClass, operatorAddress, shares);
+    });
+    vaultCmd
+        .command("get-l1-limit")
+        .description("Get L1 limit for a vault's delegator")
+        .addArgument(argVaultAddress)
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction(async (config, vaultAddress, l1Address, collateralClass) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const delegatorAddress = await vault.read.delegator();
+        // instantiate L1RestakeDelegator contract
+        const delegator = await config.contracts.L1RestakeDelegator(delegatorAddress);
+        const limit = await delegator.read.l1Limit([l1Address, collateralClass]);
+        logger_1.logger.log(`L1 limit for vault ${vaultAddress} on L1 ${l1Address} (collateral class ${collateralClass}): ${(0, viem_1.formatUnits)(limit, await vault.read.decimals())}`);
+    });
+    vaultCmd
+        .command("get-operator-l1-shares")
+        .description("Get L1 shares for an operator in a vault's delegator")
+        .addArgument(argVaultAddress)
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, vaultAddress, l1Address, collateralClass, operatorAddress) => {
+        const vault = await config.contracts.VaultTokenized(vaultAddress);
+        const delegatorAddress = await vault.read.delegator();
+        // instantiate L1RestakeDelegator contract
+        const delegator = await config.contracts.L1RestakeDelegator(delegatorAddress);
+        const shares = await delegator.read.operatorL1Shares([l1Address, collateralClass, operatorAddress]);
+        logger_1.logger.log(`L1 shares for operator ${operatorAddress} in vault ${vaultAddress} on L1 ${l1Address} (collateral class ${collateralClass}): ${shares}`);
+    });
+    /* --------------------------------------------------
+    * MIDDLEWARE
+    * -------------------------------------------------- */
+    const middlewareCmd = program
+        .command("middleware")
+        .description("Commands to interact with the L1 Middleware contract");
+    // Add secondary collateral class
+    middlewareCmd
+        .command("add-collateral-class")
+        .description("Add a new collateral class to the middleware")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .argument("minValidatorStake", "Minimum validator stake amount")
+        .argument("maxValidatorStake", "Maximum validator stake amount")
+        .addArgument((0, cliParser_1.ArgAddress)("initialCollateral", "Initial collateral address"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId, minValidatorStake, maxValidatorStake, initialCollateral) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const collateral = await config.contracts.DefaultCollateral(initialCollateral);
+        const decimals = await collateral.read.decimals();
+        const minStakeWei = (0, viem_1.parseUnits)(minValidatorStake, decimals);
+        const maxStakeWei = (0, viem_1.parseUnits)(maxValidatorStake, decimals);
+        await middlewareSvc.safeWrite.addCollateralClass([collateralClassId, minStakeWei, maxStakeWei, initialCollateral], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Added collateral class ${collateralClassId} with min stake ${minValidatorStake} and max stake ${maxValidatorStake} using collateral at ${initialCollateral}`);
+    });
+    // Add collateral to class
+    middlewareCmd
+        .command("add-collateral-to-class")
+        .description("Add a new collateral address to an existing collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .addArgument((0, cliParser_1.ArgAddress)("collateralAddress", "Collateral address to add"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId, collateralAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await middlewareSvc.safeWrite.addAssetToClass([collateralClassId, collateralAddress], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Added collateral ${collateralAddress} to class ${collateralClassId}`);
+    });
+    // removeAssetFromClass
+    middlewareCmd
+        .command("remove-collateral-from-class")
+        .description("Remove a collateral address from an existing collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .addArgument((0, cliParser_1.ArgAddress)("collateralAddress", "Collateral address to remove"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId, collateralAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const tx = await middlewareSvc.safeWrite.removeAssetFromClass([collateralClassId, collateralAddress], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Removed collateral ${collateralAddress} from class ${collateralClassId}`);
+        logger_1.logger.log("tx hash:", tx);
+    });
+    // removeCollateralClass
+    middlewareCmd
+        .command("remove-collateral-class")
+        .description("Remove an existing secondary collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await middlewareSvc.safeWrite.removeCollateralClass([collateralClassId], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Removed collateral class ${collateralClassId}`);
+    });
+    // activateSecondaryCollateralClass
+    middlewareCmd
+        .command("activate-collateral-class")
+        .description("Activate a secondary collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await middlewareSvc.safeWrite.activateSecondaryCollateralClass([collateralClassId], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Activated collateral class ${collateralClassId}`);
+    });
+    // deactivateSecondaryCollateralClass
+    middlewareCmd
+        .command("deactivate-collateral-class")
+        .description("Deactivate a secondary collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClassId", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, collateralClassId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await middlewareSvc.safeWrite.deactivateSecondaryCollateralClass([collateralClassId], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`Deactivated collateral class ${collateralClassId}`);
+    });
+    // Register operator
+    middlewareCmd
+        .command("register-operator")
+        .description("Register an operator to operate on this L1")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction({ signer: true }, async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareRegisterOperator)(middlewareSvc, operator);
+    });
+    // Disable operator
+    middlewareCmd
+        .command("disable-operator")
+        .description("Disable an operator to prevent it from operating on this L1")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction({ signer: true }, async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareDisableOperator)(middlewareSvc, operator);
+    });
+    // Remove operator
+    middlewareCmd
+        .command("remove-operator")
+        .description("Remove an operator from this L1")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction({ signer: true }, async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareRemoveOperator)(middlewareSvc, operator);
+    });
+    // Process node stake cache
+    middlewareCmd
+        .command("process-node-stake-cache")
+        .description("Manually process node stake cache for one or more epochs")
+        .addArgument(argMiddlewareAddress)
+        .addOption(new extra_typings_1.Option("--epochs <epochs>", "Number of epochs to process (default: all)").default(0).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--loop-epochs <count>", "Loop through multiple epochs, processing --epochs at a time").argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--delay <milliseconds>", "Delay between loop iterations in milliseconds (default: 1000)").default(1000).argParser(cliParser_1.ParserNumber))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, options) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        let epochsPerCall;
+        let loopCount;
+        if (options.epochs || options.loopEpochs) { // Fully specified by user
+            epochsPerCall = options.epochs || 1;
+            loopCount = options.loopEpochs || 1;
+        }
+        else { // Automatic calculation
+            epochsPerCall = await middlewareSvc.read.getCurrentEpoch() - await middlewareSvc.read.lastGlobalNodeStakeUpdateEpoch();
+            loopCount = epochsPerCall > 50 ? Math.ceil(epochsPerCall / 50) : 1; // Limit number of epochs processed in a single call to avoid gas issues
+            epochsPerCall = Math.ceil(epochsPerCall / loopCount);
+        }
+        logger_1.logger.log(`Processing node stake cache: ${loopCount} iterations of ${epochsPerCall} epoch(s) each`);
+        for (let i = 0; i < loopCount; i++) {
+            logger_1.logger.log(`\nIteration ${i + 1}/${loopCount}`);
+            await (0, middleware_1.middlewareManualProcessNodeStakeCache)(middlewareSvc, epochsPerCall);
+            if (i < loopCount - 1 && options.delay > 0) {
+                logger_1.logger.log(`Waiting ${options.delay}ms before next iteration...`);
+                await new Promise(resolve => setTimeout(resolve, options.delay));
+            }
+        }
+        logger_1.logger.log(`\nCompleted processing ${loopCount * epochsPerCall} total epochs`);
+    });
+    // Add node
+    middlewareCmd
+        .command("add-node")
+        .description("Add a new node to an L1")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgHex)("blsKey", "BLS public key"))
+        .addOption(new extra_typings_1.Option("--initial-stake <initialStake>", "Initial stake amount (default: 0)").default('0'))
+        .addOption(new extra_typings_1.Option("--registration-expiry <expiry>", "Expiry timestamp (default: now + 12 hours)"))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-threshold <threshold>", "P-Chain remaining balance owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-threshold <threshold>", "P-Chain disable owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-address <address>", "P-Chain remaining balance owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-address <address>", "P-Chain disable owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, nodeId, blsKey, options) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const defaultOwnerAddress = (0, viem_1.fromBytes)(avalanchejs_1.utils.bech32ToBytes(config.client.addresses.P), 'hex');
+        // Default registration expiry to now + 12 hours if not provided
+        // const registrationExpiry = options.registrationExpiry
+        //     ? BigInt(options.registrationExpiry)
+        //     : BigInt(Math.floor(Date.now() / 1000) + 12 * 60 * 60); // current time + 12 hours in seconds
+        // Build remainingBalanceOwner and disableOwner PChainOwner structs
+        // If pchainRemainingBalanceOwnerAddress or pchainDisableOwnerAddress are empty (not provided), use the client account
+        const remainingBalanceOwnerAddress = options.pchainRemainingBalanceOwnerAddress.length > 0 ? options.pchainRemainingBalanceOwnerAddress : [defaultOwnerAddress];
+        const disableOwnerAddress = options.pchainDisableOwnerAddress.length > 0 ? options.pchainDisableOwnerAddress : [defaultOwnerAddress];
+        const remainingBalanceOwner = [
+            Number(options.pchainRemainingBalanceOwnerThreshold),
+            remainingBalanceOwnerAddress
+        ];
+        const disableOwner = [
+            Number(options.pchainDisableOwnerThreshold),
+            disableOwnerAddress
+        ];
+        const primaryCollateralAddress = await middlewareSvc.read.PRIMARY_ASSET();
+        const primaryCollateral = await config.contracts.DefaultCollateral(primaryCollateralAddress);
+        const initialStakeWei = (0, viem_1.parseUnits)(options.initialStake.toString(), await primaryCollateral.read.decimals());
+        // Call middlewareAddNode
+        await (0, middleware_1.middlewareAddNode)(middlewareSvc, nodeId, blsKey, remainingBalanceOwner, disableOwner, initialStakeWei);
+    });
+    // Complete validator registration
+    middlewareCmd
+        .command("complete-validator-registration")
+        .description("Complete validator registration on the P-Chain and on the middleware after adding a node")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgHex)("addNodeTxHash", "Add node transaction hash"))
+        .addArgument((0, cliParser_1.ArgBLSPOP)())
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--initial-balance <initialBalance>", "Node initial balance to pay for continuous fee").default('0.01')) // In decimals
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .asyncAction(async (_, middlewareAddress, addNodeTxHash, blsProofOfPossession, options) => {
+        const opts = program.opts();
+        // If pchainTxPrivateKey is not provided, use the private key
+        if (!options.pchainTxPrivateKey) {
+            options.pchainTxPrivateKey = opts.privateKey;
+        }
+        const initialBalance = (0, cliParser_1.ParseUnits)(options.initialBalance, 9, 'Invalid initial balance');
+        const client = await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey, opts.safe);
+        const config = (0, config_1.getConfig)(client, opts.wait, opts.skipAbiValidation);
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const balancerSvc = await config.contracts.BalancerValidatorManager(await middlewareSvc.read.balancerValidatorManager());
+        // Check if P-Chain address have 0.1 AVAX for tx fees but some times it can be less than 0.000050000 AVAX (perhaps when the validator was removed recently)
+        // await requirePChainBallance(config.client, BigInt(Math.round((50000 + Number(initialBalance)))), opts.yes);
+        // Call middlewareCompleteValidatorRegistration (no safe for pChain txs)
+        await (0, securityModule_1.completeValidatorRegistration)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : client, middlewareSvc, balancerSvc, config, blsProofOfPossession, addNodeTxHash, initialBalance, !options.skipWaitApi);
+    });
+    // Remove node
+    middlewareCmd
+        .command("remove-node")
+        .description("Remove a node from an L1")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction({ signer: true }, async (config, middlewareAddress, nodeId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareRemoveNode)(middlewareSvc, nodeId);
+    });
+    // Complete validator removal
+    middlewareCmd
+        .command("complete-validator-removal")
+        .description("Complete validator removal on the P-Chain and on the middleware after removing a node")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgHex)("removeNodeTxHash", "Remove node transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .addOption(new extra_typings_1.Option("--add-node-tx <addNodeTx>", "Add node transaction hash").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserHex)))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, removeNodeTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const balancerSvc = await config.contracts.BalancerValidatorManager(await middlewareSvc.read.balancerValidatorManager());
+        // Check if P-Chain address have 0.01 AVAX for tx fees but some times it can be less than 0.000050000 AVAX (perhaps when the validator was added recently)
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        await (0, securityModule_1.completeValidatorRemoval)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, middlewareSvc, balancerSvc, config, removeNodeTxHash, !options.skipWaitApi, options.nodeId.length > 0 ? options.nodeId : undefined, options.addNodeTx.length > 0 ? options.addNodeTx : undefined);
+    });
+    // Init stake update
+    middlewareCmd
+        .command("init-stake-update")
+        .description("Initialize validator stake update and lock")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .argument("newStake", "New stake amount")
+        .asyncAction({ signer: true }, async (config, middlewareAddress, nodeId, newStake) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const primaryCollateral = await middlewareSvc.read.PRIMARY_ASSET();
+        const collateral = await config.contracts.DefaultCollateral(primaryCollateral);
+        const decimals = await collateral.read.decimals();
+        const newStakeWei = (0, viem_1.parseUnits)(newStake, decimals);
+        await (0, middleware_1.middlewareInitStakeUpdate)(middlewareSvc, nodeId, newStakeWei);
+    });
+    // Complete stake update
+    middlewareCmd
+        .command("complete-stake-update")
+        .description("Complete validator stake update of all or specified node IDs")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validatorStakeUpdateTxHash", "Validator stake update transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .asyncAction(async (_, middlewareAddress, validatorStakeUpdateTxHash, options) => {
+        const opts = program.opts();
+        // If pchainTxPrivateKey is not provided, use the private key
+        if (!options.pchainTxPrivateKey) {
+            options.pchainTxPrivateKey = opts.privateKey;
+        }
+        const client = await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey, opts.safe);
+        const config = (0, config_1.getConfig)(client, opts.wait, opts.skipAbiValidation);
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(client, 50000n, opts.yes);
+        await (0, securityModule_1.completeWeightUpdate)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : client, middlewareSvc, config, validatorStakeUpdateTxHash, options.nodeId.length > 0 ? options.nodeId : undefined);
+    });
+    // Operator cache / calcAndCacheStakes
+    middlewareCmd
+        .command("calc-operator-cache")
+        .description("Calculate and cache stakes for operators")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, epoch, collateralClass) => {
+        logger_1.logger.log("Calculating and caching stakes...");
+        if (!config.client.account) {
+            throw new Error('Client account is required');
+        }
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const hash = await middlewareSvc.safeWrite.calcAndCacheStakes([epoch, collateralClass], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log("calcAndCacheStakes done, tx hash:", hash);
+    });
+    // calcAndCacheNodeStakeForAllOperators
+    middlewareCmd
+        .command("calc-node-stakes")
+        .description("Calculate and cache node stakes for all operators")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction({ signer: true }, async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareCalcNodeStakes)(middlewareSvc);
+    });
+    // forceUpdateNodes
+    middlewareCmd
+        .command("force-update-nodes")
+        .description("Force update operator nodes with stake limit")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .addOption(new extra_typings_1.Option("--limit-stake <stake>", "Stake limit").default(0n).argParser(cliParser_1.ParserAVAX))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, operator, options) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareForceUpdateNodes)(middlewareSvc, operator, options.limitStake);
+    });
+    // topUpAllOperatorNodes
+    middlewareCmd
+        .command("top-up-operator-validators")
+        .description("Top up all operator validators to meet a target continuous fee balance")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .argument("targetBalance", "Target continuous fee balance per validator (in AVAX)")
+        .asyncAction({ signer: true }, async (config, middlewareAddress, operator, targetBalance) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const targetBalanceWei = (0, viem_1.parseUnits)(targetBalance, 9); // AVAX has 9 decimals
+        if (targetBalanceWei <= BigInt(1e7)) { // 0.01 AVAX min
+            throw new Error("Target balance must be greater than 0.01 AVAX");
+        }
+        const balancerAddress = await middlewareSvc.read.BALANCER();
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const [nodeCount, subnetID] = await Promise.all([middlewareSvc.read.getOperatorNodesLength([operator]), balancer.read.subnetID()]);
+        const validators = await (0, pChainUtils_1.getCurrentValidators)(config.client, avalanchejs_1.utils.base58check.encode((0, justification_1.hexToUint8Array)(subnetID)));
+        const validatorsToCheck = await Promise.all(ts_belt_1.A.range(0, Number(nodeCount) - 1)
+            .map(async (index) => {
+            const nodeIdHex = await middlewareSvc.read.operatorNodesArray([operator, BigInt(index)]);
+            return validators.find(v => v.nodeID === (0, utils_1.encodeNodeID)(nodeIdHex));
+        }));
+        const validatorsToTopUp = validatorsToCheck.reduce((acc, validator) => {
+            if (validator && validator.balance < targetBalanceWei - BigInt(1e7)) { // 0.01 AVAX min diff
+                acc.push({
+                    validationId: validator.validationID,
+                    topup: targetBalanceWei - BigInt(validator.balance),
+                });
+            }
+            return acc;
+        }, []);
+        const totalTopUp = validatorsToTopUp.reduce((acc, v) => acc + v.topup, 0n);
+        if (validatorsToTopUp.length === 0) {
+            logger_1.logger.log("All operator validators have sufficient balance. No top-up needed.");
+            return;
+        }
+        logger_1.logger.log(`${validatorsToTopUp.length} validators to top-up for a total of ${(0, viem_1.formatUnits)(totalTopUp, 9)} AVAX.`);
+        await (0, transferUtils_1.requirePChainBallance)(config.client, totalTopUp + BigInt(2e4) * nodeCount, program.opts().yes); // extra 20000 for fees
+        if (!program.opts().yes) {
+            const response = await logger_1.logger.prompt(`Proceed with topping up validators? (y/n): `);
+            if (response.toLowerCase() !== 'y') {
+                logger_1.logger.log("Operation cancelled by user.");
+                process.exit(0);
+            }
+        }
+        for (const { validationId, topup } of validatorsToTopUp) {
+            logger_1.logger.log(`\nTopping up validator ${validationId}`);
+            const amount = Number(topup) / 1e9;
+            (0, ts_belt_1.pipe)(await (0, pChainUtils_1.increasePChainValidatorBalance)(config.client, amount, validationId, false), ts_belt_1.R.tapError(err => { logger_1.logger.error(err); process.exit(1); }));
+        }
+        logger_1.logger.log("\nCompleted top-up of operator validators.");
+        logger_1.logger.addData('total_amount', totalTopUp);
+        logger_1.logger.addData('validators', validatorsToTopUp);
+    });
+    // getOperatorStake (read)
+    middlewareCmd
+        .command("get-operator-stake")
+        .description("Get operator stake for a specific epoch and collateral class")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction(async (config, middlewareAddress, operator, epoch, collateralClass) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetOperatorStake)(middlewareSvc, operator, epoch, collateralClass);
+    });
+    middlewareCmd
+        .command("get-operator-nodes")
+        .description("Get operator nodes")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const nodeCount = await middlewareSvc.read.getOperatorNodesLength([operator]);
+        const abi = [(0, viem_1.getAbiItem)({ abi: middlewareSvc.abi, name: 'operatorNodesArray' })];
+        const multicallResult = await config.client.multicall({
+            contracts: ts_belt_1.A.range(0, Number(nodeCount) - 1).map(i => { return { args: [operator, BigInt(i)], abi, address: middlewareAddress, functionName: 'operatorNodesArray' }; })
+        });
+        const nodes = multicallResult.map((node) => node.error ? "error" : (0, utils_1.encodeNodeID)(node.result));
+        logger_1.logger.log(nodes);
+        logger_1.logger.addData('nodes', nodes);
+    });
+    // getCurrentEpoch (read)
+    middlewareCmd
+        .command("get-current-epoch")
+        .description("Get current epoch number")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetCurrentEpoch)(middlewareSvc);
+    });
+    // getEpochStartTs (read)
+    middlewareCmd
+        .command("get-epoch-start-ts")
+        .description("Get epoch start timestamp")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, middlewareAddress, epoch) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetEpochStartTs)(middlewareSvc, epoch);
+    });
+    // getActiveNodesForEpoch (read)
+    middlewareCmd
+        .command("get-active-nodes-for-epoch")
+        .description("Get active nodes for an operator in a specific epoch")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, middlewareAddress, operator, epoch) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetActiveNodesForEpoch)(middlewareSvc, operator, epoch);
+    });
+    // getOperatorNodesLength (read)
+    middlewareCmd
+        .command("get-operator-nodes-length")
+        .description("Get current number of nodes for an operator")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetOperatorNodesLength)(middlewareSvc, operator);
+    });
+    // getNodeStakeCache (read)
+    middlewareCmd
+        .command("get-node-stake-cache")
+        .description("Get node stake cache for a specific epoch and validator")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .addArgument((0, cliParser_1.ArgHex)("validationId", "Validation ID"))
+        .asyncAction(async (config, middlewareAddress, epoch, validationId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetNodeStakeCache)(middlewareSvc, epoch, validationId);
+    });
+    // getOperatorLockedStake (read)
+    middlewareCmd
+        .command("get-operator-locked-stake")
+        .description("Get operator locked stake")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetOperatorLockedStake)(middlewareSvc, operator);
+    });
+    // nodePendingRemoval (read)
+    middlewareCmd
+        .command("node-pending-removal")
+        .description("Check if node is pending removal")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validationId", "Validation ID"))
+        .asyncAction(async (config, middlewareAddress, validationId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareNodePendingRemoval)(middlewareSvc, validationId);
+    });
+    // getOperatorUsedStakeCached (read)
+    middlewareCmd
+        .command("get-operator-used-stake")
+        .description("Get operator used stake from cache")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetOperatorUsedStake)(middlewareSvc, operator);
+    });
+    // getOperatorAvailableStake (read)
+    middlewareCmd
+        .command("get-operator-available-stake")
+        .description("Get operator available stake")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const availableStake = await middlewareSvc.read.getOperatorAvailableStake([operator]);
+        logger_1.logger.log(`Operator ${operator} available stake: ${availableStake}`);
+    });
+    // getAllOperators (read)
+    middlewareCmd
+        .command("get-all-operators")
+        .description("Get all operators registered")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetAllOperators)(middlewareSvc);
+    });
+    // getCollateralClassIds (read)
+    middlewareCmd
+        .command("get-collateral-class-ids")
+        .description("Get all collateral class IDs from the middleware")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.getCollateralClassIds)(middlewareSvc);
+    });
+    // getActiveCollateralClasses (read)
+    middlewareCmd
+        .command("get-active-collateral-classes")
+        .description("Get active collateral classes (primary and secondary)")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.getActiveCollateralClasses)(middlewareSvc);
+    });
+    middlewareCmd
+        .command("node-logs")
+        .description("Get middleware node logs")
+        .addArgument(argMiddlewareAddress)
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID to filter logs").default(undefined).argParser(cliParser_1.ParserNodeID))
+        .addOption(new extra_typings_1.Option('--snowscan-api-key <string>', "Snowscan API key").default(""))
+        .asyncAction(async (config, middlewareAddress, options) => {
+        logger_1.logger.log(`nodeId: ${options.nodeId}`);
+        const middleware = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareGetNodeLogs)(config.client, middleware, config, options.nodeId, options.snowscanApiKey);
+    });
+    middlewareCmd
+        .command("get-last-node-validation-id")
+        .description("Set middleware log level")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction(async (config, middlewareAddress, nodeId) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const balancerAddress = await middlewareSvc.read.balancerValidatorManager();
+        const balancerSvc = await config.contracts.BalancerValidatorManager(balancerAddress);
+        logger_1.logger.log(`Fetching last validation ID`);
+        const validationId = await (0, middleware_1.middlewareLastValidationId)(config.client, middlewareSvc, balancerSvc, nodeId);
+        logger_1.logger.log(`Last validationID: ${validationId}`);
+    });
+    middlewareCmd
+        .command("to-vault-epoch")
+        .description("convert middleware epoch to a vault epoch")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("middlewareEpoch", "Middleware epoch number"))
+        .asyncAction(async (config, middlewareAddress, vaultAddress, middlewareEpoch) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const vaultSvc = await config.contracts.VaultTokenized(vaultAddress);
+        const middlewareEpochTs = await middlewareSvc.read.getEpochStartTs([middlewareEpoch]);
+        const vaultEpoch = await vaultSvc.read.epochAt([middlewareEpochTs]);
+        logger_1.logger.log(`Vault epoch at middleware epoch ${middlewareEpoch} (timestamp: ${middlewareEpochTs}) is ${vaultEpoch}`);
+    });
+    middlewareCmd
+        .command("update-window-ends-ts")
+        .description("Get the end timestamp of the last completed middleware epoch window")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const [currentEpoch, updateWindow] = await middlewareSvc.multicall(['getCurrentEpoch', 'UPDATE_WINDOW']);
+        const lastEpochStartTs = await middlewareSvc.read.getEpochStartTs([currentEpoch]);
+        logger_1.logger.log(`Window ends at: ${lastEpochStartTs + updateWindow}`);
+    });
+    middlewareCmd
+        .command("vault-to-middleware-epoch")
+        .description("convert vault epoch to a middleware epoch")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argVaultAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("vaultEpoch", "Vault epoch number"))
+        .asyncAction(async (config, middlewareAddress, vaultAddress, vaultEpoch) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const vaultSvc = await config.contracts.VaultTokenized(vaultAddress);
+        const vaultEpochStartTs = await vaultSvc.read.epochDuration() * vaultEpoch + await vaultSvc.read.epochDurationInit();
+        const middlewareEpoch = await middlewareSvc.read.getEpochAtTs([vaultEpochStartTs]);
+        logger_1.logger.log(`Middleware epoch at vault epoch ${vaultEpoch} (timestamp: ${vaultEpochStartTs}) is ${middlewareEpoch}`);
+    });
+    middlewareCmd
+        .command("set-vault-manager")
+        .description("Set vault manager")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .asyncAction({ signer: true }, async (config, middlewareAddress, vaultManagerAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await middlewareSvc.safeWrite.setVaultManager([vaultManagerAddress]);
+        logger_1.logger.log(`Set vault manager to ${vaultManagerAddress} on middleware ${middlewareAddress} ok`);
+    });
+    middlewareCmd
+        .command("get-operator-validation-ids")
+        .description("Get operator validation IDs")
+        .addArgument(argMiddlewareAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, middlewareAddress, operator) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const validationIDs = await middlewareSvc.read.getOperatorValidationIDs([operator]);
+        logger_1.logger.log(`Validation IDs for operator ${operator}: ${validationIDs.join(', ')}`);
+    });
+    middlewareCmd
+        .command("account-info")
+        .description("Get account info")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account address"))
+        .asyncAction(async (config, middlewareAddress, account) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        const [owner, operators, epoch, balancerAddress] = await middlewareSvc.multicall(['owner', 'getAllOperators', 'getCurrentEpoch', 'BALANCER']);
+        const roles = (0, accessControl_1.getRoles)(middlewareSvc);
+        const accessControl = await config.contracts.AccessControl(middlewareAddress);
+        const hasRole = await accessControl.multicall(roles.map(role => { return { name: 'hasRole', args: [(0, accessControl_1.ensureRoleHex)(role), account] }; }));
+        logger_1.logger.log(`Account ${account} has the following rights: `);
+        if (account === owner) {
+            logger_1.logger.log(`L1 owner`);
+        }
+        if (hasRole.some(role => role)) {
+            logger_1.logger.log(`Middleware roles: `);
+            logger_1.logger.log("  " + roles.filter((_, index) => hasRole[index]).join('\n  '));
+        }
+        if (operators.includes(account)) {
+            const balancerSvc = await config.contracts.BalancerValidatorManager(balancerAddress);
+            const [stake, validationIDs] = await middlewareSvc.multicall([
+                { name: 'getOperatorStake', args: [account, 1, BigInt(epoch)] },
+                { name: 'getOperatorValidationIDs', args: [account] }
+            ]);
+            const validators = await balancerSvc.multicall(validationIDs.flatMap(id => { return [{ name: 'getValidator', args: [id] }, { name: 'isValidatorPendingWeightUpdate', args: [id] }]; }));
+            logger_1.logger.log(`Operator with stake ${stake} and the following validators: `);
+            const subnetIdHex = await balancerSvc.read.subnetID();
+            const pChainValidators = await (0, pChainUtils_1.getCurrentValidators)(config.client, avalanchejs_1.utils.base58check.encode((0, viem_1.hexToBytes)(subnetIdHex)));
+            const formated = {};
+            for (let i = 0; i < validators.length; i += 2) {
+                const validator = validators[i];
+                const pendingWeightUpdate = validators[i + 1];
+                const status = balancer_1.ValidatorStatusNames[validator.status == balancer_1.ValidatorStatus.Active && pendingWeightUpdate ? balancer_1.ValidatorStatus.PendingStakeUpdated : validator.status];
+                const pChainValidator = pChainValidators.find(v => v.nodeID === validator.nodeID);
+                formated[(0, utils_1.encodeNodeID)(validator.nodeID)] = { NodeID: (0, utils_1.encodeNodeID)(validator.nodeID), status, weight: validator.weight, ValidationId: validationIDs[i / 2], continuousAVAXBalance: (0, viem_1.parseUnits)(pChainValidator?.balance?.toString() ?? '0', 9) };
+            }
+            logger_1.logger.logJsonTree(formated);
+        }
+    });
+    middlewareCmd
+        .command("info")
+        .description("Get general information about the middleware")
+        .addArgument(argMiddlewareAddress)
+        .asyncAction(async (config, middlewareAddress) => {
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, middleware_1.middlewareInfo)(middlewareSvc);
+    });
+    middlewareCmd
+        .command('weight-sync')
+        .description('Watch for operators weight changes')
+        .addArgument(argMiddlewareAddress)
+        .addOption(new extra_typings_1.Option('-e, --epochs <number>', 'Number of epochs to watch').argParser(Number))
+        .addOption(new extra_typings_1.Option('-l, --loop-epochs <number>', 'Number of epochs to loop').argParser(Number))
+        .asyncAction({ signer: true }, async (config, middlewareAddress, options) => {
+        await (0, middleware_1.weightSync)(await config.contracts.L1Middleware(middlewareAddress), config, { epochs: options.epochs, loopEpochs: options.loopEpochs });
+    });
+    /**
+     * --------------------------------------------------
+     * OPERATOR → L1: optIn / optOut / check
+     * --------------------------------------------------
+     */
+    const operatorOptInCmd = program
+        .command("opt-in")
+        .description("Commands for operator opt-in services");
+    operatorOptInCmd
+        .command("l1-in")
+        .description("Operator opts in to a given L1")
+        .addArgument(argValidatorManagerAddress)
+        .asyncAction({ signer: true }, async (config, l1Address) => {
+        const service = await config.contracts.OperatorL1OptInService();
+        await (0, operatorOptIn_1.optInL1)(service, l1Address);
+    });
+    operatorOptInCmd
+        .command("l1-out")
+        .description("Operator opts out from a given L1")
+        .addArgument(argValidatorManagerAddress)
+        .asyncAction({ signer: true }, async (config, l1Address) => {
+        const service = await config.contracts.OperatorL1OptInService();
+        await (0, operatorOptIn_1.optOutL1)(service, l1Address);
+    });
+    operatorOptInCmd
+        .command("check-l1")
+        .description("Check if an operator is opted in to a given L1")
+        .addArgument(argOperatorAddress)
+        .addArgument(argValidatorManagerAddress)
+        .asyncAction(async (config, operator, l1Address) => {
+        const service = await config.contracts.OperatorL1OptInService();
+        await (0, operatorOptIn_1.checkOptInL1)(service, operator, l1Address);
+    });
+    /**
+     * --------------------------------------------------
+     * OPERATOR → Vault: optIn / optOut / check
+     * --------------------------------------------------
+     */
+    operatorOptInCmd
+        .command("vault-in")
+        .description("Operator opts in to a given Vault")
+        .addArgument(argVaultAddress)
+        .asyncAction({ signer: true }, async (config, vaultAddress) => {
+        const service = await config.contracts.OperatorVaultOptInService();
+        await (0, operatorOptIn_1.optInVault)(service, vaultAddress);
+    });
+    operatorOptInCmd
+        .command("vault-out")
+        .description("Operator opts out from a given Vault")
+        .addArgument(argVaultAddress)
+        .asyncAction({ signer: true }, async (config, vaultAddress) => {
+        const service = await config.contracts.OperatorVaultOptInService();
+        await (0, operatorOptIn_1.optOutVault)(service, vaultAddress);
+    });
+    operatorOptInCmd
+        .command("check-vault")
+        .description("Check if an operator is opted in to a given Vault")
+        .addArgument(argOperatorAddress)
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, operator, vaultAddress) => {
+        const service = await config.contracts.OperatorVaultOptInService();
+        await (0, operatorOptIn_1.checkOptInVault)(service, operator, vaultAddress);
+    });
+    /**
+     * --------------------------------------------------
+     * Validator Manager
+     * --------------------------------------------------
+     */
+    const validatorManagerCmd = program
+        .command("vmc")
+        .description("Commands to interact with ValidatorManager contracts");
+    validatorManagerCmd
+        .command("info")
+        .description("Get summary informations of a ValidatorManager contract")
+        .addArgument(argValidatorManagerAddress)
+        .asyncAction(async (config, validatorManagerAddress) => {
+        // instantiate ValidatorManager contract
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        const results = await validatorManager.multicall([
+            'getChurnTracker',
+            'getChurnPeriodSeconds',
+            'l1TotalWeight',
+            'owner',
+            'subnetID'
+        ], { details: true });
+        logger_1.logger.log(results.reduce((acc, r) => ({ ...acc, [r.name]: r.result }), {}));
+    });
+    validatorManagerCmd
+        .command("transfer-ownership")
+        .description("Transfer the ownership of a ValidatorManager contract")
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("owner", "Owner address"))
+        .asyncAction({ signer: true }, async (config, validatorManagerAddress, owner) => {
+        // instantiate ValidatorManager contract
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await validatorManager.safeWrite.transferOwnership([owner]);
+    });
+    validatorManagerCmd
+        .command("complete-validator-removal")
+        .description("Complete the removal of a validator that has been pending removal")
+        .addArgument(argValidatorManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("removalTxId", "Removal transaction ID"))
+        .asyncAction({ signer: true }, async (config, validatorManagerAddress, removalTxId) => {
+        // instantiate ValidatorManager contract
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        logger_1.logger.error("Not implemented yet");
+    });
+    /**
+     * --------------------------------------------------
+     * BALANCER
+     * --------------------------------------------------
+     */
+    const balancerCmd = program
+        .command("balancer")
+        .description("Commands to interact with BalancerValidatorManager contracts");
+    balancerCmd
+        .command("set-up-security-module")
+        .description("Set up a security module")
+        .addArgument(argBalancerAddress)
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("maxWeight", "Maximum weight"))
+        .asyncAction({ signer: true }, async (config, balancerValidatorManagerAddress, middlewareAddress, maxWeight) => {
+        // instantiate BalancerValidatorManager contract
+        const balancer = await config.contracts.BalancerValidatorManager(balancerValidatorManagerAddress);
+        await (0, balancer_1.setUpSecurityModule)(balancer, middlewareAddress, maxWeight);
+    });
+    balancerCmd
+        .command("get-security-modules")
+        .description("Get all security modules")
+        .addArgument(argBalancerAddress)
+        .asyncAction(async (config, balancerValidatorManagerAddress) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerValidatorManagerAddress);
+        await (0, balancer_1.getSecurityModules)(balancer);
+    });
+    balancerCmd
+        .command("get-security-module-weights")
+        .description("Get security module weights")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("securityModule", "Security module address"))
+        .asyncAction(async (config, balancerValidatorManagerAddress, securityModule) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerValidatorManagerAddress);
+        await (0, balancer_1.getSecurityModuleWeights)(balancer, securityModule);
+    });
+    balancerCmd
+        .command("get-validator-status")
+        .description("Get validator status by node ID")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "Node ID"))
+        .asyncAction(async (config, balancerAddress, nodeId) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const validationId = await balancer.read.getNodeValidationID([(0, utils_1.parseNodeID)(nodeId, false)]);
+        if (Number(validationId) === 0) {
+            logger_1.logger.log("Validator status: NotRegistered");
+            return;
+        }
+        const [validator, PendingWeightUpdate] = await Promise.all([balancer.read.getValidator([validationId]), balancer.read.isValidatorPendingWeightUpdate([validationId])]);
+        const status = validator.status == balancer_1.ValidatorStatus.Active && PendingWeightUpdate ? balancer_1.ValidatorStatus.PendingStakeUpdated : validator.status;
+        logger_1.logger.log("Validator status:", balancer_1.ValidatorStatusNames[status]);
+        logger_1.logger.addData("status", balancer_1.ValidatorStatusNames[status]);
+        logger_1.logger.addData("statusId", status);
+        logger_1.logger.addData("validationId", validationId);
+        logger_1.logger.addData("nodeId", nodeId);
+    });
+    balancerCmd
+        .command("resend-validator-registration")
+        .description("Resend validator registration transaction")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "Node ID"))
+        .asyncAction({ signer: true }, async (config, balancerAddress, nodeId) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId, false);
+        const validationId = await balancer.read.getNodeValidationID([nodeIdHex32]);
+        const hash = await balancer.safeWrite.resendRegisterValidatorMessage([validationId]);
+        logger_1.logger.log("resendValidatorRegistration executed successfully, tx hash:", hash);
+    });
+    balancerCmd
+        .command("resend-weight-update")
+        .description("Resend validator weight update transaction")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "Node ID"))
+        .asyncAction({ signer: true }, async (config, balancerAddress, nodeId) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId, false);
+        const validationId = await balancer.read.getNodeValidationID([nodeIdHex32]);
+        const hash = await balancer.safeWrite.resendValidatorWeightUpdate([validationId]);
+        logger_1.logger.log("resendWeightUpdate executed successfully, tx hash:", hash);
+    });
+    balancerCmd
+        .command("resend-validator-removal")
+        .description("Resend validator removal transaction")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "Node ID"))
+        .asyncAction({ signer: true }, async (config, balancerAddress, nodeId) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId, false);
+        const validationId = await balancer.read.getNodeValidationID([nodeIdHex32]);
+        const hash = await balancer.safeWrite.resendValidatorRemovalMessage([validationId]);
+        logger_1.logger.log("resendValidatorRemoval executed successfully, tx hash:", hash);
+    });
+    balancerCmd
+        .command("transfer-l1-ownership")
+        .description("Transfer Validator manager, balancer and its security modules ownership to a new owner")
+        .addArgument(argBalancerAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("newOwner", "New owner address"))
+        .asyncAction({ signer: true }, async (config, balancerAddress, newOwner) => {
+        const balancer = await config.contracts.BalancerValidatorManager(balancerAddress);
+        const VMTx = await balancer.safeWrite.transferValidatorManagerOwnership([newOwner]);
+        logger_1.logger.log("transferValidatorManagerOwnership executed successfully, tx hash:", VMTx);
+        const BTx = await balancer.safeWrite.transferOwnership([newOwner]);
+        logger_1.logger.log("transferOwnership of balancer executed successfully, tx hash:", BTx);
+        const securityModules = await balancer.read.getSecurityModules();
+        for (const smAddress of securityModules) {
+            const smOwnable = await config.contracts.Ownable(smAddress);
+            const SMTx = await smOwnable.safeWrite.transferOwnership([newOwner]);
+            logger_1.logger.log(`transferOwnership of security module ${smAddress} executed successfully, tx hash:`, SMTx);
+            const smAccessControl = await config.contracts.AccessControl(smAddress);
+            const isAccessControl = await smAccessControl.read.supportsInterface(["0x7965db0b"]);
+            if (isAccessControl) {
+                const ROLETX = await smAccessControl.safeWrite.grantRole([await smAccessControl.read.DEFAULT_ADMIN_ROLE(), newOwner]);
+                logger_1.logger.log(`grantRole DEFAULT_ADMIN_ROLE to ${newOwner} on security module ${smAddress} executed successfully, tx hash:`, ROLETX);
+            }
+        }
+    });
+    /**
+     * --------------------------------------------------
+     * POA-Security-Module
+     * --------------------------------------------------
+     * This section is for the POA Security Module commands.
+     * It includes commands to add or remove validators
+     */
+    const poaCmd = program
+        .command("poa")
+        .description("Commands to interact with POA Security Module contracts");
+    poaCmd
+        .command("add-node")
+        .description("Add a new node to an L1")
+        .addArgument(argPoaSecurityModuleAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgHex)("blsKey", "BLS public key"))
+        .addArgument((0, cliParser_1.ArgBigInt)("initialWeight", "Initial weight of the validator"))
+        .addOption(new extra_typings_1.Option("--registration-expiry <expiry>", "Expiry timestamp (default: now + 12 hours)"))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-threshold <threshold>", "P-Chain remaining balance owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-threshold <threshold>", "P-Chain disable owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-address <address>", "P-Chain remaining balance owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-address <address>", "P-Chain disable owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .asyncAction({ signer: true }, async (config, poaSecurityModule, nodeId, blsKey, initialWeight, options) => {
+        const poaSM = await config.contracts.PoASecurityModule(poaSecurityModule);
+        const defaultOwnerAddress = (0, viem_1.fromBytes)(avalanchejs_1.utils.bech32ToBytes(config.client.addresses.P), 'hex');
+        // Default registration expiry to now + 12 hours if not provided
+        // const registrationExpiry = options.registrationExpiry
+        //     ? BigInt(options.registrationExpiry)
+        //     : BigInt(Math.floor(Date.now() / 1000) + 12 * 60 * 60); // current time + 12 hours in seconds
+        // Build remainingBalanceOwner and disableOwner PChainOwner structs
+        // If pchainRemainingBalanceOwnerAddress or pchainDisableOwnerAddress are empty (not provided), use the client account
+        const remainingBalanceOwnerAddress = options.pchainRemainingBalanceOwnerAddress.length > 0 ? options.pchainRemainingBalanceOwnerAddress : [defaultOwnerAddress];
+        const disableOwnerAddress = options.pchainDisableOwnerAddress.length > 0 ? options.pchainDisableOwnerAddress : [defaultOwnerAddress];
+        const remainingBalanceOwner = [
+            Number(options.pchainRemainingBalanceOwnerThreshold),
+            remainingBalanceOwnerAddress
+        ];
+        const disableOwner = [
+            Number(options.pchainDisableOwnerThreshold),
+            disableOwnerAddress
+        ];
+        const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId, false);
+        const hash = await poaSM.safeWrite.initiateValidatorRegistration([nodeIdHex32, blsKey, { threshold: remainingBalanceOwner[0], addresses: remainingBalanceOwner[1] }, { threshold: disableOwner[0], addresses: disableOwner[1] }, initialWeight]);
+        logger_1.logger.log("addNode executed successfully, tx hash:", hash);
+    });
+    poaCmd
+        .command("complete-validator-registration")
+        .description("Complete validator registration on the P-Chain and on the middleware after adding a node")
+        .addArgument(argPoaSecurityModuleAddress)
+        .addArgument((0, cliParser_1.ArgHex)("addNodeTxHash", "Add node transaction hash"))
+        .addArgument((0, cliParser_1.ArgBLSPOP)())
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--initial-balance <initialBalance>", "Node initial balance to pay for continuous fee").default('0.01'))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .asyncAction({ signer: true }, async (config, poaSecurityModuleAddress, addNodeTxHash, blsProofOfPossession, options) => {
+        const opts = program.opts();
+        // If pchainTxPrivateKey is not provided, use the private key
+        if (!options.pchainTxPrivateKey) {
+            options.pchainTxPrivateKey = opts.privateKey;
+        }
+        const poaSecurityModule = await config.contracts.PoASecurityModule(poaSecurityModuleAddress);
+        const balancerSvc = await config.contracts.BalancerValidatorManager(await poaSecurityModule.read.balancerValidatorManager());
+        const initialBalance = (0, cliParser_1.ParseUnits)(options.initialBalance, 9, 'Invalid initial balance');
+        // Check if P-Chain address have 0.1 AVAX for tx fees but some times it can be less than 0.000050000 AVAX (perhaps when the validator was removed recently)
+        await (0, transferUtils_1.requirePChainBallance)(config.client, BigInt(Math.round((50000 + Number(initialBalance)))), opts.yes);
+        // Call middlewareCompleteValidatorRegistration
+        await (0, securityModule_1.completeValidatorRegistration)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, poaSecurityModule, balancerSvc, config, blsProofOfPossession, addNodeTxHash, initialBalance, !options.skipWaitApi);
+    });
+    poaCmd
+        .command("remove-node")
+        .description("Initiate validator removal")
+        .addArgument(argPoaSecurityModuleAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction({ signer: true }, async (config, poaSecurityModuleAddress, nodeID) => {
+        const poaSecurityModule = await config.contracts.PoASecurityModule(poaSecurityModuleAddress);
+        const balancerValidatorManagerAddress = await poaSecurityModule.read.balancerValidatorManager();
+        const balancer = await config.contracts.BalancerValidatorManager(balancerValidatorManagerAddress);
+        // Convert nodeID to Hex if necessary
+        const nodeIdHex = (0, utils_1.parseNodeID)(nodeID, false);
+        logger_1.logger.log(nodeIdHex);
+        const validationId = await balancer.read.getNodeValidationID([nodeIdHex]);
+        const txHash = await poaSecurityModule.safeWrite.initiateValidatorRemoval([validationId], {
+            chain: null,
+            account: config.client.account,
+        });
+        logger_1.logger.log(`End validation initialized for node ${nodeID}. Transaction hash: ${txHash}`);
+    });
+    poaCmd
+        .command("complete-validator-removal")
+        .description("Complete validator removal in the P-Chain and in the POA Security Module")
+        .addArgument(argPoaSecurityModuleAddress)
+        .addArgument((0, cliParser_1.ArgHex)("removeNodeTxHash", "Remove node transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .addOption(new extra_typings_1.Option("--add-node-tx <addNodeTx>", "Add node transaction hash").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserHex)))
+        .asyncAction({ signer: true }, async (config, poaSecurityModuleAddress, removeNodeTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const poaSecurityModule = await config.contracts.PoASecurityModule(poaSecurityModuleAddress);
+        const balancerSvc = await config.contracts.BalancerValidatorManager(await poaSecurityModule.read.balancerValidatorManager());
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        const txHash = await (0, securityModule_1.completeValidatorRemoval)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, poaSecurityModule, balancerSvc, config, removeNodeTxHash, !options.skipWaitApi, options.nodeId.length > 0 ? options.nodeId : undefined, options.addNodeTx.length > 0 ? options.addNodeTx : undefined);
+        logger_1.logger.log(`End validation initialized for node . Transaction hash: ${txHash}`);
+    });
+    poaCmd
+        .command("init-weight-update")
+        .description("Update validator weight")
+        .addArgument(argPoaSecurityModuleAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgBigInt)("newWeight", "New weight"))
+        .asyncAction({ signer: true }, async (config, poaSecurityModuleAddress, nodeId, newWeight) => {
+        const poaSecurityModule = await config.contracts.PoASecurityModule(poaSecurityModuleAddress);
+        logger_1.logger.log("Calling function initializeValidatorStakeUpdate...");
+        // Parse NodeID to bytes32 format
+        const nodeIdHex32 = (0, utils_1.parseNodeID)(nodeId);
+        const hash = await poaSecurityModule.safeWrite.initiateValidatorWeightUpdate([nodeIdHex32, newWeight]);
+        logger_1.logger.log("initiateValidatorWeightUpdate executed successfully, tx hash:", hash);
+    });
+    poaCmd
+        .command("complete-weight-update")
+        .description("Complete validator weight update of all or specified node IDs")
+        .addArgument(argMiddlewareAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validatorStakeUpdateTxHash", "Validator stake update transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .asyncAction({ signer: true }, async (config, poaSecurityModuleAddress, weightUpdateTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const poaSecurityModule = await config.contracts.PoASecurityModule(poaSecurityModuleAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        const txHash = await (0, securityModule_1.completeWeightUpdate)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, poaSecurityModule, config, weightUpdateTxHash, options.nodeId.length > 0 ? options.nodeId : undefined);
+        logger_1.logger.log(`Weight update completed for node . Transaction hash: ${txHash}`);
+    });
+    /**
+     * --------------------------------------------------
+     * KITE STAKING MANAGER
+     * --------------------------------------------------
+     */
+    const kiteStakingManagerCmd = program
+        .command("kite-staking-manager")
+        .alias("ksm")
+        .description("Commands to interact with KiteStakingManager contracts")
+        .hook("preSubcommand", () => {
+        const opts = program.opts();
+        const newNet = opts.network === "custom" ? opts.network : chainList_1.chainList[opts.network].testnet ? "kiteaitestnet" : "kiteai";
+        program.setOptionValue("network", newNet);
+    });
+    kiteStakingManagerCmd
+        .command("info")
+        .description("Get global configuration from KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .asyncAction(async (config, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        const info = await (0, kiteStaking_1.getKiteStakingManagerInfo)(kiteStakingManager);
+        logger_1.logger.logJsonTree(info);
+    });
+    kiteStakingManagerCmd
+        .command("validator-info")
+        .description("Get comprehensive information for a validator on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validationID", "Validation ID of the validator"))
+        .asyncAction(async (config, validationID, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        const info = await (0, kiteStaking_1.getValidatorFullInfo)(kiteStakingManager, validationID);
+        logger_1.logger.logJsonTree(info);
+    });
+    kiteStakingManagerCmd
+        .command("delegator-info")
+        .description("Get comprehensive information for a delegator on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("delegationID", "Delegation ID of the delegator"))
+        .asyncAction(async (config, delegationID, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        const info = await (0, kiteStaking_1.getDelegatorFullInfo)(kiteStakingManager, delegationID);
+        logger_1.logger.logJsonTree(info);
+    });
+    kiteStakingManagerCmd
+        .command("update-staking-config")
+        .description("Update staking configuration")
+        .addOption(optKiteStakingManagerAddress)
+        .argument("minimumStakeAmount", "Minimum stake amount")
+        .argument("maximumStakeAmount", "Maximum stake amount")
+        .argument("minimumStakeDuration", "Minimum stake duration in seconds")
+        .addArgument((0, cliParser_1.ArgNumber)("minimumDelegationFeeBips", "Minimum delegation fee in basis points"))
+        .addArgument((0, cliParser_1.ArgNumber)("maximumStakeMultiplier", "Maximum stake multiplier"))
+        .asyncAction({ signer: true }, async (config, minimumStakeAmount, maximumStakeAmount, minimumStakeDuration, minimumDelegationFeeBips, maximumStakeMultiplier, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        // Get staking config to determine decimals - typically 18 for native tokens
+        // For now, assume 18 decimals (1e18) for stake amounts
+        const minimumStakeAmountWei = (0, viem_1.parseUnits)(minimumStakeAmount, 18);
+        const maximumStakeAmountWei = (0, viem_1.parseUnits)(maximumStakeAmount, 18);
+        const minimumStakeDurationBigInt = BigInt(minimumStakeDuration);
+        await (0, kiteStaking_1.updateStakingConfig)(kiteStakingManager, minimumStakeAmountWei, maximumStakeAmountWei, minimumStakeDurationBigInt, minimumDelegationFeeBips, maximumStakeMultiplier);
+    });
+    kiteStakingManagerCmd
+        .command("initiate-validator-registration")
+        .description("Initiate validator registration on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgHex)("blsKey", "BLS public key"))
+        .addArgument((0, cliParser_1.ArgNumber)("delegationFeeBips", "Delegation fee in basis points"))
+        .argument("minStakeDuration", "Minimum stake duration in seconds")
+        .addArgument((0, cliParser_1.ArgAddress)("rewardRecipient", "Reward recipient address"))
+        .argument("stakeAmount", "Initial stake amount")
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-threshold <threshold>", "P-Chain remaining balance owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-threshold <threshold>", "P-Chain disable owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-address <address>", "P-Chain remaining balance owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-address <address>", "P-Chain disable owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .asyncAction({ signer: true }, async (config, nodeId, blsKey, delegationFeeBips, minStakeDuration, rewardRecipient, stakeAmount, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        const defaultOwnerAddress = (0, viem_1.fromBytes)(avalanchejs_1.utils.bech32ToBytes(config.client.addresses.P), 'hex');
+        // Build remainingBalanceOwner and disableOwner PChainOwner structs
+        const remainingBalanceOwnerAddress = options.pchainRemainingBalanceOwnerAddress.length > 0 ? options.pchainRemainingBalanceOwnerAddress : [defaultOwnerAddress];
+        const disableOwnerAddress = options.pchainDisableOwnerAddress.length > 0 ? options.pchainDisableOwnerAddress : [defaultOwnerAddress];
+        const remainingBalanceOwner = [
+            Number(options.pchainRemainingBalanceOwnerThreshold),
+            remainingBalanceOwnerAddress
+        ];
+        const disableOwner = [
+            Number(options.pchainDisableOwnerThreshold),
+            disableOwnerAddress
+        ];
+        // Get staking config to determine decimals for initial stake
+        // For now, assume 18 decimals (1e18) for stake amounts
+        const stakeAmountWei = (0, viem_1.parseUnits)(stakeAmount, 18);
+        const minStakeDurationBigInt = BigInt(minStakeDuration);
+        await (0, kiteStaking_1.initiateValidatorRegistration)(kiteStakingManager, nodeId, blsKey, remainingBalanceOwner, disableOwner, delegationFeeBips, minStakeDurationBigInt, rewardRecipient, stakeAmountWei);
+    });
+    kiteStakingManagerCmd
+        .command("complete-validator-registration")
+        .description("Complete validator registration on the P-Chain and on the KiteStakingManager after initiating registration")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateTxHash", "Initiate validator registration transaction hash"))
+        .addArgument((0, cliParser_1.ArgBLSPOP)())
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--initial-balance <initialBalance>", "Node initial balance to pay for continuous fee").default('0.01'))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .asyncAction(async (_, initiateTxHash, blsProofOfPossession, options) => {
+        const opts = program.opts();
+        // If pchainTxPrivateKey is not provided, use the private key
+        if (!options.pchainTxPrivateKey) {
+            options.pchainTxPrivateKey = opts.privateKey;
+        }
+        const initialBalance = (0, cliParser_1.ParseUnits)(options.initialBalance, 9, 'Invalid initial balance');
+        const client = await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey, opts.safe);
+        const config = (0, config_1.getConfig)(client, opts.wait, opts.skipAbiValidation);
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        await (0, kiteStaking_1.completeValidatorRegistration)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : client, kiteStakingManager, config, blsProofOfPossession, initiateTxHash, initialBalance, !options.skipWaitApi);
+    });
+    kiteStakingManagerCmd
+        .command("initiate-delegator-registration")
+        .description("Initiate delegator registration on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgAddress)("rewardRecipient", "Reward recipient address"))
+        .argument("stakeAmount", "Initial stake amount")
+        .asyncAction({ signer: true }, async (config, nodeId, rewardRecipient, stakeAmount, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        // Get staking config to determine decimals for stake amount
+        // For now, assume 18 decimals (1e18) for stake amounts
+        const stakeAmountWei = (0, viem_1.parseUnits)(stakeAmount, 18);
+        await (0, kiteStaking_1.initiateDelegatorRegistration)(kiteStakingManager, config, nodeId, rewardRecipient, stakeAmountWei);
+    });
+    kiteStakingManagerCmd
+        .command("complete-delegator-registration")
+        .description("Complete delegator registration on the P-Chain and on the KiteStakingManager after initiating registration")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateTxHash", "Initiate delegator registration transaction hash"))
+        .argument("rpcUrl", "RPC URL for getting validator uptime")
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .asyncAction({ signer: true }, async (config, initiateTxHash, rpcUrl, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        await (0, kiteStaking_1.completeDelegatorRegistration)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, kiteStakingManager, config, initiateTxHash, rpcUrl);
+    });
+    kiteStakingManagerCmd
+        .command("initiate-delegator-removal")
+        .description("Initiate delegator removal on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("delegationID", "Delegation ID"))
+        .addOption(new extra_typings_1.Option("--include-uptime-proof", "Include uptime proof in the removal").default(false))
+        .addOption(new extra_typings_1.Option("--rpc-url <rpcUrl>", "RPC URL for getting validator uptime (required if --include-uptime-proof is true)"))
+        .asyncAction({ signer: true }, async (config, delegationID, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        await (0, kiteStaking_1.initiateDelegatorRemoval)(kiteStakingManager, config, delegationID, options.includeUptimeProof, options.rpcUrl);
+    });
+    kiteStakingManagerCmd
+        .command("complete-delegator-removal")
+        .description("Complete delegator removal on the P-Chain and on the KiteStakingManager after initiating removal")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateRemovalTxHash", "Initiate delegator removal transaction hash"))
+        .argument("rpcUrl", "RPC URL for getting validator uptime")
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--delegation-id <delegationID>", "Delegation ID of the delegator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserHex)))
+        .addOption(new extra_typings_1.Option("--initiate-tx <initiateTx>", "Initiate delegator registration transaction hash"))
+        .asyncAction({ signer: true }, async (config, initiateRemovalTxHash, rpcUrl, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        await (0, kiteStaking_1.completeDelegatorRemoval)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, kiteStakingManager, config, initiateRemovalTxHash, rpcUrl, !options.skipWaitApi, options.delegationId.length > 0 ? options.delegationId : undefined, options.initiateTx ? options.initiateTx : undefined);
+    });
+    kiteStakingManagerCmd
+        .command("initiate-validator-removal")
+        .description("Initiate validator removal on KiteStakingManager")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addOption(new extra_typings_1.Option("--include-uptime-proof", "Include uptime proof in the removal").default(false))
+        .asyncAction({ signer: true }, async (config, nodeId, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        await (0, kiteStaking_1.initiateValidatorRemoval)(kiteStakingManager, config, nodeId, options.includeUptimeProof);
+    });
+    kiteStakingManagerCmd
+        .command("complete-validator-removal")
+        .description("Complete validator removal on the P-Chain and on the KiteStakingManager after initiating removal")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateRemovalTxHash", "Initiate validator removal transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .addOption(new extra_typings_1.Option("--initiate-tx <initiateTx>", "Initiate validator registration transaction hash").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserHex)))
+        .asyncAction({ signer: true }, async (config, initiateRemovalTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        await (0, kiteStaking_1.completeValidatorRemoval)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, kiteStakingManager, config, initiateRemovalTxHash, !options.skipWaitApi, options.nodeId.length > 0 ? options.nodeId : undefined, options.initiateTx.length > 0 ? options.initiateTx : undefined);
+    });
+    kiteStakingManagerCmd
+        .command("submit-uptime-proof")
+        .description("Submit uptime proof for a validator")
+        .addOption(optKiteStakingManagerAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "Node ID of the validator"))
+        .argument("rpcUrl", "RPC URL for getting validator uptime")
+        .asyncAction({ signer: true }, async (config, nodeId, rpcUrl, options) => {
+        const kiteStakingManager = await config.contracts.KiteStakingManager(options.stakingManagerAddress);
+        await (0, kiteStaking_1.submitUptimeProof)(config, kiteStakingManager, rpcUrl, nodeId);
+    });
+    /**
+     * --------------------------------------------------
+     * STAKING VAULT
+     * --------------------------------------------------
+     */
+    const stakingVaultCmd = program
+        .command("staking-vault")
+        .alias("sv")
+        .description("Commands to interact with StakingVault contracts")
+        .hook("preSubcommand", () => {
+        const opts = program.opts();
+        const newNet = opts.network === "custom" ? opts.network : chainList_1.chainList[opts.network].testnet ? "kiteaitestnet" : "kiteai";
+        program.setOptionValue("network", newNet);
+    });
+    stakingVaultCmd
+        .command("deposit")
+        .description("Deposit native tokens (AVAX) into the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .argument("amount", "Amount to deposit in AVAX")
+        .addArgument((0, cliParser_1.ArgBigInt)("minShares", "Minimum shares expected from the deposit (slippage protection)"))
+        .asyncAction({ signer: true }, async (config, amount, minShares, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.depositStakingVault)(config.client, stakingVault, amount, minShares);
+    });
+    stakingVaultCmd
+        .command("request-withdrawal")
+        .description("Request withdrawal from the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .argument("shares", "Amount of shares to withdraw")
+        .asyncAction({ signer: true }, async (config, shares, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.requestWithdrawalStakingVault)(config.client, stakingVault, shares);
+    });
+    stakingVaultCmd
+        .command("claim-withdrawal")
+        .description("Claim a withdrawal from the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("requestId", "Withdrawal request ID to claim"))
+        .asyncAction({ signer: true }, async (config, requestId, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.claimWithdrawalStakingVault)(config.client, stakingVault, requestId);
+    });
+    stakingVaultCmd
+        .command("claim-withdrawal-for")
+        .description("Claim a withdrawal for a request ID (permissionless)")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("requestId", "Withdrawal request ID to claim"))
+        .asyncAction({ signer: true }, async (config, requestId, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.claimWithdrawalFor([requestId]);
+        logger_1.logger.log("claimWithdrawalFor tx hash:", hash);
+        logger_1.logger.log("claimWithdrawalFor executed successfully");
+    });
+    stakingVaultCmd
+        .command("claim-withdrawals-for")
+        .description("Claim multiple withdrawals for request IDs (permissionless)")
+        .addOption(optStakingVaultAddress)
+        .argument("requestIds...", "Withdrawal request IDs to claim")
+        .asyncAction({ signer: true }, async (config, requestIds, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const ids = requestIds.map((id) => BigInt(id));
+        const hash = await stakingVault.safeWrite.claimWithdrawalsFor([ids]);
+        logger_1.logger.log("claimWithdrawalsFor tx hash:", hash);
+        logger_1.logger.log("claimWithdrawalsFor executed successfully");
+    });
+    stakingVaultCmd
+        .command("claim-escrowed-withdrawal")
+        .description("Claim escrowed withdrawal to a recipient")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("recipient", "Recipient address"))
+        .asyncAction({ signer: true }, async (config, recipient, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.claimEscrowedWithdrawal([recipient]);
+        logger_1.logger.log("claimEscrowedWithdrawal tx hash:", hash);
+        logger_1.logger.log("claimEscrowedWithdrawal executed successfully");
+    });
+    stakingVaultCmd
+        .command("process-epoch")
+        .description("Process the current epoch in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.processEpochStakingVault)(config.client, stakingVault);
+    });
+    stakingVaultCmd
+        .command("initiate-validator-registration")
+        .description("Initiate validator registration in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .addArgument((0, cliParser_1.ArgHex)("blsKey", "BLS public key"))
+        .argument("stakeAmount", "Stake amount in AVAX")
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-threshold <threshold>", "P-Chain remaining balance owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-threshold <threshold>", "P-Chain disable owner threshold").default(1).argParser(cliParser_1.ParserNumber))
+        .addOption(new extra_typings_1.Option("--pchain-remaining-balance-owner-address <address>", "P-Chain remaining balance owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .addOption(new extra_typings_1.Option("--pchain-disable-owner-address <address>", "P-Chain disable owner address").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserAddress)))
+        .asyncAction({ signer: true }, async (config, nodeId, blsKey, stakeAmount, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const defaultOwnerAddress = (0, viem_1.fromBytes)(avalanchejs_1.utils.bech32ToBytes(config.client.addresses.P), 'hex');
+        // Build remainingBalanceOwner and disableOwner PChainOwner structs
+        const remainingBalanceOwnerAddress = options.pchainRemainingBalanceOwnerAddress.length > 0 ? options.pchainRemainingBalanceOwnerAddress : [defaultOwnerAddress];
+        const disableOwnerAddress = options.pchainDisableOwnerAddress.length > 0 ? options.pchainDisableOwnerAddress : [defaultOwnerAddress];
+        const remainingBalanceOwner = [
+            Number(options.pchainRemainingBalanceOwnerThreshold),
+            remainingBalanceOwnerAddress
+        ];
+        const disableOwner = [
+            Number(options.pchainDisableOwnerThreshold),
+            disableOwnerAddress
+        ];
+        await (0, stakingVault_1.initiateValidatorRegistrationStakingVault)(config.client, stakingVault, nodeId, blsKey, remainingBalanceOwner, disableOwner, stakeAmount);
+    });
+    stakingVaultCmd
+        .command("add-operator")
+        .description("Add an operator to the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument(argOperatorAddress)
+        .argument("allocationBips", "Allocation in basis points (1 bips = 0.01%)")
+        .addArgument((0, cliParser_1.ArgAddress)("feeRecipient", "Fee recipient address"))
+        .asyncAction({ signer: true }, async (config, operator, allocationBips, feeRecipient, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const allocationBipsBigInt = BigInt(allocationBips);
+        await (0, stakingVault_1.addOperatorStakingVault)(config.client, stakingVault, operator, allocationBipsBigInt, feeRecipient);
+    });
+    stakingVaultCmd
+        .command("remove-operator")
+        .description("Remove an operator from the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction({ signer: true }, async (config, operator, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.removeOperator([operator]);
+        logger_1.logger.log("removeOperator tx hash:", hash);
+        logger_1.logger.log("removeOperator executed successfully");
+    });
+    stakingVaultCmd
+        .command("complete-validator-registration")
+        .description("Complete validator registration on the P-Chain and on the StakingVault after initiating registration")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateTxHash", "Initiate validator registration transaction hash"))
+        .addArgument((0, cliParser_1.ArgBLSPOP)())
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--initial-balance <initialBalance>", "Node initial balance to pay for continuous fee").default('0.01'))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be visible through the P-Chain API"))
+        .asyncAction(async (_, initiateTxHash, blsProofOfPossession, options) => {
+        const opts = program.opts();
+        // If pchainTxPrivateKey is not provided, use the private key
+        if (!options.pchainTxPrivateKey) {
+            options.pchainTxPrivateKey = opts.privateKey;
+        }
+        const initialBalance = (0, cliParser_1.ParseUnits)(options.initialBalance, 9, 'Invalid initial balance');
+        const client = await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey, opts.safe);
+        const config = (0, config_1.getConfig)(client, opts.wait, opts.skipAbiValidation);
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await (0, stakingVault_1.completeValidatorRegistrationStakingVault)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : client, config, stakingVault, validatorManager, blsProofOfPossession, initiateTxHash, initialBalance, !options.skipWaitApi);
+    });
+    stakingVaultCmd
+        .command("initiate-validator-removal")
+        .description("Initiate validator removal in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction({ signer: true }, async (config, nodeId, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await (0, stakingVault_1.initiateValidatorRemovalStakingVault)(config.client, stakingVault, validatorManager, nodeId);
+    });
+    stakingVaultCmd
+        .command("complete-validator-removal")
+        .description("Complete validator removal on the P-Chain and on the StakingVault after initiating removal")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateRemovalTxHash", "Initiate validator removal transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be removed from the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--node-id <nodeId>", "Node ID of the validator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserNodeID)))
+        .addOption(new extra_typings_1.Option("--initiate-tx <initiateTx>", "Initiate validator registration transaction hash").argParser((value) => value))
+        .asyncAction({ signer: true }, async (config, initiateRemovalTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        await (0, stakingVault_1.completeValidatorRemovalStakingVault)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, config, stakingVault, validatorManager, initiateRemovalTxHash, !options.skipWaitApi, options.nodeId.length > 0 ? options.nodeId : undefined, options.initiateTx);
+    });
+    stakingVaultCmd
+        .command("force-remove-validator")
+        .description("Force remove a validator from the StakingVault (admin/emergency operation)")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction({ signer: true }, async (config, nodeId, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await (0, stakingVault_1.forceRemoveValidatorStakingVault)(config.client, stakingVault, validatorManager, nodeId);
+    });
+    stakingVaultCmd
+        .command("initiate-delegator-registration")
+        .description("Initiate delegator registration in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .argument("amount", "Stake amount in AVAX")
+        .asyncAction({ signer: true }, async (config, nodeId, amount, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await (0, stakingVault_1.initiateDelegatorRegistrationStakingVault)(config.client, stakingVault, validatorManager, nodeId, amount);
+    });
+    stakingVaultCmd
+        .command("complete-delegator-registration")
+        .description("Complete delegator registration on the P-Chain and on the StakingVault after initiating registration")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateTxHash", "Initiate delegator registration transaction hash"))
+        .argument("rpcUrl", "RPC URL for getting validator uptime (e.g. http(s)://domainOrIp:portIfNeeded)")
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .asyncAction({ signer: true }, async (config, initiateTxHash, rpcUrl, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress, stakingManager, stakingManagerStorageLocation } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const uptimeBlockchainID = await config.client.getStorageAt({ address: stakingManager.address, slot: `0x${(BigInt(stakingManagerStorageLocation) + 6n).toString(16).padStart(64, '0')}` });
+        if (!uptimeBlockchainID || uptimeBlockchainID === "0x0") {
+            throw new Error("Could not get uptime blockchain ID");
+        }
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        await (0, stakingVault_1.completeDelegatorRegistrationStakingVault)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, config, stakingVault, validatorManager, initiateTxHash, rpcUrl, uptimeBlockchainID);
+    });
+    stakingVaultCmd
+        .command("initiate-delegator-removal")
+        .description("Initiate delegator removal in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("delegationID", "Delegation ID"))
+        .asyncAction({ signer: true }, async (config, delegationID, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.initiateDelegatorRemovalStakingVault)(config.client, stakingVault, delegationID);
+    });
+    stakingVaultCmd
+        .command("force-remove-delegator")
+        .description("Force remove a delegator from the StakingVault (admin/emergency operation)")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("delegationID", "Delegation ID"))
+        .asyncAction({ signer: true }, async (config, delegationID, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.forceRemoveDelegatorStakingVault)(config.client, stakingVault, delegationID);
+    });
+    stakingVaultCmd
+        .command("complete-delegator-removal")
+        .description("Complete delegator removal on the P-Chain and on the StakingVault after initiating removal")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgHex)("initiateRemovalTxHash", "Initiate delegator removal transaction hash"))
+        .addOption(new extra_typings_1.Option("--pchain-tx-private-key <pchainTxPrivateKey>", "P-Chain transaction private key/secret name or 'ledger'. Defaults to the private key.").argParser(cliParser_1.ParserPrivateKey))
+        .addOption(new extra_typings_1.Option("--skip-wait-api", "Don't wait for the validator to be removed from the P-Chain API"))
+        .addOption(new extra_typings_1.Option("--delegation-id <delegationID>", "Delegation ID of the delegator being removed").default([]).argParser((0, cliParser_1.collectMultiple)(cliParser_1.ParserHex)))
+        .addOption(new extra_typings_1.Option("--initiate-tx <initiateTx>", "Initiate delegator registration transaction hash").argParser((value) => value))
+        .asyncAction({ signer: true }, async (config, initiateRemovalTxHash, options) => {
+        const opts = program.opts();
+        if (!options.pchainTxPrivateKey)
+            options.pchainTxPrivateKey = opts.privateKey;
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const { validatorManagerAddress } = await (0, stakingVault_1.getValidatorManagerAddress)(config, stakingVault);
+        const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress);
+        // Check if P-Chain address have 0.000050000 AVAX for tx fees
+        await (0, transferUtils_1.requirePChainBallance)(config.client, 50000n, opts.yes);
+        await (0, stakingVault_1.completeDelegatorRemovalStakingVault)(options.pchainTxPrivateKey ? await (0, client_1.generateClient)(opts.network, options.pchainTxPrivateKey) : config.client, config, stakingVault, validatorManager, initiateRemovalTxHash, options.delegationId.length > 0 ? options.delegationId : undefined, options.initiateTx);
+    });
+    stakingVaultCmd
+        .command("update-operator-allocations")
+        .description("Update operator allocations in the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .addArgument(argOperatorAddress)
+        .argument("allocationBips", "Allocation in basis points (1 bips = 0.01%)")
+        .asyncAction({ signer: true }, async (config, operator, allocationBips, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const allocationBipsBigInt = BigInt(allocationBips);
+        await stakingVault.safeWrite.updateOperatorAllocations([[operator], [allocationBipsBigInt]]);
+    });
+    stakingVaultCmd
+        .command("claim-operator-fees")
+        .description("Claim operator fees for the caller")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.claimOperatorFees([]);
+        logger_1.logger.log("claimOperatorFees executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("force-claim-operator-fees")
+        .description("Force claim operator fees for an operator (admin)")
+        .addOption(optStakingVaultAddress)
+        .addArgument(argOperatorAddress)
+        .asyncAction({ signer: true }, async (config, operator, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.forceClaimOperatorFees([operator]);
+        logger_1.logger.log("forceClaimOperatorFees executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("claim-pending-protocol-fees")
+        .description("Claim pending protocol fees")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.claimPendingProtocolFees([]);
+        logger_1.logger.log("claimPendingProtocolFees executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("harvest")
+        .description("Harvest rewards")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.harvest([]);
+        logger_1.logger.log("harvest executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("harvest-validators")
+        .description("Harvest validator rewards in batches")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("operatorIndex", "Operator index"))
+        .addArgument((0, cliParser_1.ArgBigInt)("start", "Validator list start index"))
+        .addArgument((0, cliParser_1.ArgBigInt)("batchSize", "Validator batch size"))
+        .asyncAction({ signer: true }, async (config, operatorIndex, start, batchSize, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.harvestValidators([operatorIndex, start, batchSize]);
+        logger_1.logger.log("harvestValidators executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("harvest-delegators")
+        .description("Harvest delegator rewards in batches")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("operatorIndex", "Operator index"))
+        .addArgument((0, cliParser_1.ArgBigInt)("start", "Delegator list start index"))
+        .addArgument((0, cliParser_1.ArgBigInt)("batchSize", "Delegator batch size"))
+        .asyncAction({ signer: true }, async (config, operatorIndex, start, batchSize, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.harvestDelegators([operatorIndex, start, batchSize]);
+        logger_1.logger.log("harvestDelegators executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("prepare-withdrawals")
+        .description("Prepare withdrawals by initiating stake removals")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.prepareWithdrawals([]);
+        logger_1.logger.log("prepareWithdrawals executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("pause")
+        .description("Pause the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.pause([]);
+        logger_1.logger.log("pause executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("unpause")
+        .description("Unpause the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.unpause([]);
+        logger_1.logger.log("unpause executed successfully, tx hash:", hash);
+    });
+    /**
+     * Setters
+     */
+    stakingVaultCmd
+        .command("set-liquidity-buffer-bips")
+        .description("Set the liquidity buffer in basis points")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("liquidityBufferBips", "Liquidity buffer in basis points"))
+        .asyncAction({ signer: true }, async (config, liquidityBufferBips, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setLiquidityBufferBips([liquidityBufferBips]);
+        logger_1.logger.log("setLiquidityBufferBips executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-withdrawal-request-fee")
+        .description("Set the withdrawal request fee")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("fee", "Withdrawal request fee"))
+        .asyncAction({ signer: true }, async (config, fee, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setWithdrawalRequestFee([fee]);
+        logger_1.logger.log("setWithdrawalRequestFee executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-max-operators")
+        .description("Set the maximum number of operators")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("maxOperators", "Maximum number of operators"))
+        .asyncAction({ signer: true }, async (config, maxOperators, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setMaxOperators([maxOperators]);
+        logger_1.logger.log("setMaxOperators executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-max-validators-per-operator")
+        .description("Set the maximum number of validators per operator")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("maxValidatorsPerOperator", "Maximum number of validators per operator"))
+        .asyncAction({ signer: true }, async (config, maxValidatorsPerOperator, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setMaxValidatorsPerOperator([maxValidatorsPerOperator]);
+        logger_1.logger.log("setMaxValidatorsPerOperator executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-maximum-delegator-stake")
+        .description("Set the maximum stake amount for a delegator")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("maximumDelegatorStake", "Maximum stake amount for a delegator"))
+        .asyncAction({ signer: true }, async (config, maximumDelegatorStake, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setMaximumDelegatorStake([maximumDelegatorStake]);
+        logger_1.logger.log("setMaximumDelegatorStake executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-maximum-validator-stake")
+        .description("Set the maximum stake amount for a validator")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("maximumValidatorStake", "Maximum stake amount for a validator"))
+        .asyncAction({ signer: true }, async (config, maximumValidatorStake, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setMaximumValidatorStake([maximumValidatorStake]);
+        logger_1.logger.log("setMaximumValidatorStake executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-operations-impl")
+        .description("Set the operations implementation")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("operationsImpl", "Operations implementation"))
+        .asyncAction({ signer: true }, async (config, operationsImpl, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setOperationsImpl([operationsImpl]);
+        logger_1.logger.log("setOperationsImpl executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-operator-fee-bips")
+        .description("Set the operator fee in basis points")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("operatorFeeBips", "Operator fee in basis points"))
+        .asyncAction({ signer: true }, async (config, operatorFeeBips, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setOperatorFeeBips([operatorFeeBips]);
+        logger_1.logger.log("setOperatorFeeBips executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-operator-fee-recipient")
+        .description("Set the operator fee recipient")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("operatorFeeRecipient", "Operator fee recipient"))
+        .asyncAction({ signer: true }, async (config, operatorFeeRecipient, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setOperatorFeeRecipient([operatorFeeRecipient]);
+        logger_1.logger.log("setOperatorFeeRecipient executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-protocol-fee-bips")
+        .description("Set the protocol fee in basis points")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("protocolFeeBips", "Protocol fee in basis points"))
+        .asyncAction({ signer: true }, async (config, protocolFeeBips, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setProtocolFeeBips([protocolFeeBips]);
+        logger_1.logger.log("setProtocolFeeBips executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("set-protocol-fee-recipient")
+        .description("Set the protocol fee recipient")
+        .addOption(optStakingVaultAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("protocolFeeRecipient", "Protocol fee recipient"))
+        .asyncAction({ signer: true }, async (config, protocolFeeRecipient, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const hash = await stakingVault.safeWrite.setProtocolFeeRecipient([protocolFeeRecipient]);
+        logger_1.logger.log("setProtocolFeeRecipient executed successfully, tx hash:", hash);
+    });
+    stakingVaultCmd
+        .command("get-withdrawal-request-fee")
+        .description("Get the withdrawal request fee")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const fee = await stakingVault.read.getWithdrawalRequestFee();
+        logger_1.logger.log("Withdrawal request fee:", fee);
+    });
+    stakingVaultCmd
+        .command("info")
+        .description("Get general overview of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction({ signer: true }, async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getGeneralInfo)(stakingVault, config.client);
+    });
+    stakingVaultCmd
+        .command("fees-info")
+        .description("Get fees configuration of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getFeesInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("operators-info")
+        .description("Get operators details of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getOperatorsInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("validators-info")
+        .description("Get validators details per operator of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getValidatorsInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("delegators-info")
+        .description("Get delegations details per operator of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getDelegatorsInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("withdrawals-info")
+        .description("Get withdrawal queue info of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getWithdrawalsInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("epoch-info")
+        .description("Get epoch info of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getEpochInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("full-info")
+        .description("Get all information about the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        await (0, stakingVault_1.getGeneralInfo)(stakingVault, config.client);
+        await (0, stakingVault_1.getFeesInfo)(stakingVault);
+        await (0, stakingVault_1.getOperatorsInfo)(stakingVault);
+        await (0, stakingVault_1.getValidatorsInfo)(stakingVault);
+        await (0, stakingVault_1.getDelegatorsInfo)(stakingVault);
+        await (0, stakingVault_1.getWithdrawalsInfo)(stakingVault);
+        await (0, stakingVault_1.getEpochInfo)(stakingVault);
+    });
+    stakingVaultCmd
+        .command("get-current-epoch")
+        .description("Get current epoch number of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const currentEpoch = await stakingVault.read.getCurrentEpoch();
+        logger_1.logger.log(`Current epoch: ${currentEpoch}`);
+    });
+    stakingVaultCmd
+        .command("get-epoch-duration")
+        .description("Get epoch duration in seconds of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const epochDuration = await stakingVault.read.getEpochDuration();
+        logger_1.logger.log(`Epoch duration (seconds): ${epochDuration}`);
+    });
+    stakingVaultCmd
+        .command("get-next-epoch-start-time")
+        .description("Get next epoch start time (timestamp) of the StakingVault")
+        .addOption(optStakingVaultAddress)
+        .asyncAction(async (config, options) => {
+        const stakingVault = await config.contracts.StakingVault(options.stakingVaultAddress);
+        const startTime = await stakingVault.read.getStartTime();
+        const [epochDuration, currentEpoch] = await stakingVault.multicall(["getEpochDuration", "getCurrentEpoch"]);
+        const nextEpochStartTime = startTime + (epochDuration * (currentEpoch + 1n));
+        const nextEpochStartDate = new Date(Number(nextEpochStartTime) * 1000);
+        logger_1.logger.log(`Next epoch start time (timestamp): ${nextEpochStartTime} => ${nextEpochStartDate.toLocaleString()}`);
+    });
+    /**
+     * --------------------------------------------------
+     * OP-STAKES: enumerates the vaults and attempts to read stake for <operator>
+     * --------------------------------------------------
+     */
+    vaultManagerCmd
+        .command("opstakes")
+        .description("Show operator stakes across L1s, enumerating each L1 the operator is opted into.")
+        .addArgument(argMiddlewareVaultManagerAddress)
+        .addArgument(argOperatorAddress)
+        .description("Show operator stakes across L1s, enumerating each L1 the operator is opted into.")
+        .asyncAction(async (config, middlewareVaultManager, operatorAddress) => {
+        const operator = operatorAddress;
+        logger_1.logger.log(`Operator: ${operator}`);
+        // 1) Read total vaults from VaultManager
+        const vaultManager = await config.contracts.VaultManager(middlewareVaultManager);
+        const vaultCount = await vaultManager.read.getVaultCount();
+        logger_1.logger.log(`Found ${vaultCount} vault(s).`);
+        // This map accumulates the total stake for each collateral
+        const totalStakesByCollateral = {};
+        // 2) Let's get all L1 addresses from the L1Registry (similar to your Python code)
+        const l1Registry = await config.contracts.L1Registry();
+        const totalL1s = await l1Registry.read.totalL1s();
+        // We'll store them in an array
+        const l1Array = [];
+        for (let i = 0n; i < totalL1s; i++) {
+            // e.g. getL1At(i) might return [address, metadataUrl], adjust as needed
+            const [l1Address, _] = await l1Registry.read.getL1At([i]);
+            l1Array.push(l1Address);
+        }
+        // 3) For each vault in [0..vaultCount-1], read collateralClass, delegator, collateral
+        for (let i = 0n; i < vaultCount; i++) {
+            const [vaultAddress] = await vaultManager.read.getVaultAtWithTimes([i]);
+            logger_1.logger.log(`\nVault #${i}: ${vaultAddress}`);
+            // read the collateralClass
+            const collateralClass = await vaultManager.read.getVaultCollateralClass([vaultAddress]);
+            // read delegator
+            const vaultTokenized = await config.contracts.VaultTokenized(vaultAddress);
+            const delegator = await vaultTokenized.read.delegator();
+            if (delegator === '0x0000000000000000000000000000000000000000') {
+                logger_1.logger.log("    (No delegator set, skipping)");
+                continue;
+            }
+            const l1RestakeDelegator = await config.contracts.L1RestakeDelegator(delegator);
+            // read collateral
+            const collateral = await vaultTokenized.read.collateral();
+            // 4) For each L1 in l1Array, check if operator is opted in
+            for (const l1Address of l1Array) {
+                const operatorL1OptInService = await config.contracts.OperatorL1OptInService();
+                const isOptedIn = await operatorL1OptInService.read.isOptedIn([operator, l1Address]);
+                if (isOptedIn) {
+                    // read stake
+                    const stakeValue = await l1RestakeDelegator.read.stake([l1Address, collateralClass, operator]);
+                    if (stakeValue > 0n) {
+                        logger_1.logger.log(`    L1: ${l1Address} => stake = ${stakeValue.toString()} (vault=${vaultAddress})`);
+                        // sum into totalStakesByCollateral
+                        const oldVal = totalStakesByCollateral[collateral] || 0n;
+                        totalStakesByCollateral[collateral] = oldVal + stakeValue;
+                    }
+                }
+            }
+        }
+        // 5) Finally, print aggregated totals
+        logger_1.logger.log("\nAggregated stakes by collateral:");
+        if (Object.keys(totalStakesByCollateral).length === 0) {
+            logger_1.logger.log("   No stakes found or operator not opted into any L1s this way.");
+        }
+        else {
+            for (const [collateralAddr, totalWei] of Object.entries(totalStakesByCollateral)) {
+                // optional: look up decimals for that collateral if you want a float
+                const decimals = 18; // or read from chain
+                const floatAmount = Number(totalWei) / 10 ** decimals;
+                logger_1.logger.log(`   Collateral=${collateralAddr} totalStakeWei=${totalWei} => ${floatAmount}`);
+            }
+        }
+    });
+    vaultManagerCmd
+        .command("l1stakes")
+        .description("Show L1 stakes for a given validator manager")
+        .addArgument(argValidatorManagerAddress)
+        .description("Show L1 stakes for a given validator manager")
+        .asyncAction(async (config) => {
+        // TODO: Implement
+    });
+    // --------------------------------------------------
+    // "UpTime" Commands
+    // These commands help with reporting validator uptime to the UptimeTracker contract
+    // They include fetching the signed uptime message from a validator and submitting it to the contract
+    // --------------------------------------------------
+    const uptimeCmd = program
+        .command("uptime")
+        .description("Commands related to validator uptime reporting");
+    uptimeCmd
+        .command("get-validation-uptime-message")
+        .description("Get the validation uptime message for a given validator in the given L1 RPC")
+        .addArgument((0, cliParser_1.ArgURI)("rpcUrl", "RPC URL like 'http(s)://<domain or ip and port>'"))
+        .addArgument((0, cliParser_1.ArgCB58)("blockchainId", "Blockchain ID"))
+        .addArgument((0, cliParser_1.ArgNodeID)())
+        .asyncAction(async (config, rpcUrl, blockchainId, nodeId) => {
+        rpcUrl = rpcUrl + "/ext/bc/" + blockchainId;
+        const opts = program.opts();
+        const client = await (0, client_1.generateClient)(opts.network);
+        await (0, uptime_1.getValidationUptimeMessage)(config.client, rpcUrl, nodeId, config.client.network === "fuji" ? 5 : 1, blockchainId);
+    });
+    uptimeCmd
+        .command('compute-validator-uptime')
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("signedUptimeHex", "Signed uptime hex"))
+        .asyncAction({ signer: true }, async (config, uptimeTrackerAddress, signedUptimeHex) => {
+        await (0, uptime_1.computeValidatorUptime)(await config.contracts.UptimeTracker(uptimeTrackerAddress), signedUptimeHex);
+    });
+    // ---- Combined Uptime Reporting Command ----
+    uptimeCmd
+        .command("report-uptime-validator")
+        .description("Gets a validator's signed uptime message and submits it to the UptimeTracker contract.")
+        .addArgument((0, cliParser_1.ArgURI)("rpcUrl", "RPC URL like 'http(s)://<domain or ip and port>'"))
+        .addArgument((0, cliParser_1.ArgCB58)("blockchainId", "The Blockchain ID for which the uptime is being reported"))
+        .addArgument((0, cliParser_1.ArgNodeID)("nodeId", "The NodeID of the validator"))
+        .addArgument(argUptimeTrackerAddress)
+        .asyncAction({ signer: true }, async (config, rpcUrl, blockchainId, nodeId, uptimeTrackerAddress) => {
+        const opts = program.opts();
+        if (!opts.privateKey) {
+            logger_1.logger.error("Error: Private key is required. Use -k or set PK environment variable.");
+            process.exit(1);
+        }
+        rpcUrl = rpcUrl + "/ext/bc/" + blockchainId;
+        await (0, uptime_1.reportAndSubmitValidatorUptime)(config.client, rpcUrl, nodeId, blockchainId, await config.contracts.UptimeTracker(uptimeTrackerAddress));
+    });
+    // ---- Adding new commands for operator uptime ----
+    uptimeCmd
+        .command("compute-operator-uptime")
+        .description("Compute uptime for an operator at a specific epoch")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction({ signer: true }, async (config, uptimeTrackerAddress, operator, epoch) => {
+        const opts = program.opts();
+        if (!opts.privateKey) {
+            logger_1.logger.error("Error: Private key is required. Use -k or set PK environment variable.");
+            process.exit(1);
+        }
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        await (0, uptime_1.computeOperatorUptimeAtEpoch)(uptimeTracker, operator, epoch);
+    });
+    uptimeCmd
+        .command("compute-operator-uptime-range")
+        .description("Compute uptime for an operator over a range of epochs (client-side looping)")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("startEpoch", "Starting epoch number"))
+        .addArgument((0, cliParser_1.ArgNumber)("endEpoch", "Ending epoch number"))
+        .asyncAction({ signer: true }, async (config, uptimeTrackerAddress, operator, startEpoch, endEpoch) => {
+        const opts = program.opts();
+        if (!opts.privateKey) {
+            logger_1.logger.error("Error: Private key is required. Use -k or set PK environment variable.");
+            process.exit(1);
+        }
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        await (0, uptime_1.computeOperatorUptimeForEpochs)(uptimeTracker, operator, startEpoch, endEpoch);
+    });
+    // ---- Read-only commands for uptime data ----
+    uptimeCmd
+        .command("get-validator-uptime")
+        .description("Get the recorded uptime for a validator at a specific epoch")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validationID", "Validation ID of the validator"))
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, uptimeTrackerAddress, validationID, epoch) => {
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        const uptime = await (0, uptime_1.getValidatorUptimeForEpoch)(uptimeTracker, validationID, epoch);
+        logger_1.logger.log(`Validator uptime for epoch ${epoch}: ${uptime.toString()} seconds`);
+    });
+    uptimeCmd
+        .command("check-validator-uptime-set")
+        .description("Check if uptime data is set for a validator at a specific epoch")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument((0, cliParser_1.ArgHex)("validationID", "Validation ID of the validator"))
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, uptimeTrackerAddress, validationID, epoch) => {
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        const isSet = await (0, uptime_1.isValidatorUptimeSetForEpoch)(uptimeTracker, validationID, epoch);
+        logger_1.logger.log(`Validator uptime is ${isSet ? 'set' : 'not set'} for epoch ${epoch}`);
+    });
+    uptimeCmd
+        .command("get-operator-uptime")
+        .description("Get the recorded uptime for an operator at a specific epoch")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, uptimeTrackerAddress, operator, epoch) => {
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        const uptime = await (0, uptime_1.getOperatorUptimeForEpoch)(uptimeTracker, operator, epoch);
+        logger_1.logger.log(`Operator uptime for epoch ${epoch}: ${uptime.toString()} seconds`);
+    });
+    uptimeCmd
+        .command("check-operator-uptime-set")
+        .description("Check if uptime data is set for an operator at a specific epoch")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch number"))
+        .asyncAction(async (config, uptimeTrackerAddress, operator, epoch) => {
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        const isSet = await (0, uptime_1.isOperatorUptimeSetForEpoch)(uptimeTracker, operator, epoch);
+        logger_1.logger.log(`Operator uptime is ${isSet ? 'set' : 'not set'} for epoch ${epoch}`);
+    });
+    uptimeCmd
+        .command("uptime-sync")
+        .description("Report uptime for all validators")
+        .addArgument(argUptimeTrackerAddress)
+        .addArgument(argMiddlewareAddress)
+        .argument("rpcUrl", "RPC URL of the network")
+        .addArgument((0, cliParser_1.ArgCB58)("blockchainId", "The Blockchain ID for which the uptime is being reported"))
+        .addOption(new extra_typings_1.Option("--epoch <epoch>", "Epoch number to check (defaults to current epoch)").argParser(cliParser_1.ParserNumber))
+        .asyncAction({ signer: true }, async (config, uptimeTrackerAddress, middlewareAddress, rpcUrl, blockchainId, options) => {
+        const uptimeTracker = await config.contracts.UptimeTracker(uptimeTrackerAddress);
+        const middlewareSvc = await config.contracts.L1Middleware(middlewareAddress);
+        await (0, uptime_1.uptimeSync)(config.client, uptimeTracker, middlewareSvc, rpcUrl, blockchainId);
+    });
+    /* --------------------------------------------------
+    * REWARDS COMMANDS
+    * -------------------------------------------------- */
+    const rewardsCmd = program
+        .command("rewards")
+        .description("Commands for managing rewards");
+    rewardsCmd
+        .command("distribute")
+        .description("Distribute rewards for a specific epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to distribute rewards for"))
+        .addArgument((0, cliParser_1.ArgNumber)("batchSize", "Number of operators to process in this batch"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, epoch, batchSize) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const txHash = await (0, rewards_1.distributeRewards)(rewardsContract, epoch, batchSize);
+        logger_1.logger.log(`Rewards distributed for epoch ${epoch}. tx hash: ${txHash}`);
+    });
+    rewardsCmd
+        .command("claim")
+        .description("Claim rewards for a staker in batch of 64 epochs")
+        .addArgument(argRewardsAddress)
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, options) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const recipient = options.recipient ?? config.client.account.address;
+        let hashs = [];
+        for (const _ of Array.from({ length: await (0, rewards_1.getRewardsClaimsCount)(rewardsContract, config, 'Staker', config.client.account) })) {
+            hashs.push(await (0, rewards_1.claimRewards)(rewardsContract, recipient));
+        }
+        if (hashs.length === 0) {
+            logger_1.logger.log("No rewards to claim");
+            return;
+        }
+        const logs = await Promise.all(hashs.map(hash => (0, transferUtils_1.getERC20Events)(hash, config)));
+        logs.flat().forEach((log) => {
+            if (log.eventName === "Transfer") {
+                const { from, to, value } = log.args;
+                logger_1.logger.log(`Rewards claimed: ${value.toString()} tokens transferred from ${from} to ${to}`);
+            }
+        });
+    });
+    rewardsCmd
+        .command("claim-operator-fee")
+        .description("Claim operator fees in batch of 64 epochs")
+        .addArgument(argRewardsAddress)
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, options) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const recipient = options.recipient ?? config.client.account.address;
+        let hashs = [];
+        for (const _ of Array.from({ length: await (0, rewards_1.getRewardsClaimsCount)(rewardsContract, config, 'Operator', config.client.account) })) {
+            hashs.push(await (0, rewards_1.claimOperatorFee)(rewardsContract, recipient));
+        }
+        if (hashs.length === 0) {
+            logger_1.logger.log("No operator fees to claim");
+            return;
+        }
+        const logs = await Promise.all(hashs.map(hash => (0, transferUtils_1.getERC20Events)(hash, config)));
+        logs.flat().forEach((log) => {
+            if (log.eventName === "Transfer") {
+                const { from, to, value } = log.args;
+                logger_1.logger.log(`Rewards claimed: ${value.toString()} tokens transferred from ${from} to ${to}`);
+            }
+        });
+    });
+    rewardsCmd
+        .command("claim-curator-fee")
+        .description("Claim all curator fees in batch of 64 epochs")
+        .addArgument(argRewardsAddress)
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, options) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const recipient = options.recipient ?? config.client.account.address;
+        let hashs = [];
+        for (const _ of Array.from({ length: await (0, rewards_1.getRewardsClaimsCount)(rewardsContract, config, 'Curator', config.client.account) })) {
+            hashs.push(await (0, rewards_1.claimCuratorFee)(rewardsContract, recipient));
+        }
+        if (hashs.length === 0) {
+            logger_1.logger.log("No curator fees to claim");
+            return;
+        }
+        const logs = await Promise.all(hashs.map(hash => (0, transferUtils_1.getERC20Events)(hash, config)));
+        logs.flat().forEach((log) => {
+            if (log.eventName === "Transfer") {
+                const { from, to, value } = log.args;
+                logger_1.logger.log(`Rewards claimed: ${value.toString()} tokens transferred from ${from} to ${to}`);
+            }
+        });
+    });
+    rewardsCmd
+        .command("claim-protocol-fee")
+        .description("Claim protocol fees (only for protocol owner)")
+        .addArgument(argRewardsAddress)
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, options) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const recipient = options.recipient ?? config.client.account.address;
+        const hash = await (0, rewards_1.claimProtocolFee)(rewardsContract, recipient);
+        if (!hash) {
+            logger_1.logger.log("No protocol fees to claim");
+            return;
+        }
+        const logs = await (0, transferUtils_1.getERC20Events)(hash, config);
+        logs.forEach((log) => {
+            if (log.eventName === "Transfer") {
+                const { from, to, value } = log.args;
+                logger_1.logger.log(`Rewards claimed: ${value.toString()} tokens transferred from ${from} to ${to}`);
+            }
+        });
+    });
+    rewardsCmd
+        .command("claim-undistributed")
+        .description("Claim undistributed rewards (admin only)")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to claim undistributed rewards for"))
+        .addOption(new extra_typings_1.Option("--recipient <recipient>", "Optional recipient address").argParser(cliParser_1.ParserAddress))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, epoch, options) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const recipient = options.recipient ?? config.client.account.address;
+        const hash = await (0, rewards_1.claimUndistributedRewards)(rewardsContract, epoch, recipient);
+        if (!hash) {
+            logger_1.logger.log("No undistributed rewards to claim");
+            return;
+        }
+        const logs = await (0, transferUtils_1.getERC20Events)(hash, config);
+        logs.forEach((log) => {
+            if (log.eventName === "Transfer") {
+                const { from, to, value } = log.args;
+                logger_1.logger.log(`Rewards claimed: ${value.toString()} tokens transferred from ${from} to ${to}`);
+            }
+        });
+    });
+    rewardsCmd
+        .command("set-amount")
+        .description("Set rewards amount for epochs")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("startEpoch", "Starting epoch"))
+        .addArgument((0, cliParser_1.ArgNumber)("numberOfEpochs", "Number of epochs"))
+        .argument("rewardsAmount", "Amount of rewards in decimal format")
+        .asyncAction({ signer: true }, async (config, rewardsAddress, startEpoch, numberOfEpochs, rewardsAmount) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        if (rewardsContract.name !== 'RewardsNativeToken') {
+            throw new Error('Rewards contract is not a RewardsNativeToken');
+        }
+        const tokenAddress = await rewardsContract.read.rewardsToken();
+        const token = await config.contracts.ERC20(tokenAddress);
+        const decimals = await token.read.decimals();
+        const rewardsAmountWei = (0, viem_1.parseUnits)(rewardsAmount, decimals);
+        const amountToApprove = rewardsAmountWei * BigInt(numberOfEpochs);
+        await token.safeWrite.approve([rewardsAddress, amountToApprove], {
+            chain: null,
+            account: config.client.account,
+        });
+        const txHash = await (0, rewards_1.setRewardsAmountForEpochs)(rewardsContract, startEpoch, numberOfEpochs, rewardsAmountWei);
+        logger_1.logger.log(`setRewardsAmountForEpochs tx hash: ${txHash}`);
+    });
+    rewardsCmd
+        .command("set-bips-collateral-class")
+        .description("Set rewards bips for collateral class")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .addArgument((0, cliParser_1.ArgNumber)("bips", "Bips in basis points (100 = 1%)"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, collateralClass, bips) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.setRewardsBipsForCollateralClass)(rewardsContract, collateralClass, bips);
+        logger_1.logger.log(`setRewardsBipsForCollateralClass tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("set-min-uptime")
+        .description("Set minimum required uptime for rewards eligibility")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("minUptime", "Minimum uptime in seconds"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, minUptime) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.setMinRequiredUptime)(rewardsContract, minUptime);
+        logger_1.logger.log(`setMinRequiredUptime tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("set-protocol-owner")
+        .description("Set protocol owner (DEFAULT_ADMIN_ROLE only)")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("newOwner", "New protocol owner address"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, newOwner) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.setProtocolOwner)(rewardsContract, newOwner);
+        logger_1.logger.log(`setProtocolOwner tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("update-protocol-fee")
+        .description("Update protocol fee")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("newFee", "New fee in basis points (100 = 1%)"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, newFee) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.updateProtocolFee)(rewardsContract, newFee);
+        logger_1.logger.log(`updateProtocolFee tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("update-operator-fee")
+        .description("Update operator fee")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("newFee", "New fee in basis points (100 = 1%)"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, newFee) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.updateOperatorFee)(rewardsContract, newFee);
+        logger_1.logger.log(`updateOperatorFee tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("update-curator-fee")
+        .description("Update curator fee")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("newFee", "New fee in basis points (100 = 1%)"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, newFee) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.updateCuratorFee)(rewardsContract, newFee);
+        logger_1.logger.log(`updateCuratorFee tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("update-all-fees")
+        .description("Update all fees at once (protocol, operator, curator)")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("protocolFee", "New protocol fee in basis points (100 = 1%)"))
+        .addArgument((0, cliParser_1.ArgNumber)("operatorFee", "New operator fee in basis points (100 = 1%)"))
+        .addArgument((0, cliParser_1.ArgNumber)("curatorFee", "New curator fee in basis points (100 = 1%)"))
+        .asyncAction({ signer: true }, async (config, rewardsAddress, protocolFee, operatorFee, curatorFee) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        const hash = await (0, rewards_1.updateAllFees)(rewardsContract, protocolFee, operatorFee, curatorFee);
+        logger_1.logger.log(`updateAllFees tx hash: ${hash}`);
+    });
+    rewardsCmd
+        .command("get-epoch-rewards")
+        .description("Get rewards amount for a specific epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to query"))
+        .asyncAction(async (config, rewardsAddress, epoch) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getEpochRewards)(rewardsContract, epoch);
+    });
+    rewardsCmd
+        .command("get-operator-shares")
+        .description("Get operator shares for a specific epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to query"))
+        .addArgument(argOperatorAddress)
+        .asyncAction(async (config, rewardsAddress, epoch, operator) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getOperatorShares)(rewardsContract, epoch, operator);
+    });
+    rewardsCmd
+        .command("get-vault-shares")
+        .description("Get vault shares for a specific epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to query"))
+        .addArgument(argVaultAddress)
+        .asyncAction(async (config, rewardsAddress, epoch, vault) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getVaultShares)(rewardsContract, epoch, vault);
+    });
+    rewardsCmd
+        .command("get-curator-shares")
+        .description("Get curator shares for a specific epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to query"))
+        .addArgument((0, cliParser_1.ArgAddress)("curator", "Curator address"))
+        .asyncAction(async (config, rewardsAddress, epoch, curator) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getCuratorShares)(rewardsContract, epoch, curator);
+    });
+    rewardsCmd
+        .command("get-protocol-rewards")
+        .description("Get protocol rewards for a token")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("token", "Token address"))
+        .asyncAction(async (config, rewardsAddress, token) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getProtocolRewards)(rewardsContract);
+    });
+    rewardsCmd
+        .command("get-distribution-batch")
+        .description("Get distribution batch status for an epoch")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgNumber)("epoch", "Epoch to query"))
+        .asyncAction(async (config, rewardsAddress, epoch) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getDistributionBatch)(rewardsContract, epoch);
+    });
+    rewardsCmd
+        .command("get-fees-config")
+        .description("Get current fees configuration")
+        .addArgument(argRewardsAddress)
+        .asyncAction(async (config, rewardsAddress) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getFeesConfiguration)(rewardsContract);
+    });
+    rewardsCmd
+        .command("get-bips-collateral-class")
+        .description("Get rewards bips for collateral class")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgBigInt)("collateralClass", "Collateral class ID"))
+        .asyncAction(async (config, rewardsAddress, collateralClass) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getRewardsBipsForCollateralClass)(rewardsContract, collateralClass);
+    });
+    rewardsCmd
+        .command("get-min-uptime")
+        .description("Get minimum required uptime for rewards eligibility")
+        .addArgument(argRewardsAddress)
+        .asyncAction(async (config, rewardsAddress) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getMinRequiredUptime)(rewardsContract);
+    });
+    rewardsCmd
+        .command("get-last-claimed-staker")
+        .description("Get last claimed epoch for a staker")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("staker", "Staker address"))
+        .addArgument(argRewardTokenAddress)
+        .asyncAction(async (config, rewardsAddress, staker, rewardToken) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getLastEpochClaimedStaker)(rewardsContract, staker);
+    });
+    rewardsCmd
+        .command("get-last-claimed-operator")
+        .description("Get last claimed epoch for an operator")
+        .addArgument(argRewardsAddress)
+        .addArgument(argOperatorAddress)
+        .addArgument(argRewardTokenAddress)
+        .asyncAction(async (config, rewardsAddress, operator, rewardToken) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getLastEpochClaimedOperator)(rewardsContract, operator);
+    });
+    rewardsCmd
+        .command("get-last-claimed-curator")
+        .description("Get last claimed epoch for a curator")
+        .addArgument(argRewardsAddress)
+        .addArgument((0, cliParser_1.ArgAddress)("curator", "Curator address"))
+        .addArgument(argRewardTokenAddress)
+        .asyncAction(async (config, rewardsAddress, curator, rewardToken) => {
+        const rewardsContract = await config.contracts.RewardsNativeToken(rewardsAddress);
+        await (0, rewards_1.getLastEpochClaimedCurator)(rewardsContract, curator);
+    });
+    (0, keyStore_1.buildCommands)(program
+        .command("key")
+        .description("Manage the cli keystore (advanced users can use pass directly)"));
+    function printIndentedHelp(cmd, indent = 0) {
+        const pad = " ".repeat(indent);
+        let newLineToLog = false;
+        let hasSubCmds = false;
+        cmd.commands.forEach((sub) => {
+            const args = sub.args?.map(a => `<${a}>`).join(" ");
+            const desc = sub.description() ? sub.description() : "";
+            console.log(`${newLineToLog ? "\n" : ""}${pad}${sub.name()} ${args.padEnd(31 - sub.name().length)} ${desc}`);
+            if (sub.commands.length > 0) {
+                newLineToLog = printIndentedHelp(sub, indent + 2);
+                hasSubCmds = true;
+            }
+        });
+        if (!hasSubCmds || hasSubCmds && !newLineToLog)
+            newLineToLog = true;
+        return newLineToLog;
+    }
+    const accessControlCmd = program
+        .command("access-control")
+        .description("Commands for managing access control");
+    accessControlCmd
+        .command("grant-role")
+        .description("Grant a role to an account")
+        .addArgument(argAccessControlAddress)
+        .argument("role", "Role hash or name case unsensitive without '()'")
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account address to grant the role to"))
+        .asyncAction({ signer: true }, async (config, contractAddress, role, account) => {
+        const accessControl = await config.contracts.AccessControl(contractAddress);
+        if (!await (0, accessControl_1.isAccessControl)(accessControl)) {
+            throw new Error("Contract does not implement AccessControl interface");
+        }
+        const txHash = await (0, accessControl_1.grantRole)(accessControl, role, account);
+        logger_1.logger.log(`Role granted. tx hash: ${txHash}`);
+    });
+    accessControlCmd
+        .command("revoke-role")
+        .description("Revoke a role from an account")
+        .addArgument(argAccessControlAddress)
+        .argument("role", "Role hash or name case unsensitive")
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account address to revoke the role from"))
+        .asyncAction({ signer: true }, async (config, contractAddress, role, account) => {
+        const accessControl = await config.contracts.AccessControl(contractAddress);
+        if (!await (0, accessControl_1.isAccessControl)(accessControl)) {
+            throw new Error("Contract does not implement AccessControl interface");
+        }
+        const txHash = await (0, accessControl_1.revokeRole)(accessControl, role, account);
+        logger_1.logger.log(`Role revoked. tx hash: ${txHash}`);
+    });
+    accessControlCmd
+        .command("has-role")
+        .description("Check if an account has a specific role")
+        .addArgument(argAccessControlAddress)
+        .argument("role", "Role hash or name case unsensitive")
+        .addArgument((0, cliParser_1.ArgAddress)("account", "Account address to check"))
+        .asyncAction(async (config, contractAddress, role, account) => {
+        const accessControl = await config.contracts.AccessControl(contractAddress);
+        if (!await (0, accessControl_1.isAccessControl)(accessControl)) {
+            throw new Error("Contract does not implement AccessControl interface");
+        }
+        const hasRoleResult = await (0, accessControl_1.hasRole)(accessControl, role, account);
+        logger_1.logger.log(`Account ${account} has role ${role}: ${hasRoleResult}`);
+    });
+    accessControlCmd
+        .command("get-role-admin")
+        .description("Get the admin role that controls a specific role")
+        .addArgument(argAccessControlAddress)
+        .argument("role", "Role hash or name case unsensitive")
+        .asyncAction(async (config, contractAddress, role) => {
+        const accessControl = await config.contracts.AccessControl(contractAddress);
+        if (!await (0, accessControl_1.isAccessControl)(accessControl)) {
+            throw new Error("Contract does not implement AccessControl interface");
+        }
+        const adminRole = await (0, accessControl_1.getRoleAdmin)(accessControl, role);
+        logger_1.logger.log(`Admin role for role ${role} is: ${adminRole}`);
+    });
+    const ledgerCmd = program
+        .command("ledger")
+        .description("Commands for ledger");
+    ledgerCmd
+        .command("addresses")
+        .description("Get ledger addresses")
+        .asyncAction(async () => {
+        const opts = program.opts();
+        const client = await (0, client_1.generateClient)(opts.network, 'ledger');
+        logger_1.logger.log(client.addresses);
+    });
+    ledgerCmd
+        .command('fix-usb-rules')
+        .description('Fix ledger usb rules on linux')
+        .asyncAction(async (config) => {
+        logger_1.logger.log("Fixing ledger usb rules...");
+        try {
+            // Execute system command to fix ledger usb rules (https://github.com/LedgerHQ/ledger-live-desktop/issues/2873#issuecomment-674844905)
+            const result = (0, child_process_1.execSync)('wget -q -O - https://raw.githubusercontent.com/LedgerHQ/udev-rules/master/add_udev_rules.sh | sudo bash');
+            logger_1.logger.log(result.toString());
+        }
+        catch (error) {
+            logger_1.logger.error("Failed to fix ledger usb rules");
+            logger_1.logger.error(error);
+        }
+    });
+    const safeCmd = program
+        .command("safe")
+        .description("Commands for safe");
+    safeCmd
+        .command("nonce")
+        .description("Get safe nonce")
+        .addArgument((0, cliParser_1.ArgAddress)("safeAddress", "Address of the safe"))
+        .asyncAction(async (config, safeAddress) => {
+        logger_1.logger.log((await config.client.safe.getNonce()).toString());
+    });
+    safeCmd
+        .command("get-role")
+        .description("Get user role in the safe")
+        .addOption((0, cliParser_1.OptAddress)("--account <account>", "Account address to check"))
+        .asyncAction({ signer: true }, async (config, options) => {
+        const addressToCheck = options.account || config.client.account.address;
+        const owners = await config.client.safe.getOwners();
+        const delegates = await config.client.safe.apiKit.getSafeDelegates({ safeAddress: program.opts().safe });
+        if (owners.find(owner => owner.toLowerCase() === addressToCheck.toLowerCase())) {
+            logger_1.logger.log("Owner");
+        }
+        else if (delegates.results.find(delegate => delegate.delegate.toLowerCase() === addressToCheck.toLowerCase())) {
+            logger_1.logger.log("Delegate");
+        }
+        else {
+            logger_1.logger.log("No role");
+        }
+    });
+    program.
+        command('create-network', { hidden: true })
+        .description('Create a new network')
+        .argument('chainName', 'Name of the chain')
+        .argument('genesisFile', 'Path to the genesis file')
+        .option('--vm-id <vmId>', 'subnet-evm custom id')
+        .asyncAction({ signer: true }, async (config, chainName, genesisFile, options) => {
+        const subnetId = await (0, pChainUtils_1.createSubnet)({ client: config.client });
+        const genesisData = (0, fs_1.readFileSync)(genesisFile).toString('utf-8');
+        const chainId = await (0, pChainUtils_1.createChain)({
+            client: config.client,
+            chainName,
+            subnetId,
+            genesisData,
+            SubnetEVMId: options.vmId
+        });
+        logger_1.logger.log(`Network created:`);
+        logger_1.logger.log(`  Chain ID: ${chainId}`);
+        logger_1.logger.log(`  Subnet ID: ${subnetId}`);
+        logger_1.logger.addData('network', { chainId, subnetId });
+    });
+    program
+        .command('subnet-to-l1', { hidden: true })
+        .description('Convert a subnet to L1')
+        .addArgument((0, cliParser_1.ArgCB58)('subnetId', 'Subnet ID of the subnet'))
+        .addArgument((0, cliParser_1.ArgCB58)('chainId', 'Chain ID of the subnet'))
+        .addArgument((0, cliParser_1.ArgAddress)('validatorManagerAddress', 'Validator manager of the subnet'))
+        .addArgument((0, cliParser_1.ArgCB58)('vmcChainId', 'Validator Manager Contract Chain ID'))
+        .addOption(new extra_typings_1.Option('--validatorConfig <validatorConfig>', 'Validator config file path (json)').default([]).argParser((0, cliParser_1.collectMultiple)(String)).makeOptionMandatory())
+        .addOption((0, cliParser_1.OptHex)('--convertTx <convertTx>', 'Existing convert transaction hash to reuse'))
+        .addOption(new extra_typings_1.Option('--init-vmc', 'Initialize the VMC before conversion'))
+        .asyncAction({ signer: true }, async (config, subnetId, chainId, validatorManagerAddress, vmcChainId, options) => {
+        // const validatorManager = await config.contracts.ValidatorManager(validatorManagerAddress)
+        await (0, pChainUtils_1.convertSubnetToL1)({ client: config.client, subnetId, chainId, validatorManager: validatorManagerAddress, validatorManagerBlockchainID: vmcChainId, validators: options.validatorConfig.map(v => JSON.parse((0, fs_1.readFileSync)(v).toString('utf-8'))), convertTx: options.convertTx, init: options.initVmc });
+    });
+    program
+        .command("help-all")
+        .description("Display help for all commands and sub-commands")
+        .action(() => {
+        console.log(`Suzaku CLI - version ${program.version()}`);
+        console.log(program.description());
+        console.log("Commands:\n");
+        printIndentedHelp(program);
+    });
+    program
+        .command("completion install")
+        .description("Install autocompletion for Bash/Zsh")
+        .action(() => (0, autoCompletion_1.installCompletion)(program));
+    program
+        .command("__complete")
+        .description("internal completion helper")
+        .option("--line <line>")
+        .action(({ line }) => {
+        line = line || "";
+        const parts = line.trim().split(/\s+/).slice(1);
+        let node = program;
+        for (const part of parts) {
+            const found = node.commands.find(c => c.name() === part);
+            if (!found)
+                break;
+            node = found;
+        }
+        const suggestions = node.commands.map(c => c.name());
+        console.log(suggestions.join(" "));
+    });
+    program.parse(process.argv);
+}
+main();
+//# sourceMappingURL=cli.js.map