Implement support for validator next-epoch proposer duties

packages/beacon-state-transition/src/cache/cachedBeaconState.ts

@@ -10,7 +10,7 @@ import {
   readonlyValues,
   TreeBacked,
 } from "@chainsafe/ssz";
-import {allForks, altair, Number64, ParticipationFlags} from "@chainsafe/lodestar-types";
+import {allForks, altair, Number64, ParticipationFlags, ValidatorIndex} from "@chainsafe/lodestar-types";
 import {createIBeaconConfig, IBeaconConfig, IChainForkConfig} from "@chainsafe/lodestar-config";
 import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {MutableVector} from "@chainsafe/persistent-ts";
@@ -20,6 +20,7 @@ import {CachedEpochParticipation, CachedEpochParticipationProxyHandler} from "./
 import {ForkName} from "@chainsafe/lodestar-params";
 import {CachedInactivityScoreList, CachedInactivityScoreListProxyHandler} from "./cachedInactivityScoreList";
 import {newFilledArray} from "../util/array";
+import {computeProposers} from "../util";
 
 /**
  * `BeaconState` with various caches
@@ -273,6 +274,22 @@ export class BeaconStateContext<T extends allForks.BeaconState> {
     ) as CachedBeaconState<T>;
   }
 
+  getState(): allForks.BeaconState {
+    return this.type.createTreeBacked(this.tree);
+  }
+
+  getNextEpochBeaconProposer(): ValidatorIndex[] {
+    const nextShuffling = this.epochCtx.nextShuffling;
+    let nextProposers = this.epochCtx.nextEpochProposers.get(nextShuffling.epoch);
+    if (!nextProposers) {
+      nextProposers = computeProposers(this.getState(), nextShuffling, this.epochCtx.effectiveBalanceIncrements);
+      // Only keep proposers for one epoch in the future, so clear before setting new value
+      this.epochCtx.nextEpochProposers.clear();
+      this.epochCtx.nextEpochProposers.set(nextShuffling.epoch, nextProposers);
+    }
+    return nextProposers;
+  }
+
   /**
    * Toggle all `MutableVector` caches to use `TransientVector`
    */

packages/beacon-state-transition/src/cache/epochContext.ts

