fix(PDG): don't allow proving without activation by default

Author: folkyatina

contracts/0.8.25/vaults/LazyOracle.sol

@@ -249,6 +249,10 @@ contract LazyOracle is ILazyOracle, AccessControlEnumerableUpgradeable {
         return batch;
     }
 
+    /**
+     * @notice batch method to mass check the validator stages in PredepositGuarantee contract
+     * @param _pubkeys the array of validator's pubkeys to check
+     */
     function batchValidatorStages(
         bytes[] calldata _pubkeys
     ) external view returns (IPredepositGuarantee.ValidatorStage[] memory batch) {

contracts/0.8.25/vaults/predeposit_guarantee/PredepositGuarantee.sol

@@ -199,9 +199,9 @@ contract PredepositGuarantee is IPredepositGuarantee, CLProofVerifier, PausableU
     }
 
     /**
-     * @notice returns the current amount of ether that is predeposited to a given vault
+     * @notice returns the number of validators in PREDEPOSITED and PROVEN states but not ACTIVATED yet
      * @param _vault staking vault address
-     * @return amount of ether in wei
+     * @return the number of validators yet-to-be-activated
      */
     function pendingActivations(IStakingVault _vault) external view returns (uint256) {
         return _storage().pendingActivations[address(_vault)];
@@ -420,12 +420,13 @@ contract PredepositGuarantee is IPredepositGuarantee, CLProofVerifier, PausableU
     }
 
     /**
-     * @notice permissionless method to prove correct Withdrawal Credentials for the validator
+     * @notice permissionless method to prove correct Withdrawal Credentials and activate validator if possible
      * @param _witness object containing validator pubkey, Merkle proof and timestamp for Beacon Block root child block
      * @dev will revert if proof is invalid or misformed or validator is not predeposited
-     * @dev transition PREDEPOSITED => PROVEN
+     * @dev transition PREDEPOSITED => PROVEN [=> ACTIVATED]
+     * @dev if activation is impossible, it can be done later by calling activateValidator() explicitly
      */
