@lidofinance/lsv-cli 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/programs/dashboard/read.js

@@ -0,0 +1,88 @@
+import { formatEther } from 'viem';
+import { Option } from 'commander';
+import { DashboardAbi } from '../../abi/index.js';
+import { getDashboardBaseInfo, getDashboardRoles, getDashboardHealth, getDashboardOverview, } from '../../features/index.js';
+import { getDashboardContract, getStakingVaultContract } from '../../contracts/index.js';
+import { generateReadCommands, logResult, logInfo, getCommandsJson, stringToAddress, callReadMethod, getRequiredLockByShares, callReadMethodSilent, } from '../../utils/index.js';
+import { dashboard } from './main.js';
+import { readCommandConfig } from './config.js';
+const dashboardRead = dashboard
+    .command('read')
+    .alias('r')
+    .description('read commands');
+dashboardRead.addOption(new Option('-cmd2json'));
+dashboardRead.on('option:-cmd2json', function () {
+    logInfo(getCommandsJson(dashboardRead));
+    process.exit();
+});
+dashboardRead
+    .command('info')
+    .description('get dashboard base info')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    await getDashboardBaseInfo(contract);
+});
+dashboardRead
+    .command('overview')
+    .description('get dashboard overview')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    await getDashboardOverview(contract);
+});
+dashboardRead
+    .command('roles')
+    .description('get dashboard roles')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    await getDashboardRoles(contract);
+});
+dashboardRead
+    .command('health')
+    .description('get vault health info')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    await getDashboardHealth(contract);
+});
+dashboardRead
+    .command('locked')
+    .description('get locked info')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const vaultContract = getStakingVaultContract(vault);
+    await callReadMethod(vaultContract, 'locked');
+});
+dashboardRead
+    .command('required-lock-by-shares')
+    .alias('req-lock')
+    .description('get required lock by shares')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<newShares>', 'new shares')
+    .action(async (address, newShares) => {
+    const { requiredLock, currentLock } = await getRequiredLockByShares(address, newShares);
+    logResult({
+        'Required Lock (wei)': requiredLock,
+        'Required Lock (shares)': formatEther(requiredLock),
+        'Current Lock (wei)': currentLock,
+        'Current Lock (shares)': formatEther(currentLock),
+    });
+});
+dashboardRead
+    .command('dashboard-address-by-vault')
+    .alias('dashboard-by-vault')
+    .description('get dashboard address by vault')
+    .argument('<vault>', 'vault address', stringToAddress)
+    .action(async (vault) => {
+    const contract = getStakingVaultContract(vault);
+    const owner = await callReadMethodSilent(contract, 'owner');
+    logResult({
+        'Dashboard Address': owner,
+    });
+});
+generateReadCommands(DashboardAbi, getDashboardContract, dashboardRead, readCommandConfig);
+//# sourceMappingURL=read.js.map

package/dist/programs/dashboard/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../programs/dashboard/read.ts"],"names":[],"mappings":"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"}

package/dist/programs/dashboard/write.d.ts

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

package/dist/programs/dashboard/write.js

