@lidofinance/lsv-cli 1.0.0-alpha.61 → 1.0.0-alpha.63

package/dist/programs/contracts/dashboard/write.js

@@ -1,9 +1,8 @@
 import { parseEther, formatEther } from 'viem';
 import { Option } from 'commander';
-import { getAccount } from '../../../providers/index.js';
-import { getDashboardContract, getStakingVaultContract } from '../../../contracts/index.js';
-import { mintShares, burnShares, mintSteth, burnSteth, checkIsReportFresh, } from '../../../features/index.js';
-import { callReadMethod, callWriteMethodWithReceipt, jsonToRoleAssignment, confirmOperation, stringToBigInt, parseDepositArray, logInfo, getCommandsJson, stringToAddress, createPDGProof, confirmProposal, formatBP, callReadMethodSilent, showSpinner, stringToBigIntArrayWei, stringToHexArray, etherToWei, } from '../../../utils/index.js';
+import { getDashboardContract, getOperatorGridContract, getStakingVaultContract, } from '../../../contracts/index.js';
+import { mintShares, burnShares, mintSteth, burnSteth, checkIsReportFresh, checkBLSDeposits, } from '../../../features/index.js';
+import { callReadMethod, callWriteMethodWithReceipt, jsonToRoleAssignment, confirmOperation, stringToBigInt, parseDepositArray, logInfo, getCommandsJson, stringToAddress, createPDGProof, confirmProposal, formatBP, callReadMethodSilent, showSpinner, stringToBigIntArrayWei, stringToHexArray, etherToWei, stringToNumber, } from '../../../utils/index.js';
 import { dashboard } from './main.js';
 const dashboardWrite = dashboard
     .command('write')
@@ -21,7 +20,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<newOwner>', 'address of the new owner', stringToAddress)
     .action(async (address, newOwner) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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)
@@ -37,11 +36,14 @@ dashboardWrite
     .description('disconnects the staking vault from the vault hub')
     .argument('<address>', 'dashboard address', stringToAddress)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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;
+    const isReportFresh = await checkIsReportFresh(vault);
+    if (!isReportFresh)
+        return;
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'voluntaryDisconnect',
@@ -54,7 +56,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<ether>', 'amount of ether to be funded (in ETH)')
     .action(async (address, ether) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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)
@@ -73,7 +75,7 @@ dashboardWrite
     .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 contract = await 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)
@@ -93,7 +95,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<validatorPubKey>', 'public key of the validator to exit')
     .action(async (address, validatorPubKey) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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)
