@lidofinance/lsv-cli 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/programs/delegation.js

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const _command_1 = require("../command");
-const _contracts_1 = require("../contracts");
-const _utils_1 = require("../utils");
-const _features_1 = require("../features");
-const delegation = _command_1.program
-    .command("delegation")
-    .description("delegation contract");
-delegation
-    .command("roles")
-    .description("get delegation contract roles info")
-    .argument("<address>", "delegation contract address")
+import { program } from '../command/index.js';
+import { getDelegationContract, getStakingVaultContract } from '../contracts/index.js';
+import { callWriteMethod, callReadMethod } from '../utils/index.js';
+import { getBaseInfo } from '../features/index.js';
+const delegation = program
+    .command('delegation')
+    .description('delegation contract');
+delegation
+    .command('roles')
+    .description('get delegation contract roles info')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
+    const contract = getDelegationContract(address);
     try {
         const CURATOR_ROLE = await contract.read.CURATOR_ROLE();
         const NODE_OPERATOR_MANAGER_ROLE = await contract.read.NODE_OPERATOR_MANAGER_ROLE();
@@ -44,86 +42,86 @@ delegation
     }
     catch (err) {
         if (err instanceof Error) {
-            console.log("Error when getting roles:\n", err.message);
+            console.info('Error when getting roles:\n', err.message);
         }
     }
 });
 delegation
-    .command("base-info")
-    .description("get delegation base info")
-    .argument("<address>", "delegation address")
+    .command('base-info')
+    .description('get delegation base info')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _features_1.getBaseInfo)(contract);
+    const contract = getDelegationContract(address);
+    await getBaseInfo(contract);
 });
 delegation
-    .command("voting-lifetime")
+    .command('voting-lifetime')
     .description("get committee's voting lifetime period")
-    .argument("<address>", "delegation contract address")
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "voteLifetime");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'voteLifetime');
 });
 delegation
-    .command("is-healthy")
-    .description("get vault healthy info")
-    .argument("<address>", "vault address")
+    .command('is-healthy')
+    .description('get vault healthy info')
+    .argument('<address>', 'vault address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
+    const contract = getDelegationContract(address);
     try {
         const valuation = await contract.read.valuation();
         const curatorUnclaimedFee = await contract.read.curatorUnclaimedFee();
         const nodeOperatorUnclaimedFee = await contract.read.nodeOperatorUnclaimedFee();
         const minted = await contract.read.sharesMinted();
         const { vault } = await contract.read.vaultSocket();
-        const vaultContract = (0, _contracts_1.getStakingVaultContract)(vault);
+        const vaultContract = getStakingVaultContract(vault);
         const locked = await vaultContract.read.locked();
         const reserved = locked + curatorUnclaimedFee + nodeOperatorUnclaimedFee;
         const valuationPerc = (valuation / (reserved + minted)) * 100n;
         const isHealthy = valuationPerc >= 100n;
         console.table({
-            "Vault Healthy": isHealthy,
+            'Vault Healthy': isHealthy,
             Valuation: valuation,
-            "Curator Unclaimed Fee": curatorUnclaimedFee,
-            "Node Operator Unclaimed Fee": nodeOperatorUnclaimedFee,
+            'Curator Unclaimed Fee': curatorUnclaimedFee,
+            'Node Operator Unclaimed Fee': nodeOperatorUnclaimedFee,
             Minted: minted,
             Reserved: reserved,
         });
     }
     catch (err) {
         if (err instanceof Error) {
-            console.log("Error when getting info:\n", err.message);
+            console.info('Error when getting info:\n', err.message);
         }
     }
 });
 delegation
-    .command("voting-info")
-    .description("get committee votes")
-    .argument("<address>", "delegation contract address")
-    .argument("<callId>", "voting id")
-    .argument("<role>", "role that voted")
+    .command('voting-info')
+    .description('get committee votes')
+    .argument('<address>', 'delegation contract address')
+    .argument('<callId>', 'voting id')
+    .argument('<role>', 'role that voted')
     .action(async (address, callId, role) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "votings", [callId, role]);
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'votings', [callId, role]);
 });
 delegation
-    .command("cf")
-    .description("Curator fee in basis points")
-    .argument("<address>", "delegation contract address")
+    .command('cf')
+    .description('Curator fee in basis points')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "curatorFeeBP");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'curatorFeeBP');
 });
 delegation