@@ -0,0 +1,553 @@
+import { parseEther, formatEther } from 'viem';
+import { Option } from 'commander';
+import { getDashboardContract, getStakingVaultContract } from '../../contracts/index.js';
+import { callReadMethod, callWriteMethodWithReceipt, stringToBigIntArray, jsonToRoleAssignment, confirmOperation, stringToBigInt, mintShares, burnShares, parseDepositArray, logInfo, getCommandsJson, stringToAddress, mintSteth, burnSteth, createPDGProof, } from '../../utils/index.js';
+import { dashboard } from './main.js';
+const dashboardWrite = dashboard
+    .command('write')
+    .alias('w')
+    .description('write commands');
+dashboardWrite.addOption(new Option('-cmd2json'));
+dashboardWrite.on('option:-cmd2json', function () {
+    logInfo(getCommandsJson(dashboardWrite));
+    process.exit();
+});
+dashboardWrite
+    .command('ownership')
+    .description('transfers ownership of the staking vault to a new owner')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<newOwner>', 'address of the new owner', stringToAddress)
+    .action(async (address, newOwner) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to transfer ownership of the staking vault ${vault} to ${newOwner}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'transferStakingVaultOwnership',
+        payload: [newOwner],
+    });
+});
+dashboardWrite
+    .command('disconnect')
+    .description('disconnects the staking vault from the vault hub')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to disconnect the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'voluntaryDisconnect',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('fund')
+    .description('funds the staking vault with ether')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<ether>', 'amount of ether to be funded (in ETH)')
+    .action(async (address, ether) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to fund the staking vault ${vault} with ${ether} ether?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'fund',
+        payload: [],
+        value: parseEther(ether),
+    });
+});
+dashboardWrite
+    .command('withdraw')
+    .description('withdraws ether from the staking vault to a recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<recipient>', 'address of the recipient', stringToAddress)
+    .argument('<eth>', 'amount of ether to withdraw (in ETH)')
+    .action(async (address, recipient, ether) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to withdraw ${ether} from the staking vault ${vault} to ${recipient}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'withdraw',
+        payload: [recipient, parseEther(ether)],
+    });
+});
+dashboardWrite
+    .command('lock')
+    .description('updates the locked amount of the staking vault')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<lockedAmount>', 'amount of ether to lock')
+    .action(async (address, lockedAmount) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to update the locked amount of the staking vault ${vault} to ${lockedAmount}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'lock',
+        payload: [parseEther(lockedAmount)],
+    });
+});
+dashboardWrite
+    .command('exit')
+    .description('requests the exit of a validator from the staking vault')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<validatorPubKey>', 'public key of the validator to exit')
+    .action(async (address, validatorPubKey) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to exit the validator ${validatorPubKey} from the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'requestValidatorExit',
+        payload: [validatorPubKey],
+    });
+});
+dashboardWrite
+    .command('trigger-validator-withdrawal')
+    .description('triggers the withdrawal of a validator from the staking vault')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<pubkeys>', 'pubkeys of the validators to withdraw')
+    .argument('<amounts>', 'amounts of ether to withdraw', stringToBigIntArray)
+    .argument('<recipient>', 'address of the recipient', stringToAddress)
+    .action(async (address, pubkeys, amounts, recipient) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const vaultContract = getStakingVaultContract(vault);
+    const fee = await callReadMethod(vaultContract, 'calculateValidatorWithdrawalFee', [BigInt(amounts.length)]);
+    const confirm = await confirmOperation(`Are you sure you want to trigger the withdrawal of the validators ${pubkeys} from the staking vault ${vault} to ${recipient} with amounts ${amounts}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'triggerValidatorWithdrawal',
+        payload: [pubkeys, amounts, recipient],
+        value: fee,
+    });
+});
+dashboardWrite
+    .command('mint-shares')
+    .alias('mint')
+    .description('mints stETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<recipient>', 'address of the recipient', stringToAddress)
+    .argument('<amountOfShares>', 'amount of shares to mint (in Shares)')
+    .action(async (address, recipient, amountOfShares) => {
+    const contract = getDashboardContract(address);
+    await mintShares(contract, recipient, parseEther(amountOfShares), 'mintShares');
+});
+dashboardWrite
+    .command('mint-steth')
+    .description('mints stETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<recipient>', 'address of the recipient', stringToAddress)
+    .argument('<amountOfSteth>', 'amount of stETH to mint')
+    .action(async (address, recipient, amountOfSteth) => {
+    const contract = getDashboardContract(address);
+    await mintSteth(contract, recipient, parseEther(amountOfSteth));
+});
+dashboardWrite
+    .command('mint-wsteth')
+    .description('mints wstETH tokens backed by the vault to a recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<recipient>', 'address of the recipient', stringToAddress)
+    .argument('<amountOfWsteth>', 'amount of wstETH to mint')
+    .action(async (address, recipient, amountOfWsteth) => {
+    const contract = getDashboardContract(address);
+    await mintShares(contract, recipient, parseEther(amountOfWsteth), 'mintWstETH');
+});
+dashboardWrite
+    .command('burn-shares')
+    .alias('burn')
+    .description('Burns stETH shares from the sender backed by the vault. Expects corresponding amount of stETH approved to this contract')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<amountOfShares>', 'amount of shares to burn (in Shares)')
+    .action(async (address, amountOfShares) => {
+    const contract = getDashboardContract(address);
+    await burnShares(contract, parseEther(amountOfShares), 'burnShares');
+});
+dashboardWrite
+    .command('burn-steth')
+    .description('Burns stETH shares from the sender backed by the vault. Expects stETH amount approved to this contract.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<amountOfShares>', 'amount of shares to burn (in stETH)')
+    .action(async (address, amountOfShares) => {
+    const contract = getDashboardContract(address);
+    await burnSteth(contract, parseEther(amountOfShares));
+});
+dashboardWrite
+    .command('burn-wsteth')
+    .description('burn wstETH tokens from the sender backed by the vault')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<tokens>', 'amount of wstETH tokens to burn (in wstETH)')
+    .action(async (address, tokens) => {
+    const contract = getDashboardContract(address);
+    await burnShares(contract, parseEther(tokens), 'burnWstETH');
+});
+dashboardWrite
+    .command('rebalance')
+    .description('rebalance the vault by transferring ether')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<ether>', 'amount of ether to rebalance (in ETH)')
+    .action(async (address, ether) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to rebalance the vault ${vault} with ${ether} ether?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'rebalanceVault',
+        payload: [parseEther(ether)],
+    });
+});
+dashboardWrite
+    .command('recover-erc20')
+    .description('recovers ERC20 tokens or ether from the dashboard contract to sender')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<token>', 'Address of the token to recover or 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee for ether')
+    .argument('<recipient>', 'Address of the recovery recipient', stringToAddress)
+    .argument('<amount>', 'amount of ether to recover (in ETH)')
+    .action(async (address, token, recipient, amount) => {
+    const contract = getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to recover ${amount} ${token} from the dashboard contract ${address} to ${recipient}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'recoverERC20',
+        payload: [token, recipient, parseEther(amount)],
+    });
+});
+dashboardWrite
+    .command('recover-erc721')
+    .description('Transfers a given token_id of an ERC721-compatible NFT (defined by the token contract address)')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<token>', 'an ERC721-compatible token')
+    .argument('<tokenId>', 'token id to recover')
+    .argument('<recipient>', 'Address of the recovery recipient', stringToAddress)
+    .action(async (address, token, tokenId, recipient) => {
+    const contract = getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to recover the token ${token} with id ${tokenId} from the dashboard contract ${address} to ${recipient}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'recoverERC721',
+        payload: [token, BigInt(tokenId), recipient],
+    });
+});
+dashboardWrite
+    .command('deposit-pause')
+    .description('Pauses beacon chain deposits on the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to pause beacon chain deposits on the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'pauseBeaconChainDeposits',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('deposit-resume')
+    .description('Mass-grants multiple roles to multiple accounts.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to resume beacon chain deposits on the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'resumeBeaconChainDeposits',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('role-grant')
+    .description('Mass-revokes multiple roles from multiple accounts.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<roleAssignmentJSON>', 'JSON array of role assignments', jsonToRoleAssignment)
+    .addHelpText('after', `Role assignment format:
+    [{
+      "account": "...",
+      "role": "..."
+    }
+    {second role assignment}
+    ...]`)
+    .action(async (address, roleAssignment) => {
+    const contract = getDashboardContract(address);
+    if (!Array.isArray(roleAssignment)) {
+        throw new Error('the 2nd argument should be an array of role assignments');
+    }
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to grant the roles ${roleAssignment.map((i) => JSON.stringify(i))} in the vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'grantRoles',
+        payload: [roleAssignment],
+    });
+});
+dashboardWrite
+    .command('role-revoke')
+    .description('Resumes beacon chain deposits on the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<roleAssignmentJSON>', 'JSON array of role assignments', jsonToRoleAssignment)
+    .addHelpText('after', `Role assignment format:
+    [{
+      "account": "...",
+      "role": "..."
+    }
+    {second role assignment}
+    ...]`)
+    .action(async (address, roleAssignment) => {
+    const contract = getDashboardContract(address);
+    if (!Array.isArray(roleAssignment)) {
+        throw new Error('the 2nd argument should be an array of role assignments');
+    }
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to revoke the roles ${roleAssignment.map((i) => JSON.stringify(i))} in the vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'revokeRoles',
+        payload: [roleAssignment],
+    });
+});
+dashboardWrite
+    .command('compensate-disproven-predeposit')
+    .alias('compensate')
+    .description('Compensates ether of disproven validator`s predeposit from PDG to the recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<pubkey>', 'validator that was proven invalid in PDG')
+    .argument('<recipient>', 'address to receive the `PDG.PREDEPOSIT_AMOUNT`', stringToAddress)
+    .action(async (address, pubkey, recipient) => {
+    const contract = getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to compensate the disproven predeposit from the Predeposit Guarantee contract ${contract} with validator public key ${pubkey} to ${recipient}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'compensateDisprovenPredepositFromPDG',
+        payload: [pubkey, recipient],
+    });
+});
+dashboardWrite
+    .command('unguaranteed-deposit-to-beacon-chain')
+    .alias('unguaranteed-deposit')
+    .description('Withdraws ether from vault and deposits directly to provided validators bypassing the default PDG process')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<deposits>', 'array of IStakingVault.Deposit structs containing deposit data', parseDepositArray)
+    .addHelpText('after', `Deposit format:
+    '{
+      "pubkey": "...",
+      "signature": "...",
+      "amount": "...",
+      "deposit_data_root": "..."
+    }
+    {second deposit}
+    ...'`)
+    .action(async (address, deposits) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to unguaranteed deposit ${deposits.length} deposits to the beacon chain in the staking vault ${vault}?
+      Deposits: ${JSON.stringify(deposits)}`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'unguaranteedDepositToBeaconChain',
+        payload: [deposits],
+    });
+});
+dashboardWrite
+    .command('prove-unknown-validators-to-pdg')
+    .alias('prove-unknown-validators')
+    .description('Proves validators with correct vault WC if they are unknown to PDG')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<validatorIndex...>', 'index of the validator to prove')
+    .action(async (address, validatorIndexes) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const vaultContract = getStakingVaultContract(vault);
+    const pdgContract = await callReadMethod(vaultContract, 'depositor');
+    for (const validatorIndex of validatorIndexes) {
+        const packageProof = await createPDGProof(Number(validatorIndex));
+        const { proof, pubkey, childBlockTimestamp } = packageProof;
+        const confirm = await confirmOperation(`Are you sure you want to prove ${proof.length} validators to the Predeposit Guarantee contract ${pdgContract} in the staking vault ${vault}?
+      Witnesses: ${JSON.stringify(proof)}`);
+        if (!confirm)
+            return;
+        await callWriteMethodWithReceipt({
+            contract,
+            methodName: 'proveUnknownValidatorsToPDG',
+            payload: [
+                [
+                    {
+                        proof,
+                        pubkey,
+                        validatorIndex: BigInt(validatorIndex),
+                        childBlockTimestamp,
+                    },
+                ],
+            ],
+        });
+    }
+});
+dashboardWrite
+    .command('authorize-lido-vault-hub')
+    .alias('authorize-hub')
+    .description('Authorizes the Lido Vault Hub to manage the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to authorize the Lido Vault Hub to manage the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'authorizeLidoVaultHub',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('deauthorize-lido-vault-hub')
+    .alias('deauthorize-hub')
+    .description('Deauthorizes the Lido Vault Hub from managing the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to deauthorize the Lido Vault Hub from managing the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'deauthorizeLidoVaultHub',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('ossify-staking-vault')
+    .alias('ossify')
+    .description('Ossifies the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to ossify the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'ossifyStakingVault',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('set-depositor')
+    .description('Updates the address of the depositor for the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<depositor>', 'address of the new depositor')
+    .action(async (address, depositor) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to set the depositor of the staking vault ${vault} to ${depositor}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'setDepositor',
+        payload: [depositor],
+    });
+});
+dashboardWrite
+    .command('reset-locked')
+    .description('Zeroes the locked amount of the staking vault.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to reset the locked amount of the staking vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'resetLocked',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('request-tier-change')
+    .description('Requests a change of tier on the OperatorGrid.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<tier>', 'tier to change to', stringToBigInt)
+    .action(async (address, tier) => {
+    const contract = getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to request a change of tier on the OperatorGrid for the staking vault ${vault} to ${tier}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'requestTierChange',
+        payload: [tier],
+    });
+});
+dashboardWrite
+    .command('increase-accrued-rewards-adjustment')
+    .description('Increases the accrued rewards adjustment.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<amount>', 'amount to increase the accrued rewards adjustment by (in ETH)')
+    .action(async (address, amount) => {
+    const contract = getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to increase the accrued rewards adjustment by ${amount} ETH?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'increaseAccruedRewardsAdjustment',
+        payload: [parseEther(amount)],
+    });
+});
+dashboardWrite
+    .command('set-accrued-rewards-adjustment')
+    .description('Sets the accrued rewards adjustment.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<amount>', 'amount to set the accrued rewards adjustment to (in ETH)')
+    .action(async (address, amount) => {
+    const contract = getDashboardContract(address);
+    const currentAdjustment = await callReadMethod(contract, 'accruedRewardsAdjustment');
+    const confirm = await confirmOperation(`Are you sure you want to set the accrued rewards adjustment to ${amount}?
+      Current adjustment: ${formatEther(currentAdjustment)} ETH`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'setAccruedRewardsAdjustment',
+        payload: [parseEther(amount), currentAdjustment],
+    });
+});
+//# sourceMappingURL=write.js.map