@@ -113,9 +115,9 @@ dashboardWrite
     .argument('<recipient>', 'address of the recipient', stringToAddress)
     .action(async (address, pubkeys, amounts, recipient) => {
     const mergedPubkeys = pubkeys.join('');
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
-    const vaultContract = getStakingVaultContract(vault);
+    const vaultContract = await getStakingVaultContract(vault);
     const fee = await callReadMethod(vaultContract, 'calculateValidatorWithdrawalFee', [BigInt(amounts.length)]);
     const confirmationMessage = `Are you sure you want to trigger the withdrawal of the validators 
       ${pubkeys.join(', ')} 
@@ -124,10 +126,11 @@ dashboardWrite
     const confirm = await confirmOperation(confirmationMessage);
     if (!confirm)
         return;
+    const gweiAmounts = amounts.map((amount) => parseEther(formatEther(amount), 'gwei'));
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'triggerValidatorWithdrawals',
-        payload: [mergedPubkeys, amounts.map(BigInt), recipient],
+        payload: [mergedPubkeys, gweiAmounts, recipient],
         value: fee,
     });
 });
@@ -139,7 +142,7 @@ dashboardWrite
     .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);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await mintShares(contract, recipient, parseEther(amountOfShares), vault, 'mintShares');
 });
@@ -150,7 +153,7 @@ dashboardWrite
     .argument('<recipient>', 'address of the recipient', stringToAddress)
     .argument('<amountOfSteth>', 'amount of stETH to mint')
     .action(async (address, recipient, amountOfSteth) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await mintSteth(contract, recipient, parseEther(amountOfSteth), vault);
 });
@@ -161,7 +164,7 @@ dashboardWrite
     .argument('<recipient>', 'address of the recipient', stringToAddress)
     .argument('<amountOfWsteth>', 'amount of wstETH to mint')
     .action(async (address, recipient, amountOfWsteth) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await mintShares(contract, recipient, parseEther(amountOfWsteth), vault, 'mintWstETH');
 });
@@ -172,7 +175,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<amountOfShares>', 'amount of shares to burn (in Shares)')
     .action(async (address, amountOfShares) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await burnShares(contract, parseEther(amountOfShares), vault, 'burnShares');
 });
@@ -182,7 +185,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<amountOfShares>', 'amount of shares to burn (in stETH)')
     .action(async (address, amountOfShares) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await burnSteth(contract, parseEther(amountOfShares), vault);
 });
@@ -192,7 +195,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<tokens>', 'amount of wstETH tokens to burn (in wstETH)')
     .action(async (address, tokens) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     await burnShares(contract, parseEther(tokens), vault, 'burnWstETH');
 });
@@ -202,15 +205,16 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<ether>', 'amount of ether to rebalance (in ETH)', etherToWei)
     .action(async (address, ether) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
-    const confirm = await confirmOperation(`Are you sure you want to rebalance the vault ${vault} with ${formatEther(ether)} ether?`);
+    const confirm = await confirmOperation(`Are you sure you want to rebalance the vault ${vault} with ${formatEther(ether)} ether by transferring?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'rebalanceVaultWithEther',
         payload: [ether],
+        value: ether,
     });
 });
 dashboardWrite
@@ -219,7 +223,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<shares>', 'amount of shares to rebalance (in shares)', etherToWei)
     .action(async (address, shares) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     const confirm = await confirmOperation(`Are you sure you want to rebalance the vault ${vault} with ${formatEther(shares)} shares?`);
     if (!confirm)
@@ -232,38 +236,38 @@ dashboardWrite
 });
 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}?`);
+    .description('recovers ERC20 tokens or ether from the dashboard contract to the recipient')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<token>', 'address of the token to recover or 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee for ether (EIP-7528)', stringToAddress)
+    .argument('<amount>', 'amount of tokens or ether to recover (in ETH)', etherToWei)
+    .argument('<recipient>', 'address of the recovery recipient', stringToAddress)
+    .action(async (address, token, amount, recipient) => {
+    const contract = await getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to recover the token ${token} with amount ${formatEther(amount)} from the dashboard contract ${address} to ${recipient}?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'recoverERC20',
-        payload: [token, recipient, parseEther(amount)],
+        payload: [token, recipient, amount],
     });
 });
 dashboardWrite
-    .command('recover-erc721')
-    .description('Transfers a given token_id of an ERC721-compatible NFT (defined by the token contract address)')
+    .command('collect-erc20-from-vault')
+    .description('collects ERC20 tokens from vault contract balance to the recipient')
     .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}?`);