-    .command("cf-report")
-    .description("The last report for which curator fee was claimed. Updated on each claim.")
-    .argument("<address>", "delegation contract address")
+    .command('cf-report')
+    .description('The last report for which curator fee was claimed. Updated on each claim.')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "curatorFeeClaimedReport");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'curatorFeeClaimedReport');
 });
 delegation
-    .command("cf-unclaimed")
+    .command('cf-unclaimed')
     .description(`Returns the accumulated unclaimed curator fee in ether,
     calculated as: U = (R * F) / T
     where:
@@ -131,55 +129,55 @@ delegation
     - R is the StakingVault rewards accrued since the last curator fee claim;
     - F is curatorFeeBP
     - T is the total basis points, 10,000.`)
-    .argument("<address>", "delegation contract address")
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "curatorUnclaimedFee");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'curatorUnclaimedFee');
 });
 delegation
-    .command("cf-set")
-    .description("sets the curator fee")
-    .argument("<address>", "delegation contract address")
-    .argument("<newCuratorFee>", "curator fee in basis points")
+    .command('cf-set')
+    .description('sets the curator fee')
+    .argument('<address>', 'delegation contract address')
+    .argument('<newCuratorFee>', 'curator fee in basis points')
     .action(async (address, newCuratorFee) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "setCuratorFeeBP", [BigInt(newCuratorFee)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'setCuratorFeeBP', [BigInt(newCuratorFee)]);
 });
 delegation
-    .command("cf-claim")
-    .description("claims the curator fee")
-    .argument("<address>", "delegation contract address")
-    .argument("<recipient>", "address to which the curator fee will be sent")
+    .command('cf-claim')
+    .description('claims the curator fee')
+    .argument('<address>', 'delegation contract address')
+    .argument('<recipient>', 'address to which the curator fee will be sent')
     .action(async (address, recipient) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "claimCuratorFee", [recipient]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'claimCuratorFee', [recipient]);
 });
 delegation
-    .command("nof")
-    .description("Node operator fee in basis points")
-    .argument("<address>", "delegation contract address")
+    .command('nof')
+    .description('Node operator fee in basis points')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
+    const contract = getDelegationContract(address);
     try {
         const nodeOperatorFeeBP = await contract.read.nodeOperatorFeeBP();
-        console.table({ "Node Operator Fee BP:": nodeOperatorFeeBP });
+        console.table({ 'Node Operator Fee BP:': nodeOperatorFeeBP });
     }
     catch (err) {
         if (err instanceof Error) {
-            console.log("Error when getting Node Operator Fee BP:\n", err.message);
+            console.info('Error when getting Node Operator Fee BP:\n', err.message);
         }
     }
 });
 delegation
-    .command("nof-report")
-    .description("The last report for which node operator fee was claimed. Updated on each claim.")
-    .argument("<address>", "delegation contract address")
+    .command('nof-report')
+    .description('The last report for which node operator fee was claimed. Updated on each claim.')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "nodeOperatorUnclaimedFee");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'nodeOperatorFeeClaimedReport');
 });
 delegation
-    .command("nof-unclaimed")
+    .command('nof-unclaimed')
     .description(`Returns the accumulated unclaimed node operator fee in ether,
     calculated as: U = (R * F) / T
     where:
@@ -187,46 +185,46 @@ delegation
     - R is the StakingVault rewards accrued since the last node operator fee claim;
     - F is nodeOperatorFeeBP
     - T is the total basis points, 10,000.`)
-    .argument("<address>", "delegation contract address")
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "nodeOperatorUnclaimedFee");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'nodeOperatorUnclaimedFee');
 });
 delegation
-    .command("nof-set")
-    .description("sets the node operator fee")
-    .argument("<address>", "delegation contract address")
-    .argument("<newNodeOperatorFeeBP>", "The new node operator fee in basis points")
+    .command('nof-set')
+    .description('sets the node operator fee')
+    .argument('<address>', 'delegation contract address')
+    .argument('<newNodeOperatorFeeBP>', 'The new node operator fee in basis points')
     .action(async (address, newNodeOperatorFeeBP) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "setNodeOperatorFeeBP", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'setNodeOperatorFeeBP', [
         BigInt(newNodeOperatorFeeBP),
     ]);
 });
 delegation
