Implement support for validator next-epoch proposer duties

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

@@ -3,6 +3,7 @@ import {BLSSignature, CommitteeIndex, Epoch, Slot, ValidatorIndex, phase0, SyncP
 import {createIBeaconConfig, IBeaconConfig, IChainConfig} from "@chainsafe/lodestar-config";
 import {
   ATTESTATION_SUBNET_COUNT,
+  DOMAIN_BEACON_PROPOSER,
   EFFECTIVE_BALANCE_INCREMENT,
   FAR_FUTURE_EPOCH,
   GENESIS_EPOCH,
@@ -18,8 +19,9 @@ import {
   getChurnLimit,
   isActiveValidator,
   isAggregatorFromCommitteeLength,
-  computeProposers,
   computeSyncPeriodAtEpoch,
+  getSeed,
+  computeProposers,
 } from "../util";
 import {computeEpochShuffling, IEpochShuffling} from "../util/epochShuffling";
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements";
@@ -95,6 +97,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()
@@ -150,6 +163,9 @@ export class EpochContext {
   epoch: Epoch;
   syncPeriod: SyncPeriod;
 
+  currentProposerSeed: Uint8Array;
+  nextProposerSeed: Uint8Array;
+
   constructor(data: {
     config: IBeaconConfig;
     pubkey2index: PubkeyIndexMap;
@@ -170,6 +186,8 @@ export class EpochContext {
     nextSyncCommitteeIndexed: SyncCommitteeCache;
     epoch: Epoch;
     syncPeriod: SyncPeriod;
+    currentProposerSeed: Uint8Array;
+    nextProposerSeed: Uint8Array;
   }) {
     this.config = data.config;
     this.pubkey2index = data.pubkey2index;
@@ -190,6 +208,8 @@ export class EpochContext {
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
+    this.currentProposerSeed = data.currentProposerSeed;
+    this.nextProposerSeed = data.nextProposerSeed;
   }
 
   /**
@@ -269,9 +289,14 @@ export class EpochContext {
       : computeEpochShuffling(state, previousActiveIndices, previousEpoch);
     const nextShuffling = computeEpochShuffling(state, nextActiveIndices, nextEpoch);
 
+    const currentProposerSeed = getSeed(state, currentShuffling.epoch, DOMAIN_BEACON_PROPOSER);
+    const nextProposerSeed = getSeed(state, nextShuffling.epoch, DOMAIN_BEACON_PROPOSER);
+
     // Allow to create CachedBeaconState for empty states
     const proposers =
-      state.validators.length > 0 ? computeProposers(state, currentShuffling, effectiveBalanceIncrements) : [];
+      state.validators.length > 0
+        ? computeProposers(currentProposerSeed, currentShuffling, effectiveBalanceIncrements)
+        : [];
 
     // Only after altair, compute the indices of the current sync committee
     const afterAltairFork = currentEpoch >= config.ALTAIR_FORK_EPOCH;
@@ -334,6 +359,8 @@ export class EpochContext {
       nextSyncCommitteeIndexed,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
+      currentProposerSeed,
+      nextProposerSeed,
     });
   }
 
@@ -369,6 +396,8 @@ export class EpochContext {
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
+      currentProposerSeed: this.currentProposerSeed,
+      nextProposerSeed: this.nextProposerSeed,
     });
   }
 
@@ -389,7 +418,10 @@ export class EpochContext {
     const nextEpoch = currEpoch + 1;
 
     this.nextShuffling = computeEpochShuffling(state, epochProcess.nextEpochShufflingActiveValidatorIndices, nextEpoch);
-    this.proposers = computeProposers(state, this.currentShuffling, this.effectiveBalanceIncrements);
+    this.currentProposerSeed = getSeed(state, this.currentShuffling.epoch, DOMAIN_BEACON_PROPOSER);
+    this.nextProposerSeed = getSeed(state, this.nextShuffling.epoch, DOMAIN_BEACON_PROPOSER);
+
+    this.proposers = computeProposers(this.currentProposerSeed, this.currentShuffling, this.effectiveBalanceIncrements);
 
     // TODO: DEDUPLICATE from createEpochContext
     //
@@ -467,6 +499,18 @@ export class EpochContext {
     return (committeesSinceEpochStart + committeeIndex) % ATTESTATION_SUBNET_COUNT;
   }
 
+  getNextEpochBeaconProposer(): ValidatorIndex[] {
+    const nextShuffling = this.nextShuffling;
+    let nextProposers = this.nextEpochProposers.get(nextShuffling.epoch);
+    if (!nextProposers) {
+      nextProposers = computeProposers(this.nextProposerSeed, nextShuffling, this.effectiveBalanceIncrements);
+      // Only keep proposers for one epoch in the future, so clear before setting new value
+      this.nextEpochProposers.clear();
+      this.nextEpochProposers.set(nextShuffling.epoch, nextProposers);
+    }
+    return nextProposers;
+  }
+
   getBeaconProposer(slot: Slot): ValidatorIndex {
     const epoch = computeEpochAtSlot(slot);
     if (epoch !== this.currentShuffling.epoch) {

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

@@ -30,4 +30,9 @@ export {EpochProcess, beforeProcessEpoch} from "./cache/epochProcess";
 
 // Aux data-structures
 export {PubkeyIndexMap, Index2PubkeyCache} from "./cache/pubkeyCache";
-export {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsZeroed} from "./cache/effectiveBalanceIncrements";
+
+export {
+  EffectiveBalanceIncrements,
+  getEffectiveBalanceIncrementsZeroed,
+  getEffectiveBalanceIncrementsWithLen,
+} from "./cache/effectiveBalanceIncrements";

packages/beacon-state-transition/src/util/seed.ts

@@ -6,7 +6,6 @@ import {digest} from "@chainsafe/as-sha256";
 import {Epoch, Bytes32, DomainType, ValidatorIndex} from "@chainsafe/lodestar-types";
 import {assert, bytesToBigInt, intToBytes} from "@chainsafe/lodestar-utils";
 import {
-  DOMAIN_BEACON_PROPOSER,
   DOMAIN_SYNC_COMMITTEE,
   EFFECTIVE_BALANCE_INCREMENT,
   EPOCHS_PER_HISTORICAL_VECTOR,
@@ -25,11 +24,10 @@ import {computeEpochAtSlot} from "./epoch";
  * Compute proposer indices for an epoch
  */
 export function computeProposers(
-  state: BeaconStateAllForks,
+  epochSeed: Uint8Array,
   shuffling: {epoch: Epoch; activeIndices: ValidatorIndex[]},
   effectiveBalanceIncrements: EffectiveBalanceIncrements
 ): number[] {
-  const epochSeed = getSeed(state, shuffling.epoch, DOMAIN_BEACON_PROPOSER);
   const startSlot = computeStartSlotAtEpoch(shuffling.epoch);
   const proposers = [];
   for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {

packages/beacon-state-transition/test/perf/allForks/util/shufflings.test.ts

@@ -1,13 +1,15 @@
 import {itBench} from "@dapplion/benchmark";
 import {Epoch} from "@chainsafe/lodestar-types";
+import {DOMAIN_BEACON_PROPOSER} from "@chainsafe/lodestar-params";
 import {
   computeEpochAtSlot,
   CachedBeaconStateAllForks,
   computeEpochShuffling,
   getNextSyncCommittee,
 } from "../../../../src";
+import {computeProposers} from "../../../../src";
+import {getSeed} from "../../../../lib";
 import {generatePerfTestCachedStatePhase0, numValidators} from "../../util";
-import {computeProposers} from "../../../../src/util/seed";
 
 describe("epoch shufflings", () => {
   let state: CachedBeaconStateAllForks;
@@ -25,7 +27,8 @@ describe("epoch shufflings", () => {
   itBench({
     id: `computeProposers - vc ${numValidators}`,
     fn: () => {
-      computeProposers(state, state.epochCtx.nextShuffling, state.epochCtx.effectiveBalanceIncrements);
+      const epochSeed = getSeed(state, state.epochCtx.nextShuffling.epoch, DOMAIN_BEACON_PROPOSER);
+      computeProposers(epochSeed, state.epochCtx.nextShuffling, state.epochCtx.effectiveBalanceIncrements);
     },
   });
 

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

@@ -276,16 +276,23 @@ 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.epochCtx.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.epochCtx.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
+          const validatorIndex = state.epochCtx.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

@@ -71,8 +71,91 @@ describe("get proposers api impl", function () {
     );
     const cachedState = createCachedBeaconStateTest(state, config);
     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: Array.from({length: 25}, () => MAX_EFFECTIVE_BALANCE),
+      },
+      config
+    );
+
+    const cachedState = createCachedBeaconStateTest(state, config);
+    chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
+    const stubGetNextBeaconProposer = sinon.stub(cachedState.epochCtx, "getNextEpochBeaconProposer");
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetNextBeaconProposer.returns([1]);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const {data: result} = await api.getProposerDuties(1);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    expect(result.length).to.be.equal(SLOTS_PER_EPOCH, "result should be equals to slots per epoch");
+    expect(stubGetNextBeaconProposer.called, "stubGetBeaconProposer function should not have been called").to.be.true;
+    expect(stubGetBeaconProposer.called, "stubGetBeaconProposer function should 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: Array.from({length: 25}, () => MAX_EFFECTIVE_BALANCE),
+      },
+      config
+    );
+    const cachedState = createCachedBeaconStateTest(state, config);
+    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: Array.from({length: 25}, () => MAX_EFFECTIVE_BALANCE),
+      },
+      config
+    );
+    const cachedState = createCachedBeaconStateTest(state, config);
+    chainStub.getHeadStateAtCurrentEpoch.resolves(cachedState);
+    const stubGetBeaconProposer = sinon.stub(cachedState.epochCtx, "getBeaconProposer");
+    stubGetBeaconProposer.throws();
+    expect(api.getProposerDuties(2), "calling getProposerDuties should throw").to.eventually.throws;
   });
 });