-    function proveWC(ValidatorWitness calldata _witness) external whenResumed {
+    function proveWCAndActivate(ValidatorWitness calldata _witness) external whenResumed {
         ValidatorStatus storage validator = _storage().validatorStatus[_witness.pubkey];
 
         if (validator.stage != ValidatorStage.PREDEPOSITED) {
@@ -434,9 +435,19 @@ contract PredepositGuarantee is IPredepositGuarantee, CLProofVerifier, PausableU
 
         IStakingVault stakingVault = validator.stakingVault;
         bytes32 withdrawalCredentials = _checkVaultWC(stakingVault);
+        address nodeOperator = validator.nodeOperator;
+
+        _proveWC(_witness, stakingVault, withdrawalCredentials, nodeOperator);
 
-        validator.stage = ValidatorStage.PROVEN;
-        _proveWC(_witness, stakingVault, withdrawalCredentials, validator.nodeOperator);
+        // activate validator if possible
+        if (stakingVault.depositor() == address(this) && stakingVault.stagedBalance() >= ACTIVATION_DEPOSIT_AMOUNT) {
+            _activateValidator(_witness.pubkey, 0, stakingVault, withdrawalCredentials, nodeOperator);
+            validator.stage = ValidatorStage.ACTIVATED;
+        } else {
+            // only if validator is disconnected
+            // because on connection we check depositor and staged balance
+            validator.stage = ValidatorStage.PROVEN;
+        }
     }
 
     /**

test/0.8.25/vaults/predepositGuarantee/predepositGuarantee.test.ts

@@ -851,27 +851,29 @@ describe("PredepositGuarantee.sol", () => {
         };
 
         // stage NONE
-        await expect(pdg.proveWC(witness))
+        await expect(pdg.proveWCAndActivate(witness))
           .to.be.revertedWithCustomError(pdg, "ValidatorNotPreDeposited")
           .withArgs(validator.container.pubkey, 0n);
 
         // stage PREDEPOSITED
         const { deposit, depositY } = await generatePredeposit(validator);
         await pdg.predeposit(stakingVault, [deposit], [depositY]);
 
-        const proveTx = await pdg.proveWC(witness);
+        const proveTx = await pdg.proveWCAndActivate(witness);
         await expect(proveTx)
           .to.emit(pdg, "BalanceUnlocked")
           .withArgs(vaultOperator.address, balance, 0)
           .to.emit(pdg, "ValidatorProven")
+          .withArgs(validator.container.pubkey, vaultOperator.address, await stakingVault.getAddress(), wc)
+          .to.emit(pdg, "ValidatorActivated")
           .withArgs(validator.container.pubkey, vaultOperator.address, await stakingVault.getAddress(), wc);
 
-        expect((await pdg.validatorStatus(validator.container.pubkey)).stage).to.equal(2n);
+        expect((await pdg.validatorStatus(validator.container.pubkey)).stage).to.equal(3n); // 3n is ACTIVATED
 
-        // stage PROVEN
-        await expect(pdg.proveWC(witness))
+        // stage ACTIVATED
+        await expect(pdg.proveWCAndActivate(witness))
           .to.be.revertedWithCustomError(pdg, "ValidatorNotPreDeposited")
-          .withArgs(validator.container.pubkey, 2n);
+          .withArgs(validator.container.pubkey, 3n); // 3n is ACTIVATED
       });
 
       it("allows NO to proveValidatorWC", async () => {
@@ -918,16 +920,18 @@ describe("PredepositGuarantee.sol", () => {
           proposerIndex: beaconBlockHeader.proposerIndex,
         };
 
-        const proveValidatorWCTX = pdg.connect(vaultOwner).proveWC(witness);
+        const proveValidatorWCTX = pdg.connect(vaultOwner).proveWCAndActivate(witness);
 
         await expect(proveValidatorWCTX)
           .to.emit(pdg, "BalanceUnlocked")
           .withArgs(vaultOperator, ether("1"), ether("0"))
           .to.emit(pdg, "ValidatorProven")
+          .withArgs(validator.container.pubkey, vaultOperator, stakingVault, vaultWC)
+          .to.emit(pdg, "ValidatorActivated")
           .withArgs(validator.container.pubkey, vaultOperator, stakingVault, vaultWC);
 
         const validatorStatus = await pdg.validatorStatus(validator.container.pubkey);
-        expect(validatorStatus.stage).to.equal(2n);
+        expect(validatorStatus.stage).to.equal(3n); // 3n is ACTIVATED
         expect(validatorStatus.stakingVault).to.equal(stakingVault);
         expect(validatorStatus.nodeOperator).to.equal(vaultOperator);
       });
@@ -1017,35 +1021,32 @@ describe("PredepositGuarantee.sol", () => {
         const sameNoProof = [...sameNoValidatorProof.proof, ...sameNoStateProof, ...beaconProof];
 
         // prove
-        await pdg.proveWC({
+        await pdg.proveWCAndActivate({
           proof: mainProof,
           pubkey: mainValidator.container.pubkey,
           validatorIndex: mainValidatorIndex,
           childBlockTimestamp: childBlockTimestamp,
           slot: beaconHeader.slot,
           proposerIndex: beaconHeader.proposerIndex,
         });
-        await pdg.activateValidator(mainValidator.container.pubkey);
 
-        await pdg.proveWC({
+        await pdg.proveWCAndActivate({
           proof: sideProof,
           pubkey: sideValidator.container.pubkey,
           validatorIndex: sideValidatorIndex,
           childBlockTimestamp: childBlockTimestamp,
           slot: beaconHeader.slot,
           proposerIndex: beaconHeader.proposerIndex,
         });
-        await pdg.activateValidator(sideValidator.container.pubkey);
 
-        await pdg.proveWC({
+        await pdg.proveWCAndActivate({
           proof: sameNoProof,
           pubkey: sameNOValidator.container.pubkey,
           validatorIndex: sameNoValidatorIndex,
           childBlockTimestamp: childBlockTimestamp,
           slot: beaconHeader.slot,
           proposerIndex: beaconHeader.proposerIndex,
         });
-        await pdg.activateValidator(sameNOValidator.container.pubkey);
 
         expect((await pdg.validatorStatus(mainValidator.container.pubkey)).stage).to.equal(3n); // 3n is ACTIVATED
         expect((await pdg.validatorStatus(sideValidator.container.pubkey)).stage).to.equal(3n); // 3n is ACTIVATED
@@ -1233,10 +1234,10 @@ describe("PredepositGuarantee.sol", () => {
         ).to.revertedWithCustomError(pdg, "WithdrawalCredentialsMatch");
 
         // proving
-        await pdg.proveWC(validNotPredepostedValidatorWitness);
+        await pdg.proveWCAndActivate(validNotPredepostedValidatorWitness);
         await expect(pdg.connect(vaultOperator).proveInvalidValidatorWC(validNotPredepostedValidatorWitness, validWC))
           .to.revertedWithCustomError(pdg, "ValidatorNotPreDeposited")
-          .withArgs(validNotPredepostedValidator.container.pubkey, 2n);
+          .withArgs(validNotPredepostedValidator.container.pubkey, 3n); // 3n is ACTIVATED
       });
 
       it("reverts when trying to prove valid validator", async () => {
@@ -1413,7 +1414,7 @@ describe("PredepositGuarantee.sol", () => {
       };
 
       await expect(pdg.predeposit(stakingVault, [], [])).to.revertedWithCustomError(pdg, "ResumedExpected");
-      await expect(pdg.proveWC(witness)).to.revertedWithCustomError(pdg, "ResumedExpected");
+      await expect(pdg.proveWCAndActivate(witness)).to.revertedWithCustomError(pdg, "ResumedExpected");
       await expect(pdg.activateValidator(witness.pubkey)).to.revertedWithCustomError(pdg, "ResumedExpected");
       await expect(pdg.topUpExistingValidators([])).to.revertedWithCustomError(pdg, "ResumedExpected");
       await expect(pdg.proveWCActivateAndTopUpValidators([], [])).to.revertedWithCustomError(pdg, "ResumedExpected");