-    .command("nof-claim")
-    .description("claims the node operator fee")
-    .argument("<address>", "delegation contract address")
-    .argument("<recipient>", "address to which the node operator fee will be sent")
+    .command('nof-claim')
+    .description('claims the node operator fee')
+    .argument('<address>', 'delegation contract address')
+    .argument('<recipient>', 'address to which the node operator fee will be sent')
     .action(async (address, recipient) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "claimNodeOperatorFee", [recipient]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'claimNodeOperatorFee', [recipient]);
 });
 delegation
-    .command("unreserved")
-    .description("returns the unreserved amount of ether")
-    .argument("<address>", "delegation contract address")
+    .command('unreserved')
+    .description('returns the unreserved amount of ether')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "unreserved");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'unreserved');
 });
 delegation
-    .command("vc")
-    .description("returns the voting committee")
-    .argument("<address>", "delegation contract address")
+    .command('vc')
+    .description('returns the voting committee')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    const committeeList = await (0, _utils_1.callReadMethod)(contract, "votingCommittee");
+    const contract = getDelegationContract(address);
+    const committeeList = await callReadMethod(contract, 'votingCommittee');
     const committee = {
         CURATOR_ROLE: committeeList[0],
         NODE_OPERATOR_MANAGER_ROLE: committeeList[1],
@@ -234,372 +232,350 @@ delegation
     console.table({ committee });
 });
 delegation
-    .command("fund")
-    .description("funds the StakingVault with ether")
-    .argument("<address>", "delegation contract address")
-    .argument("<ether>", "ether to fund")
+    .command('fund')
+    .description('funds the StakingVault with ether')
+    .argument('<address>', 'delegation contract address')
+    .argument('<ether>', 'ether to fund')
     .action(async (address, ether) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "fund", [], BigInt(ether));
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'fund', [], BigInt(ether));
 });
 delegation
-    .command("withdraw")
-    .description("withdraws ether from the StakingVault")
-    .argument("<address>", "delegation contract address")
-    .argument("<recipient>", "address to which the ether will be sent")
-    .argument("<ether>", "ether to found")
+    .command('withdraw')
+    .description('withdraws ether from the StakingVault')
+    .argument('<address>', 'delegation contract address')
+    .argument('<recipient>', 'address to which the ether will be sent')
+    .argument('<ether>', 'ether to found')
     .action(async (address, recipient, ether) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "withdraw", [recipient, BigInt(ether)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'withdraw', [recipient, BigInt(ether)]);
 });
 delegation
-    .command("mint")
-    .description("mints shares for a given recipient")
-    .argument("<address>", "delegation contract address")
-    .argument("<recipient>", "address to which the ether will be sent")
-    .argument("<amountOfShares>", "amount of shares to mint")
-    .action(async (address, recipient, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "mintShares", [
-        recipient,
-        BigInt(amountOfShares),
-    ]);
-});
-delegation
-    .command("burn")
-    .description("burns shares for a given recipient")
-    .argument("<address>", "delegation contract address")
-    .argument("<amountOfShares>", "amount of shares to mint")
-    .action(async (address, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnShares", [BigInt(amountOfShares)]);
-});
-delegation
-    .command("rebalance")
-    .description("rebalances the StakingVault with a given amount of ether")
-    .argument("<address>", "delegation contract address")
-    .argument("<ether>", "amount of ether to rebalance with")
+    .command('rebalance')
+    .description('rebalances the StakingVault with a given amount of ether')
+    .argument('<address>', 'delegation contract address')
+    .argument('<ether>', 'amount of ether to rebalance with')
     .action(async (address, ether) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "rebalanceVault", [BigInt(ether)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'rebalanceVault', [BigInt(ether)]);
 });
 delegation
-    .command("set-vote-lt")
-    .description("sets the vote lifetime")
-    .argument("<address>", "delegation contract address")
-    .argument("<newVoteLifetime>", "new vote lifetime in seconds")
+    .command('set-vote-lt')
+    .description('sets the vote lifetime')
+    .argument('<address>', 'delegation contract address')
+    .argument('<newVoteLifetime>', 'new vote lifetime in seconds')
     .action(async (address, newVoteLifetime) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "setVoteLifetime", [BigInt(newVoteLifetime)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'setVoteLifetime', [
+        BigInt(newVoteLifetime),
+    ]);
 });
+// TODO: test without voting
 delegation