@@ -103,6 +103,17 @@ export class EpochContext {
    * 32 x Number
    */
   proposers: ValidatorIndex[];
+
+  /**
+   * Map of Indexes of the block proposers keyed by the next epoch.
+   *
+   * We allow requesting proposal duties only one epoch in the future
+   * Note: There is a small probability that returned validators differs
+   * than what is returned when the epoch is reached.
+   *
+   * 32 x Number
+   */
+  nextEpochProposers: Map<Epoch, ValidatorIndex[]> = new Map<Epoch, ValidatorIndex[]>();
   /**
    * Shuffling of validator indexes. Immutable through the epoch, then it's replaced entirely.
    * Note: Per spec definition, shuffling will always be defined. They are never called before loadState()
@@ -474,6 +485,13 @@ export class EpochContext {
         `Requesting beacon proposer for different epoch current shuffling: ${epoch} != ${this.currentShuffling.epoch}`
       );
     }
+
+    for (const cachedEpoch of this.nextEpochProposers.keys()) {
+      // Do not keep past cached future proposal duties.
+      if (cachedEpoch <= epoch) {
+        this.nextEpochProposers.delete(cachedEpoch);
+      }
+    }
     return this.proposers[slot % SLOTS_PER_EPOCH];
   }
 

packages/beacon-state-transition/src/index.ts

@@ -24,4 +24,8 @@ export {EpochContext} from "./cache/epochContext";
 export {EpochProcess, beforeProcessEpoch} from "./cache/epochProcess";
 export {PubkeyIndexMap, Index2PubkeyCache} from "./cache/pubkeyCache";
 
-export {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsZeroed} from "./cache/effectiveBalanceIncrements";
+export {
+  EffectiveBalanceIncrements,
+  getEffectiveBalanceIncrementsZeroed,
+  getEffectiveBalanceIncrementsWithLen,
+} from "./cache/effectiveBalanceIncrements";

packages/lodestar/src/api/impl/validator/index.ts

@@ -277,16 +277,24 @@ export function getValidatorApi({chain, config, logger, metrics, network, sync}:
       const startSlot = computeStartSlotAtEpoch(epoch);
       await waitForSlot(startSlot); // Must never request for a future slot > currentSlot
 
+      const nextEpoch = chain.clock.currentEpoch + 1;
       const state = await chain.getHeadStateAtCurrentEpoch();
-
       const duties: routes.validator.ProposerDuty[] = [];
       const indexes: ValidatorIndex[] = [];
 
-      // Gather indexes to get pubkeys in batch (performance optimization)
-      for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
-        // getBeaconProposer ensures the requested epoch is correct
-        const validatorIndex = state.getBeaconProposer(startSlot + i);
-        indexes.push(validatorIndex);
+      // We allow requesting proposal duties only one epoch in the future
+      // Note: There is a small probability that returned validators differs
+      // than what is returned when the epoch is reached.
+      if (epoch === nextEpoch) {
+        indexes.push(...state.getNextEpochBeaconProposer());
+      } else {
+        // Gather indexes to get pubkeys in batch (performance optimization)
+        for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
+          // getBeaconProposer ensures the requested epoch is correct
+          // Epoch should be equal to current epoch, if not the getBeaconProposer call throws an error
+          const validatorIndex = state.getBeaconProposer(startSlot + i);
+          indexes.push(validatorIndex);
+        }
       }
 
       // NOTE: this is the fastest way of getting compressed pubkeys.

packages/lodestar/test/unit/api/impl/validator/duties/proposer.test.ts

@@ -72,8 +72,86 @@ describe("get proposers api impl", function () {
     );
     const cachedState = createCachedBeaconState(config, state);
     chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
-    sinon.stub(cachedState.epochCtx, "getBeaconProposer").returns(1);
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetBeaconProposer.returns(1);
     const {data: result} = await api.getProposerDuties(0);
-    expect(result.length).to.be.equal(SLOTS_PER_EPOCH);
+    expect(result.length).to.be.equal(SLOTS_PER_EPOCH, "result should be equals to slots per epoch");
+    expect(stubGetBeaconProposer.called, "stubGetBeaconProposer function should have been called").to.be.true;
+  });
+
+  it("should get proposers for next epoch", async function () {
+    syncStub.isSynced.returns(true);
+    server.sandbox.stub(chainStub.clock, "currentEpoch").get(() => 0);
+    server.sandbox.stub(chainStub.clock, "currentSlot").get(() => 0);
+    dbStub.block.get.resolves({message: {stateRoot: Buffer.alloc(32)}} as any);
+    const state = generateState(
+      {
+        slot: 0,
+        validators: generateValidators(25, {
+          effectiveBalance: MAX_EFFECTIVE_BALANCE,
+          activationEpoch: 0,
+          exitEpoch: FAR_FUTURE_EPOCH,
+        }),
+        balances: generateInitialMaxBalances(config, 25),
+      },
+      config
+    );
+    const cachedState = createCachedBeaconState(config, state);
+    chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetBeaconProposer.returns(1);
+    const {data: result} = await api.getProposerDuties(1);
+    expect(result.length).to.be.equal(SLOTS_PER_EPOCH, "result should be equals to slots per epoch");
+    expect(stubGetBeaconProposer.called, "stubGetBeaconProposer function should not have been called").to.be.false;
+  });
+
+  it("should have different proposer for current and next epoch", async function () {
+    syncStub.isSynced.returns(true);
+    server.sandbox.stub(chainStub.clock, "currentEpoch").get(() => 0);
+    server.sandbox.stub(chainStub.clock, "currentSlot").get(() => 0);
+    dbStub.block.get.resolves({message: {stateRoot: Buffer.alloc(32)}} as any);
+    const state = generateState(
+      {
+        slot: 0,
+        validators: generateValidators(25, {
+          effectiveBalance: MAX_EFFECTIVE_BALANCE,
+          activationEpoch: 0,
+          exitEpoch: FAR_FUTURE_EPOCH,
+        }),
+        balances: generateInitialMaxBalances(config, 25),
+      },
+      config
+    );
+    const cachedState = createCachedBeaconState(config, state);
+    chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetBeaconProposer.returns(1);
+    const {data: currentProposers} = await api.getProposerDuties(0);
+    const {data: nextProposers} = await api.getProposerDuties(1);
+    expect(currentProposers).to.not.deep.equal(nextProposers, "current proposer and next proposer should be different");
+  });
+
+  it("should not get proposers for more than one epoch in the future", async function () {
+    syncStub.isSynced.returns(true);
+    server.sandbox.stub(chainStub.clock, "currentEpoch").get(() => 0);
+    server.sandbox.stub(chainStub.clock, "currentSlot").get(() => 0);
+    dbStub.block.get.resolves({message: {stateRoot: Buffer.alloc(32)}} as any);
+    const state = generateState(
+      {
+        slot: 0,
+        validators: generateValidators(25, {
+          effectiveBalance: MAX_EFFECTIVE_BALANCE,
+          activationEpoch: 0,
+          exitEpoch: FAR_FUTURE_EPOCH,
+        }),
+        balances: generateInitialMaxBalances(config, 25),
+      },
+      config
+    );
+    const cachedState = createCachedBeaconState(config, state);
+    chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetBeaconProposer.throws();
+    expect(api.getProposerDuties(2), "calling getProposerDuties should throw").to.eventually.throws;
   });
 });