+    .argument('<token>', 'address of the token to recover or 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee for ether (EIP-7528)', stringToAddress)
+    .argument('<amount>', 'amount of tokens or ether to recover (in ETH)', etherToWei)
+    .argument('<recipient>', 'address of the recovery recipient', stringToAddress)
+    .action(async (address, token, amount, recipient) => {
+    const contract = await getDashboardContract(address);
+    const confirm = await confirmOperation(`Are you sure you want to recover the token ${token} with amount ${formatEther(amount)} from the dashboard contract ${address} to ${recipient}?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
-        methodName: 'recoverERC721',
-        payload: [token, BigInt(tokenId), recipient],
+        methodName: 'collectERC20FromVault',
+        payload: [token, recipient, amount],
     });
 });
 dashboardWrite
@@ -271,7 +275,7 @@ dashboardWrite
     .description('Pauses beacon chain deposits on the staking vault.')
     .argument('<address>', 'dashboard address', stringToAddress)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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)
@@ -284,10 +288,10 @@ dashboardWrite
 });
 dashboardWrite
     .command('deposit-resume')
-    .description('Mass-grants multiple roles to multiple accounts.')
+    .description('resumes deposits to beacon chain')
     .argument('<address>', 'dashboard address', stringToAddress)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
+    const contract = await 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)
@@ -300,7 +304,7 @@ dashboardWrite
 });
 dashboardWrite
     .command('role-grant')
-    .description('Mass-revokes multiple roles from multiple accounts.')
+    .description('mass-grants multiple roles to multiple accounts.')
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<roleAssignmentJSON>', 'JSON array of role assignments', jsonToRoleAssignment)
     .addHelpText('after', `Role assignment format:
@@ -311,7 +315,7 @@ dashboardWrite
     {second role assignment}
     ...]`)
     .action(async (address, roleAssignment) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     if (!Array.isArray(roleAssignment)) {
         throw new Error('the 2nd argument should be an array of role assignments');
     }
@@ -327,7 +331,7 @@ dashboardWrite
 });
 dashboardWrite
     .command('role-revoke')
-    .description('Resumes beacon chain deposits on the staking vault.')
+    .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:
@@ -338,7 +342,7 @@ dashboardWrite
     {second role assignment}
     ...]`)
     .action(async (address, roleAssignment) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     if (!Array.isArray(roleAssignment)) {
         throw new Error('the 2nd argument should be an array of role assignments');
     }
@@ -352,31 +356,14 @@ dashboardWrite
         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')
+    .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:
+    .option('--no-bls-check', 'skip bls signature check')
+    .addHelpText('after', `Deposit format (amount are in gwei):
     '[{
       "pubkey": "...",
       "signature": "...",
@@ -385,13 +372,16 @@ dashboardWrite
     }
     {second deposit}
     ...]'`)
-    .action(async (address, deposits) => {
-    const contract = getDashboardContract(address);
+    .action(async (address, deposits, { blsCheck }) => {
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
+    const vaultContract = await getStakingVaultContract(vault);
     const confirm = await confirmOperation(`Are you sure you want to unguaranteed deposit ${deposits.length} deposits to the beacon chain in the staking vault ${vault}?
       Pubkeys: ${deposits.map((i) => i.pubkey).join(', ')}`);
     if (!confirm)
         return;
+    if (blsCheck)
+        await checkBLSDeposits(vaultContract, deposits);
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'unguaranteedDepositToBeaconChain',
@@ -401,23 +391,19 @@ dashboardWrite
 dashboardWrite
     .command('prove-unknown-validators-to-pdg')
     .alias('prove-unknown-validators')
-    .description('Proves validators with correct vault WC if they are unknown to PDG')
+    .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 account = await getAccount();
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
-    const vaultContract = getStakingVaultContract(vault);
+    const vaultContract = await getStakingVaultContract(vault);
     const pdgContract = await callReadMethodSilent(vaultContract, 'depositor');
     const payload = [];
-    const PDG_PROVE_VALIDATOR_ROLE = await callReadMethodSilent(contract, 'PDG_PROVE_VALIDATOR_ROLE');
-    const hasRole = await callReadMethodSilent(contract, 'hasRole', [
-        PDG_PROVE_VALIDATOR_ROLE,
-        account.address,
-    ]);
-    if (!hasRole) {
-        throw new Error(`You do not have role (PDG_PROVE_VALIDATOR_ROLE - ${PDG_PROVE_VALIDATOR_ROLE}) to prove validators to PDG`);
+    const pdgPolicy = await callReadMethodSilent(contract, 'pdgPolicy');
+    const isAllowed = pdgPolicy === 2;
+    if (!isAllowed) {
+        throw new Error(`Dashboard PDG policy is not set to allow proving unknown validators to PDG`);
     }
     for (const validatorIndex of validatorIndexes) {
         const hideSpinner = showSpinner({
@@ -454,7 +440,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<newOwner>', 'new owner address', stringToAddress)
     .action(async (address, newOwner) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
     const confirm = await confirmOperation(`Are you sure you want to abandon the dashboard ${address} (vault: ${vault})?`);
     if (!confirm)
@@ -468,12 +454,15 @@ dashboardWrite
 dashboardWrite
     .command('connect-to-vault-hub')
     .alias('connect-hub')
-    .description('connects to VaultHub, transferring ownership to VaultHub.')
+    .description('connects to VaultHub, transferring underlying StakingVault ownership to VaultHub.')
     .argument('<address>', 'dashboard address', stringToAddress)
+    .addHelpText('after', `Reverts if settledGrowth is not corrected after the vault is disconnected`)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
-    const confirm = await confirmOperation(`Are you sure you want to connect the dashboard ${address} (vault: ${vault}) to VaultHub?`);
+    const currentSettledGrowth = await callReadMethodSilent(contract, 'settledGrowth');
+    const confirm = await confirmOperation(`Are you sure you want to connect the dashboard ${address} (vault: ${vault}) to VaultHub?
+      Current settled growth: ${formatEther(currentSettledGrowth)}`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
@@ -487,10 +476,13 @@ dashboardWrite
     .alias('reconnect-hub')
     .description('accepts the ownership over the StakingVault and connects to VaultHub. Can be called to reconnect to the hub after voluntaryDisconnect()')
     .argument('<address>', 'dashboard address', stringToAddress)
+    .addHelpText('after', `Reverts if settledGrowth is not corrected after the vault is disconnected`)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
-    const confirm = await confirmOperation(`Are you sure you want to reconnect the dashboard ${address} (vault: ${vault}) to VaultHub?`);
+    const currentSettledGrowth = await callReadMethodSilent(contract, 'settledGrowth');
+    const confirm = await confirmOperation(`Are you sure you want to reconnect the dashboard ${address} (vault: ${vault}) to VaultHub?
+      Current settled growth: ${formatEther(currentSettledGrowth)}`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
@@ -506,51 +498,47 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<tier>', 'tier to change to', stringToBigInt)
     .argument('<requestedShareLimit>', 'requested new share limit for the vault (in shares)', etherToWei)
-    .action(async (address, tier, requestedShareLimit) => {
-    const contract = getDashboardContract(address);
+    .option('-f, --fund', 'optional fund the vault with 1 ETH', false)
+    .addHelpText('after', `Reverts if settledGrowth is not corrected after the vault is disconnected`)
+    .action(async (address, tier, requestedShareLimit, { fund }) => {
+    const contract = await getDashboardContract(address);
     const vault = await callReadMethod(contract, 'stakingVault');
+    const currentSettledGrowth = await callReadMethodSilent(contract, 'settledGrowth');
     const confirm = await confirmOperation(`Are you sure you want to change the tier of the vault ${vault} to ${tier} and connect to VaultHub?
-        Requested share limit: ${formatEther(requestedShareLimit)}`);
+        Requested share limit: ${formatEther(requestedShareLimit)}
+        Current settled growth: ${formatEther(currentSettledGrowth)}`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
         methodName: 'connectAndAcceptTier',
         payload: [tier, requestedShareLimit],
+        value: fund ? parseEther('1') : undefined,
     });
 });
 dashboardWrite
-    .command('increase-rewards-adjustment')
-    .description('increases rewards adjustment to correct fee calculation due to non-rewards ether on CL')
-    .argument('<address>', 'dashboard address', stringToAddress)
-    .argument('<amount>', 'amount to increase the rewards adjustment by (in ETH)', etherToWei)
-    .action(async (address, amount) => {
-    const contract = getDashboardContract(address);
-    const confirm = await confirmOperation(`Are you sure you want to increase the rewards adjustment by ${formatEther(amount)} ETH?`);
-    if (!confirm)
-        return;
-    await callWriteMethodWithReceipt({
-        contract,
-        methodName: 'increaseRewardsAdjustment',
-        payload: [amount],
-    });
-});
-dashboardWrite
-    .command('set-rewards-adjustment')
-    .description('set `rewardsAdjustment` to a new proposed value if `confirmingRoles()` agree')
-    .argument('<address>', 'dashboard address', stringToAddress)
-    .argument('<amount>', 'amount to set the accrued rewards adjustment to (in ETH)', etherToWei)
-    .action(async (address, amount) => {
-    const contract = getDashboardContract(address);
-    const currentAdjustment = await callReadMethod(contract, 'rewardsAdjustment');
-    const confirm = await confirmOperation(`Are you sure you want to set the rewards adjustment to ${formatEther(amount)} ETH?
-      Current adjustment: ${formatEther(currentAdjustment[0])} ETH`);
+    .command('set-pdg-policy')
+    .description('set the PDG policy')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<policy>', 'policy to set the PDG policy to', stringToNumber)
+    .addHelpText('after', `Policy values:
+    0: STRICT
+    1: ALLOW_PROVE
+    2: ALLOW_DEPOSIT_AND_PROVE`)
+    .action(async (address, policy) => {
+    const contract = await getDashboardContract(address);
+    const PDG_POLICY = {
+        0: 'STRICT',
+        1: 'ALLOW_PROVE',
+        2: 'ALLOW_DEPOSIT_AND_PROVE',
+    };
+    const confirm = await confirmOperation(`Are you sure you want to set the PDG policy to ${policy} (${PDG_POLICY[policy]})?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
-        methodName: 'setRewardsAdjustment',
-        payload: [amount, currentAdjustment[0]],
+        methodName: 'setPDGPolicy',
+        payload: [policy],
     });
 });
 dashboardWrite
@@ -560,13 +548,13 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<recipient>', 'address of the new node operator fee recipient', stringToAddress)
     .action(async (address, recipient) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const confirm = await confirmOperation(`Are you sure you want to set the node operator fee recipient to ${recipient}?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
-        methodName: 'setNodeOperatorFeeRecipient',
+        methodName: 'setFeeRecipient',
         payload: [recipient],
     });
 });
@@ -575,14 +563,26 @@ dashboardWrite
     .description('Confirms a proposal')
     .argument('<address>', 'dashboard address', stringToAddress)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
-    const log = await confirmProposal(contract);
+    const contract = await getDashboardContract(address);
+    const vault = await callReadMethodSilent(contract, 'stakingVault');
+    const operatorGridContract = await getOperatorGridContract();
+    const log = await confirmProposal({
+        contract: contract,
+        vault,
+        additionalContracts: [operatorGridContract],
+    });
     if (!log)
         return;
+    const isChangeTier = log.decodedData.functionName === 'changeTier';
+    // ChangeTier event from OperatorGrid has 3 args (vault, tierId, shareLimit), but we need only 2 (tierId, shareLimit)
+    let args = log.decodedData.args;
+    if (isChangeTier && args && args.length === 3) {
+        args = [args[1], args[2]];
+    }
     await callWriteMethodWithReceipt({
         contract,
         methodName: log.decodedData.functionName,
-        payload: log.decodedData.args,
+        payload: args,
     });
 });
 dashboardWrite
@@ -591,7 +591,7 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<expiry>', 'expiry in seconds', stringToBigInt)
     .action(async (address, expiry) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const hours = Number(expiry) / 3600;
     const confirm = await confirmOperation(`Are you sure you want to set the confirm expiry to ${expiry} seconds (${hours} hours)?`);
     if (!confirm)
@@ -608,14 +608,14 @@ dashboardWrite
     .argument('<address>', 'dashboard address', stringToAddress)
     .argument('<fee>', 'the new node operator fee rate in basis points', stringToBigInt)
     .action(async (address, fee) => {
-    const contract = getDashboardContract(address);
+    const contract = await getDashboardContract(address);
     const percentage = formatBP(fee);
     const confirm = await confirmOperation(`Are you sure you want to set the node operator fee ${fee} in basis points (${percentage})?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
-        methodName: 'setNodeOperatorFeeRate',
+        methodName: 'setFeeRate',
         payload: [fee],
     });
 });
@@ -624,14 +624,123 @@ dashboardWrite
     .description('transfers the node-operator`s accrued fee (if any) to nodeOperatorFeeRecipient')
     .argument('<address>', 'dashboard address', stringToAddress)
     .action(async (address) => {
-    const contract = getDashboardContract(address);
-    const nodeOperatorFeeRecipient = await callReadMethodSilent(contract, 'nodeOperatorFeeRecipient');
+    const contract = await getDashboardContract(address);
+    const nodeOperatorFeeRecipient = await callReadMethodSilent(contract, 'feeRecipient');
     const confirm = await confirmOperation(`Are you sure you want to transfer the node operator fee to ${nodeOperatorFeeRecipient}?`);
     if (!confirm)
         return;
     await callWriteMethodWithReceipt({
         contract,
-        methodName: 'disburseNodeOperatorFee',
+        methodName: 'disburseFee',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('change-tier')
+    .alias('ct')
+    .description('vault tier change with multi-role confirmation')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<tierId>', 'tier id', stringToBigInt)
+    .argument('<requestedShareLimit>', 'requested share limit (in shares)', etherToWei)
+    .action(async (address, tierId, requestedShareLimit) => {
+    const contract = await getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to change the current tier to tier ID ${tierId} for vault ${vault} with share limit ${formatEther(requestedShareLimit)} shares?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'changeTier',
+        payload: [tierId, requestedShareLimit],
+    });
+});
+dashboardWrite
+    .command('sync-tier')
+    .alias('st')
+    .description('requests a sync of tier on the OperatorGrid')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .addHelpText('after', `Tier sync confirmation logic:
+     - Both vault owner (via this function) AND node operator confirmations are required
+     - First call returns false (pending), second call with both confirmations completes the sync
+     - Confirmations expire after the configured period (default: 1 day)`)
+    .action(async (address) => {
+    const contract = await getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to sync the tier of the vault ${vault}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'syncTier',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('update-share-limit')
+    .alias('usl')
+    .description('requests a change of share limit on the OperatorGrid')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<shareLimit>', 'share limit', etherToWei)
+    .action(async (address, shareLimit) => {
+    const contract = await getDashboardContract(address);
+    const vault = await callReadMethod(contract, 'stakingVault');
+    const confirm = await confirmOperation(`Are you sure you want to request a change of share limit on the OperatorGrid for the vault ${vault} to ${formatEther(shareLimit)}?`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'updateShareLimit',
+        payload: [shareLimit],
+    });
+});
+dashboardWrite
+    .command('disburse-abnormally-high-fee')
+    .description('Disburses an abnormally high fee as `DEFAULT_ADMIN_ROLE`. Before calling this function, the caller must ensure that the high fee is expected, and the settled growth (used as baseline for fee) is set correctly.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = await getDashboardContract(address);
+    const confirm = await confirmOperation('Are you sure you want to disburse an abnormally high fee as `DEFAULT_ADMIN_ROLE`?');
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'disburseAbnormallyHighFee',
+        payload: [],
+    });
+});
+dashboardWrite
+    .command('correct-settled-growth')
+    .description('Manually corrects the settled growth value with dual confirmation.')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .argument('<newSettledGrowth>', 'new settled growth', etherToWei)
+    .action(async (address, newSettledGrowth) => {
+    const contract = await getDashboardContract(address);
+    const currentSettledGrowth = await callReadMethodSilent(contract, 'settledGrowth');
+    const confirm = await confirmOperation(`Are you sure you want to correct the settled growth to ${newSettledGrowth}?
+      Current settled growth: ${formatEther(currentSettledGrowth)}`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'correctSettledGrowth',
+        payload: [newSettledGrowth, currentSettledGrowth],
+    });
+});
+dashboardWrite
+    .command('recover-fee-leftover')
+    .alias('rfl')
+    .description('Recovers the previously collected fees to the feeRecipient address')
+    .argument('<address>', 'dashboard address', stringToAddress)
+    .action(async (address) => {
+    const contract = await getDashboardContract(address);
+    const feeLeftover = await callReadMethodSilent(contract, 'feeLeftover');
+    const confirm = await confirmOperation(`Are you sure you want to recover the fee leftover from the dashboard contract ${address}?
+      Fee leftover: ${formatEther(feeLeftover)}`);
+    if (!confirm)
+        return;
+    await callWriteMethodWithReceipt({
+        contract,
+        methodName: 'recoverFeeLeftover',
         payload: [],
     });
 });