-    .command("t-ownership")
-    .description("transfers the ownership of the StakingVault")
-    .argument("<address>", "delegation contract address")
-    .argument("<newOwner>", "address to which the ownership will be transferred")
+    .command('t-ownership')
+    .description('transfers the ownership of the StakingVault')
+    .argument('<address>', 'delegation contract address')
+    .argument('<newOwner>', 'address to which the ownership will be transferred')
     .action(async (address, newOwner) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "transferStakingVaultOwnership", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'transferStakingVaultOwnership', [
         newOwner,
     ]);
 });
 delegation
-    .command("disconnect")
-    .description("voluntarily disconnects a StakingVault from VaultHub")
-    .argument("<address>", "delegation contract address")
+    .command('disconnect')
+    .description('voluntarily disconnects a StakingVault from VaultHub')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "voluntaryDisconnect", []);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'voluntaryDisconnect', []);
 });
 delegation
-    .command("deposit-pause")
-    .description("Pauses deposits to beacon chain from the StakingVault.")
-    .argument("<address>", "delegation contract address")
+    .command('deposit-pause')
+    .description('Pauses deposits to beacon chain from the StakingVault.')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "pauseBeaconChainDeposits", []);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'pauseBeaconChainDeposits', []);
 });
 delegation
-    .command("deposit-resume")
-    .description("Resumes deposits to beacon chain from the StakingVault.")
-    .argument("<address>", "delegation contract address")
+    .command('deposit-resume')
+    .description('Resumes deposits to beacon chain from the StakingVault.')
+    .argument('<address>', 'delegation contract address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "resumeBeaconChainDeposits", []);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'resumeBeaconChainDeposits', []);
 });
 delegation
-    .command("vault")
-    .description("vault info")
-    .argument("<address>", "delegation address")
+    .command('vault')
+    .description('vault info')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "vaultSocket");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'vaultSocket');
 });
 delegation
-    .command("s-limit")
-    .description("shares limit")
-    .argument("<address>", "delegation address")
+    .command('s-limit')
+    .description('shares limit')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "shareLimit");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'shareLimit');
 });
 delegation
-    .command("s-minted")
-    .description("shares minted")
-    .argument("<address>", "delegation address")
+    .command('s-minted')
+    .description('shares minted')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "sharesMinted");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'sharesMinted');
 });
 delegation
-    .command("reserve-ratio")
-    .description("vault reserve ratio of the vault")
-    .argument("<address>", "delegation address")
+    .command('reserve-ratio')
+    .description('vault reserve ratio of the vault')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "reserveRatioBP");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'reserveRatioBP');
 });
 delegation
-    .command("t-reserve-ratio")
-    .description("threshold reserve ratio of the vault")
-    .argument("<address>", "delegation address")
+    .command('t-reserve-ratio')
+    .description('threshold reserve ratio of the vault')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "thresholdReserveRatioBP");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'thresholdReserveRatioBP');
 });
 delegation
-    .command("t-fee")
-    .description("treasury fee basis points")
-    .argument("<address>", "delegation address")
+    .command('t-fee')
+    .description('treasury fee basis points')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "treasuryFee");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'treasuryFee');
 });
 delegation
-    .command("valuation")
-    .description("valuation of the vault in ether")
-    .argument("<address>", "delegation address")
+    .command('valuation')
+    .description('valuation of the vault in ether')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "valuation");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'valuation');
 });
 delegation
-    .command("t-shares")
-    .description("total of shares that can be minted on the vault")
-    .argument("<address>", "delegation address")
+    .command('t-shares')
+    .description('total of shares that can be minted on the vault')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "totalMintableShares");
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'totalMintableShares');
 });
 delegation
-    .command("get-shares")
-    .description("maximum number of shares that can be minted with deposited ether")
-    .argument("<address>", "delegation address")
-    .argument("<ether>", "amount of ether to be funded")
+    .command('get-shares')
+    .description('maximum number of shares that can be minted with deposited ether')
+    .argument('<address>', 'delegation address')
+    .argument('<ether>', 'amount of ether to be funded')
     .action(async (address, ether) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "projectedNewMintableShares", [
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'projectedNewMintableShares', [
         BigInt(ether),
     ]);
 });
 delegation
-    .command("withdrawable-eth")
-    .description("amount of ether that can be withdrawn from the staking vault")
-    .argument("<address>", "delegation address")
+    .command('withdrawable-eth')
+    .description('amount of ether that can be withdrawn from the staking vault')
+    .argument('<address>', 'delegation address')
     .action(async (address) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callReadMethod)(contract, "withdrawableEther");
