Altair 1.1.0-alpha.5 - Beacon Chain

packages/beacon-state-transition/src/allForks/block/processBlockHeader.ts

@@ -1,4 +1,5 @@
 import {allForks} from "@chainsafe/lodestar-types";
+import {toHexString} from "@chainsafe/ssz";
 import {CachedBeaconState} from "../util";
 
 export function processBlockHeader(state: CachedBeaconState<allForks.BeaconState>, block: allForks.BeaconBlock): void {
@@ -31,7 +32,9 @@ export function processBlockHeader(state: CachedBeaconState<allForks.BeaconState
       state.config.types.phase0.BeaconBlockHeader.hashTreeRoot(state.latestBlockHeader)
     )
   ) {
-    throw new Error("Block parent root does not match state latest block");
+    throw new Error(
+      `Block parent root ${toHexString(block.parentRoot)} does not match state latest block, block slot=${slot}`
+    );
   }
   // cache current block as the new latest block
   state.latestBlockHeader = {

packages/beacon-state-transition/src/allForks/util/epochContext.ts

@@ -1,4 +1,4 @@
-import {ByteVector, hash, toHexString, BitList, List, readonlyValues} from "@chainsafe/ssz";
+import {ByteVector, hash, toHexString, BitList, List, isTreeBacked, TreeBacked} from "@chainsafe/ssz";
 import bls, {CoordType, PublicKey} from "@chainsafe/bls";
 import {
   BLSSignature,
@@ -19,10 +19,10 @@ import {
   computeEpochAtSlot,
   computeProposerIndex,
   computeStartSlotAtEpoch,
-  getAttestingIndicesFromCommittee,
   getSeed,
   getTotalActiveBalance,
   isAggregatorFromCommitteeLength,
+  zipIndexesInBitList,
 } from "../../util";
 import {getNextSyncCommitteeIndices} from "../../altair/state_accessor/sync_committee";
 import {computeEpochShuffling, IEpochShuffling} from "./epochShuffling";
@@ -373,16 +373,15 @@ export class EpochContext {
    * Return the indexed attestation corresponding to ``attestation``.
    */
   getIndexedAttestation(attestation: phase0.Attestation): phase0.IndexedAttestation {
-    const data = attestation.data;
-    const bits = Array.from(readonlyValues(attestation.aggregationBits));
-    const committee = this.getBeaconCommittee(data.slot, data.index);
-    // No need for a Set, the indices in the committee are already unique.
-    const attestingIndices: ValidatorIndex[] = [];
-    for (const [i, index] of committee.entries()) {
-      if (bits[i]) {
-        attestingIndices.push(index);
-      }
-    }
+    const {aggregationBits, data} = attestation;
+    const committeeIndices = this.getBeaconCommittee(data.slot, data.index);
+    const attestingIndices = isTreeBacked(attestation)
+      ? zipIndexesInBitList(
+          committeeIndices,
+          (attestation.aggregationBits as unknown) as TreeBacked<BitList>,
+          this.config.types.phase0.CommitteeBits
+        )
+      : committeeIndices.filter((_, index) => !!aggregationBits[index]);
     // sort in-place
     attestingIndices.sort((a, b) => a - b);
     return {
@@ -393,8 +392,15 @@ export class EpochContext {
   }
 
   getAttestingIndices(data: phase0.AttestationData, bits: BitList): ValidatorIndex[] {
-    const committee = this.getBeaconCommittee(data.slot, data.index);
-    return getAttestingIndicesFromCommittee(committee, Array.from(readonlyValues(bits)) as List<boolean>);
+    const committeeIndices = this.getBeaconCommittee(data.slot, data.index);
+    const validatorIndices = isTreeBacked(bits)
+      ? zipIndexesInBitList(
+          committeeIndices,
+          (bits as unknown) as TreeBacked<BitList>,
+          this.config.types.phase0.CommitteeBits
+        )
+      : committeeIndices.filter((_, index) => !!bits[index]);
+    return validatorIndices;
   }
 
   /**

packages/beacon-state-transition/src/altair/block/processSyncCommittee.ts

@@ -11,7 +11,7 @@ import {
   zipIndexesInBitList,
 } from "../../util";
 import {CachedBeaconState} from "../../allForks/util";
-import {BitList, TreeBacked} from "@chainsafe/ssz";
+import {BitList, isTreeBacked, TreeBacked} from "@chainsafe/ssz";
 
 export function processSyncCommittee(
   state: CachedBeaconState<altair.BeaconState>,
@@ -22,11 +22,14 @@ export function processSyncCommittee(
   const {syncParticipantReward, syncProposerReward} = epochCtx;
   const previousSlot = Math.max(state.slot, 1) - 1;
   const committeeIndices = state.currSyncCommitteeIndexes;
-  const participantIndices = zipIndexesInBitList(
-    committeeIndices,
-    aggregate.syncCommitteeBits as TreeBacked<BitList>,
-    config.types.altair.SyncCommitteeBits
-  );
+  // the only time aggregate is not a TreeBacked is when producing a new block
+  const participantIndices = isTreeBacked(aggregate)
+    ? zipIndexesInBitList(
+        committeeIndices,
+        aggregate.syncCommitteeBits as TreeBacked<BitList>,
+        config.types.altair.SyncCommitteeBits
+      )
+    : committeeIndices.filter((index) => !!aggregate.syncCommitteeBits[index]);
   const participantPubkeys = participantIndices.map((validatorIndex) => state.validators[validatorIndex].pubkey);
   const domain = getDomain(
     config,

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

@@ -9,6 +9,7 @@ import {processDeposit as altairProcessDeposit} from "../naive/altair";
 import {computeEpochAtSlot} from "./epoch";
 import {getActiveValidatorIndices} from "./validator";
 import {getTemporaryBlockHeader} from "./blockRoot";
+import {getNextSyncCommittee} from "../altair/state_accessor";
 
 // TODO: Refactor to work with non-phase0 genesis state
 
@@ -48,8 +49,15 @@ export function getGenesisBeaconState(
   // MISC
   state.slot = GENESIS_SLOT;
   const version = config.getForkVersion(GENESIS_SLOT);
+  const forkName = config.getForkName(GENESIS_SLOT);
+  const allForkNames = Object.keys(config.forks) as ForkName[];
+  const forkIndex = allForkNames.findIndex((item) => item === forkName);
+  const previousForkIndex = Math.max(0, forkIndex - 1);
+  const previousForkName = allForkNames[previousForkIndex];
+  const previousFork = config.forks[previousForkName];
+  // the altair genesis spec test requires previous version to be phase0 although ALTAIR_FORK_EPOCH=0
   state.fork = {
-    previousVersion: version,
+    previousVersion: previousFork.version,
     currentVersion: version,
     epoch: computeEpochAtSlot(config, GENESIS_SLOT),
   } as phase0.Fork;
@@ -62,7 +70,6 @@ export function getGenesisBeaconState(
   // Ethereum 1.0 chain data
   state.eth1Data = genesisEth1Data;
   state.randaoMixes = randaoMixes;
-
   return state as TreeBacked<allForks.BeaconState>;
 }
 
@@ -187,5 +194,13 @@ export function initializeBeaconStateFromEth1(
   // Process deposits
   applyDeposits(config, state, deposits);
 
-  return state;
+  if (config.getForkName(GENESIS_SLOT) === ForkName.altair) {
+    const syncCommittees = getNextSyncCommittee(config, state);
+    const altairState = state as TreeBacked<altair.BeaconState>;
+    altairState.currentSyncCommittee = syncCommittees;
+    altairState.nextSyncCommittee = syncCommittees;
+    return altairState as TreeBacked<allForks.BeaconState>;
+  } else {
+    return state;
+  }
 }

packages/spec-test-runner/test/spec/altair/fork/type.ts

@@ -0,0 +1,7 @@
+import {altair, phase0} from "@chainsafe/lodestar-types";
+import {IBaseSpecTest} from "../../type";
+
+export interface IUpgradeStateCase extends IBaseSpecTest {
+  pre: phase0.BeaconState;
+  post: altair.BeaconState;
+}

packages/spec-test-runner/test/spec/altair/fork/upgradeState.test.ts

@@ -0,0 +1,46 @@
+import {join} from "path";
+import {expect} from "chai";
+
+import {TreeBacked} from "@chainsafe/ssz";
+import {config} from "@chainsafe/lodestar-config/minimal";
+import {allForks, altair, phase0} from "@chainsafe/lodestar-beacon-state-transition";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
+import {IUpgradeStateCase} from "./type";
+import {upgradeState} from "@chainsafe/lodestar-beacon-state-transition/lib/altair";
+import {SPEC_TEST_LOCATION} from "../../../utils/specTestCases";
+
+describeDirectorySpecTest<IUpgradeStateCase, altair.BeaconState>(
+  "upgrade state to altair",
+  join(SPEC_TEST_LOCATION, "/tests/minimal/altair/fork/fork/pyspec_tests"),
+  (testcase) => {
+    const phase0State = allForks.createCachedBeaconState<phase0.BeaconState>(
+      config,
+      testcase.pre as TreeBacked<phase0.BeaconState>
+    );
+    return upgradeState(phase0State);
+  },
+  {
+    inputTypes: {
+      pre: {
+        type: InputType.SSZ_SNAPPY,
+        treeBacked: true,
+      },
+      post: {
+        type: InputType.SSZ_SNAPPY,
+        treeBacked: true,
+      },
+      meta: InputType.YAML,
+    },
+    sszTypes: {
+      pre: config.types.phase0.BeaconState,
+      post: config.types.altair.BeaconState,
+    },
+
+    timeout: 100000000,
+    shouldError: (testCase) => !testCase.post,
+    getExpected: (testCase) => testCase.post,
+    expectFunc: (testCase, expected, actual) => {
+      expect(config.types.altair.BeaconState.equals(actual, expected)).to.be.true;
+    },
+  }
+);