-});
-// TODO: test without voting
-delegation
-    .command("ownership")
-    .description("transfers ownership of the staking vault to a new owner")
-    .argument("<address>", "delegation address")
-    .argument("<newOwner>", "address of the new owner")
-    .action(async (address, newOwner) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "transferStakingVaultOwnership", [
-        newOwner,
-    ]);
+    const contract = getDelegationContract(address);
+    await callReadMethod(contract, 'withdrawableEther');
 });
 delegation
-    .command("fund-weth")
-    .description("funds the staking vault with wrapped ether")
-    .argument("<address>", "delegation address")
-    .argument("<wethAmount>", "amount of weth to be funded")
+    .command('fund-weth')
+    .description('funds the staking vault with wrapped ether')
+    .argument('<address>', 'delegation address')
+    .argument('<wethAmount>', 'amount of weth to be funded')
     .action(async (address, wethAmount) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "fundWeth", [BigInt(wethAmount)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'fundWeth', [BigInt(wethAmount)]);
 });
 delegation
-    .command("withdraw-weth")
-    .description("withdraws stETH tokens from the staking vault to wrapped ether")
-    .argument("<address>", "delegation address")
-    .argument("<recipient>", "address of the recipient")
-    .argument("<ether>", "amount of ether to withdraw")
+    .command('withdraw-weth')
+    .description('withdraws stETH tokens from the staking vault to wrapped ether')
+    .argument('<address>', 'delegation address')
+    .argument('<recipient>', 'address of the recipient')
+    .argument('<ether>', 'amount of ether to withdraw')
     .action(async (address, recipient, ether) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "withdrawWETH", [recipient, BigInt(ether)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'withdrawWETH', [recipient, BigInt(ether)]);
 });
 delegation
-    .command("exit")
-    .description("requests the exit of a validator from the staking vault")
-    .argument("<address>", "delegation address")
-    .argument("<validatorPubKey>", "public key of the validator to exit")
+    .command('exit')
+    .description('requests the exit of a validator from the staking vault')
+    .argument('<address>', 'delegation address')
+    .argument('<validatorPubKey>', 'public key of the validator to exit')
     .action(async (address, validatorPubKey) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "requestValidatorExit", [validatorPubKey]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'requestValidatorExit', [validatorPubKey]);
 });
 delegation
-    .command("mint-shares")
-    .description("mints stETH tokens backed by the vault to a recipient")
-    .argument("<address>", "delegation address")
-    .argument("<recipient>", "address of the recipient")
-    .argument("<amountOfShares>", "amount of shares to mint")
+    .command('mint-shares')
+    .description('mints stETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'delegation address')
+    .argument('<recipient>', 'address of the recipient')
+    .argument('<amountOfShares>', 'amount of shares to mint')
     .action(async (address, recipient, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "mintShares", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'mintShares', [
         recipient,
         BigInt(amountOfShares),
     ]);
 });
 delegation
-    .command("mint-steth")
-    .description("mints stETH tokens backed by the vault to a recipient")
-    .argument("<address>", "delegation address")
-    .argument("<recipient>", "address of the recipient")
-    .argument("<amountOfShares>", "amount of shares to mint")
+    .command('mint-steth')
+    .description('mints stETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'delegation address')
+    .argument('<recipient>', 'address of the recipient')
+    .argument('<amountOfShares>', 'amount of shares to mint')
     .action(async (address, recipient, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "mintStETH", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'mintStETH', [
         recipient,
         BigInt(amountOfShares),
     ]);
 });
 delegation
-    .command("mint-wsteth")
-    .description("mints wstETH tokens backed by the vault to a recipient")
-    .argument("<address>", "delegation address")
-    .argument("<recipient>", "address of the recipient")
-    .argument("<tokens>", "amount of tokens to mint")
+    .command('mint-wsteth')
+    .description('mints wstETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'delegation address')
+    .argument('<recipient>', 'address of the recipient')
+    .argument('<tokens>', 'amount of tokens to mint')
     .action(async (address, recipient, tokens) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "mintWstETH", [recipient, BigInt(tokens)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'mintWstETH', [recipient, BigInt(tokens)]);
 });
 delegation
-    .command("burn-shares")
-    .description("Burns stETH shares from the sender backed by the vault. Expects corresponding amount of stETH approved to this contract")
-    .argument("<address>", "delegation address")
-    .argument("<amountOfShares>", "amount of shares to burn")
+    .command('burn-shares')
+    .description('Burns stETH shares from the sender backed by the vault. Expects corresponding amount of stETH approved to this contract')
+    .argument('<address>', 'delegation address')
+    .argument('<amountOfShares>', 'amount of shares to burn')
     .action(async (address, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnShares", [BigInt(amountOfShares)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnShares', [BigInt(amountOfShares)]);
 });
 delegation
-    .command("burn-steth")
-    .description("Burns stETH shares from the sender backed by the vault. Expects stETH amount approved to this contract.")
-    .argument("<address>", "delegation address")
-    .argument("<amountOfShares>", "amount of shares to burn")
+    .command('burn-steth')
+    .description('Burns stETH shares from the sender backed by the vault. Expects stETH amount approved to this contract.')
+    .argument('<address>', 'delegation address')
+    .argument('<amountOfShares>', 'amount of shares to burn')
     .action(async (address, amountOfShares) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnStETH", [BigInt(amountOfShares)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnStETH', [BigInt(amountOfShares)]);
 });
 delegation
-    .command("burn-wsteth")
-    .description("burn wstETH tokens from the sender backed by the vault")
-    .argument("<address>", "delegation address")
-    .argument("<tokens>", "amount of wstETH tokens to burn")
+    .command('burn-wsteth')
+    .description('burn wstETH tokens from the sender backed by the vault')
+    .argument('<address>', 'delegation address')
+    .argument('<tokens>', 'amount of wstETH tokens to burn')
     .action(async (address, tokens) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnWstETH", [BigInt(tokens)]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnWstETH', [BigInt(tokens)]);
 });
 delegation
-    .command("burn-shares-permit")
-    .description("Burns stETH tokens (in shares) backed by the vault from the sender using permit (with value in stETH).")
-    .argument("<address>", "delegation address")
-    .argument("<tokens>", "amount of stETH tokens to burn")
-    .argument("<permitJSON>", "JSON data required for the stETH.permit() method to set the allowance")
+    .command('burn-shares-permit')
+    .description('Burns stETH tokens (in shares) backed by the vault from the sender using permit (with value in stETH).')
+    .argument('<address>', 'delegation address')
+    .argument('<tokens>', 'amount of stETH tokens to burn')
+    .argument('<permitJSON>', 'JSON data required for the stETH.permit() method to set the allowance')
     .action(async (address, tokens, permitJSON) => {
     const permit = JSON.parse(permitJSON);
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnSharesWithPermit", [BigInt(tokens), permit]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnSharesWithPermit', [
+        BigInt(tokens),
+        permit,
+    ]);
 });
 delegation
-    .command("burn-steth-permit")
-    .description("Burns stETH tokens backed by the vault from the sender using permit.")
-    .argument("<address>", "delegation address")
-    .argument("<tokens>", "amount of stETH tokens to burn")
-    .argument("<permitJSON>", "JSON data required for the stETH.permit() method to set the allowance")
+    .command('burn-steth-permit')
+    .description('Burns stETH tokens backed by the vault from the sender using permit.')
+    .argument('<address>', 'delegation address')
+    .argument('<tokens>', 'amount of stETH tokens to burn')
+    .argument('<permitJSON>', 'JSON data required for the stETH.permit() method to set the allowance')
     .action(async (address, tokens, permitJSON) => {
     const permit = JSON.parse(permitJSON);
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnStETHWithPermit", [BigInt(tokens), permit]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnStETHWithPermit', [
+        BigInt(tokens),
+        permit,
+    ]);
 });
 delegation
-    .command("burn-wsteth-permit")
-    .description("burn wstETH tokens from the sender backed by the vault using EIP-2612 Permit")
-    .argument("<address>", "delegation address")
-    .argument("<tokens>", "amount of wstETH tokens to burn")
-    .argument("<permitJSON>", "JSON data required for the wstETH.permit() method to set the allowance")
+    .command('burn-wsteth-permit')
+    .description('burn wstETH tokens from the sender backed by the vault using EIP-2612 Permit')
+    .argument('<address>', 'delegation address')
+    .argument('<tokens>', 'amount of wstETH tokens to burn')
+    .argument('<permitJSON>', 'JSON data required for the wstETH.permit() method to set the allowance')
     .action(async (address, tokens, permitJSON) => {
     const permit = JSON.parse(permitJSON);
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "burnWstETHWithPermit", [BigInt(tokens), permit]);
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'burnWstETHWithPermit', [
+        BigInt(tokens),
+        permit,
+    ]);
 });
 delegation
-    .command("recover-erc20")
-    .description("recovers ERC20 tokens or ether from the delegation contract to sender")
-    .argument("<address>", "delegation address")
-    .argument("<token>", "Address of the token to recover or 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee for ether")
-    .argument("<recipient>", "Address of the recovery recipient")
-    .argument("<amount>", "amount of ether to recover")
+    .command('recover-erc20')
+    .description('recovers ERC20 tokens or ether from the delegation contract to sender')
+    .argument('<address>', 'delegation address')
+    .argument('<token>', 'Address of the token to recover or 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee for ether')
+    .argument('<recipient>', 'Address of the recovery recipient')
+    .argument('<amount>', 'amount of ether to recover')
     .action(async (address, token, recipient, amount) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    (0, _utils_1.callWriteMethod)(contract, "recoverERC20", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'recoverERC20', [
         token,
         recipient,
         BigInt(amount),
     ]);
 });
 delegation
-    .command("recover-erc721")
-    .description("Transfers a given token_id of an ERC721-compatible NFT (defined by the token contract address)")
-    .argument("<address>", "delegation address")
-    .argument("<token>", "an ERC721-compatible token")
-    .argument("<tokenId>", "token id to recover")
-    .argument("<recipient>", "Address of the recovery recipient")
+    .command('recover-erc721')
+    .description('Transfers a given token_id of an ERC721-compatible NFT (defined by the token contract address)')
+    .argument('<address>', 'delegation address')
+    .argument('<token>', 'an ERC721-compatible token')
+    .argument('<tokenId>', 'token id to recover')
+    .argument('<recipient>', 'Address of the recovery recipient')
     .action(async (address, token, tokenId, recipient) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
-    await (0, _utils_1.callWriteMethod)(contract, "recoverERC721", [
+    const contract = getDelegationContract(address);
+    await callWriteMethod(contract, 'recoverERC721', [
         token,
         BigInt(tokenId),
         recipient,
     ]);
 });
 delegation
-    .command("role-grant")
-    .description("Mass-revokes multiple roles from multiple accounts.")
-    .argument("<address>", "delegation address")
-    .argument("<roleAssignmentJSON>", "JSON array of role assignments")
+    .command('role-grant')
+    .description('Mass-revokes multiple roles from multiple accounts.')
+    .argument('<address>', 'delegation address')
+    .argument('<roleAssignmentJSON>', 'JSON array of role assignments')
     .action(async (address, roleAssignmentJSON) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
+    const contract = getDelegationContract(address);
     const payload = JSON.parse(roleAssignmentJSON);
     if (!Array.isArray(payload)) {
-        throw new Error("the 2nd argument should be an array of role assignments");
+        throw new Error('the 2nd argument should be an array of role assignments');
     }
-    await (0, _utils_1.callWriteMethod)(contract, "grantRoles", [payload]);
+    await callWriteMethod(contract, 'grantRoles', [payload]);
 });
 delegation
-    .command("role-revoke")
-    .description("Resumes beacon chain deposits on the staking vault.")
-    .argument("<address>", "delegation address")
-    .argument("<roleAssignmentJSON>", "JSON array of role assignments")
+    .command('role-revoke')
+    .description('Resumes beacon chain deposits on the staking vault.')
+    .argument('<address>', 'delegation address')
+    .argument('<roleAssignmentJSON>', 'JSON array of role assignments')
     .action(async (address, roleAssignmentJSON) => {
-    const contract = (0, _contracts_1.getDelegationContract)(address);
+    const contract = getDelegationContract(address);
     const payload = JSON.parse(roleAssignmentJSON);
     if (!Array.isArray(payload)) {
-        throw new Error("the 2nd argument should be an array of role assignments");
+        throw new Error('the 2nd argument should be an array of role assignments');
     }
-    await (0, _utils_1.callWriteMethod)(contract, "revokeRoles", [payload]);
+    await callWriteMethod(contract, 'revokeRoles', [payload]);
 });
 //# sourceMappingURL=delegation.js.map