Spec test v1.1.0

.github/workflows/test-spec.yml

@@ -65,9 +65,9 @@ jobs:
       - name: Spec tests altair-mainnet
         run: yarn test:spec-altair-mainnet
         working-directory: packages/spec-test-runner
-      # - name: Spec tests merge-minimal
-      #   run: yarn test:spec-merge-minimal
-      #   working-directory: packages/spec-test-runner
-      # - name: Spec tests merge-mainnet
-      #   run: yarn test:spec-merge-mainnet
-      #   working-directory: packages/spec-test-runner
+      - name: Spec tests merge-minimal
+        run: yarn test:spec-merge-minimal
+        working-directory: packages/spec-test-runner
+      - name: Spec tests merge-mainnet
+        run: yarn test:spec-merge-mainnet
+        working-directory: packages/spec-test-runner

packages/beacon-state-transition/src/phase0/epoch/processPendingAttestations.ts

@@ -23,7 +23,7 @@ export function statusProcessEpoch<T extends allForks.BeaconState>(
   targetFlag: number,
   headFlag: number
 ): void {
-  const {epochCtx} = state;
+  const {epochCtx, slot: stateSlot} = state;
   const rootType = ssz.Root;
   const prevEpoch = epochCtx.previousShuffling.epoch;
   if (attestations.length === 0) {
@@ -40,7 +40,8 @@ export function statusProcessEpoch<T extends allForks.BeaconState>(
     const attBeaconBlockRoot = attData.beaconBlockRoot;
     const attTarget = attData.target;
     const attVotedTargetRoot = rootType.equals(attTarget.root, actualTargetBlockRoot);
-    const attVotedHeadRoot = rootType.equals(attBeaconBlockRoot, getBlockRootAtSlot(state, attSlot));
+    const attVotedHeadRoot =
+      attSlot < stateSlot && rootType.equals(attBeaconBlockRoot, getBlockRootAtSlot(state, attSlot));
     const committee = epochCtx.getBeaconCommittee(attSlot, committeeIndex);
     const participants = zipIndexesCommitteeBits(committee, aggregationBits);
 

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

@@ -222,6 +222,8 @@ export function initializeBeaconStateFromEth1(
 
   if (GENESIS_SLOT >= config.MERGE_FORK_EPOCH) {
     const stateMerge = state as TreeBacked<merge.BeaconState>;
+    // as of Sep 2021, this is for spec test only
+    stateMerge.fork.previousVersion = config.GENESIS_FORK_VERSION;
     stateMerge.latestExecutionPayloadHeader.blockHash = eth1BlockHash;
     stateMerge.latestExecutionPayloadHeader.timestamp = eth1Timestamp;
     stateMerge.latestExecutionPayloadHeader.random = eth1BlockHash;

packages/config/src/chainConfig/presets/minimal.ts

@@ -63,8 +63,8 @@ export const chainConfig: IChainConfig = {
   EJECTION_BALANCE: 16000000000,
   // 2**2 (= 4)
   MIN_PER_EPOCH_CHURN_LIMIT: 4,
-  // 2**16 (= 65,536)
-  CHURN_LIMIT_QUOTIENT: 65536,
+  // [customized] scale queue churn at much lower validator counts for testing
+  CHURN_LIMIT_QUOTIENT: 32,
 
   // Deposit contract
   // ---------------------------------------------------------------

packages/spec-test-runner/package.json

@@ -51,6 +51,7 @@
     "@chainsafe/lodestar-utils": "^0.30.0",
     "@chainsafe/lodestar-validator": "^0.30.0",
     "@chainsafe/ssz": "^0.8.17",
+    "@chainsafe/persistent-merkle-tree": "^0.3.7",
     "@types/yargs": "^17.0.2"
   },
   "keywords": [

packages/spec-test-runner/test/spec/allForks/epochProcessing.ts

@@ -5,7 +5,7 @@ import {CachedBeaconState, allForks} from "@chainsafe/lodestar-beacon-state-tran
 import {describeDirectorySpecTest} from "@chainsafe/lodestar-spec-test-util";
 import {ssz} from "@chainsafe/lodestar-types";
 import {TreeBacked} from "@chainsafe/ssz";
-import {ACTIVE_PRESET, ForkName, PresetName} from "@chainsafe/lodestar-params";
+import {ACTIVE_PRESET, ForkName} from "@chainsafe/lodestar-params";
 import {SPEC_TEST_LOCATION} from "../../specTestVersioning";
 import {expectEqualBeaconState, inputTypeSszTreeBacked} from "../util";
 import {getConfig} from "./util";
@@ -53,22 +53,6 @@ export function epochProcessing(fork: ForkName, epochProcessFns: Record<string,
         expectFunc: (testCase, expected, actual) => {
           expectEqualBeaconState(fork, expected, actual);
         },
-        shouldSkip: (testCase, n) =>
-          // TODO: All the tests below fail with the same error
-          //
-          // Error: Cannot get block root for slot in the future: 47 < 47
-          // at Object.lt (/home/lion/Code/eth2.0/lodestar/packages/utils/src/assert.ts:43:13)
-          // at Object.getBlockRootAtSlot (/home/lion/Code/eth2.0/lodestar/packages/beacon-state-transition/src/util/blockRoot.ts:17:10)
-          // at Object.statusProcessEpoch (/home/lion/Code/eth2.0/lodestar/packages/beacon-state-transition/src/phase0/epoch/processPendingAttestations.ts:40:66)
-          // at Object.beforeProcessEpoch (/home/lion/Code/eth2.0/lodestar/packages/beacon-state-transition/src/allForks/util/epochProcess.ts:189:5)
-          fork === ForkName.phase0 &&
-          ACTIVE_PRESET === PresetName.minimal &&
-          testDir === "justification_and_finalization" &&
-          (n === "123_ok_support" ||
-            n === "123_poor_support" ||
-            n === "12_ok_support" ||
-            n === "12_ok_support_messed_target" ||
-            n === "12_poor_support"),
       }
     );
   }

packages/spec-test-runner/test/spec/allForks/forkChoice.ts

@@ -21,7 +21,7 @@ import {
 // eslint-disable-next-line no-restricted-imports
 import {ChainEventEmitter} from "@chainsafe/lodestar/lib/chain/emitter";
 import {toHexString} from "@chainsafe/ssz";
-import {IForkChoice} from "@chainsafe/lodestar-fork-choice";
+import {CheckpointWithHex, IForkChoice} from "@chainsafe/lodestar-fork-choice";
 import {ssz} from "@chainsafe/lodestar-types";
 import {ACTIVE_PRESET, SLOTS_PER_EPOCH, ForkName} from "@chainsafe/lodestar-params";
 import {SPEC_TEST_LOCATION} from "../../specTestVersioning";
@@ -82,8 +82,8 @@ export function forkChoiceTest(fork: ForkName): void {
             const {
               head: expectedHead,
               time: expectedTime,
-              justifiedCheckpointRoot,
-              finalizedCheckpointRoot,
+              justifiedCheckpoint,
+              finalizedCheckpoint,
               bestJustifiedCheckpoint,
             } = step.checks;
 
@@ -99,21 +99,24 @@ export function forkChoiceTest(fork: ForkName): void {
                 Number(expectedTime),
                 `Invalid forkchoice time at step ${i}`
               );
-            if (justifiedCheckpointRoot)
-              expect(toHexString(forkchoice.getJustifiedCheckpoint().root)).to.be.equal(
-                justifiedCheckpointRoot,
-                `Invalid justified checkpoint time at step ${i}`
+            if (justifiedCheckpoint) {
+              expect(toSpecTestCheckpoint(forkchoice.getJustifiedCheckpoint())).to.be.deep.equal(
+                justifiedCheckpoint,
+                `Invalid justified checkpoint at step ${i}`
               );
-            if (finalizedCheckpointRoot)
-              expect(toHexString(forkchoice.getFinalizedCheckpoint().root)).to.be.equal(
-                finalizedCheckpointRoot,
-                `Invalid finalized checkpoint time at step ${i}`
+            }
+            if (finalizedCheckpoint) {
+              expect(toSpecTestCheckpoint(forkchoice.getFinalizedCheckpoint())).to.be.deep.equal(
+                finalizedCheckpoint,
+                `Invalid finalized checkpoint at step ${i}`
               );
-            if (bestJustifiedCheckpoint)
-              expect(toHexString(forkchoice.getBestJustifiedCheckpoint().root)).to.be.equal(
+            }
+            if (bestJustifiedCheckpoint) {
+              expect(toSpecTestCheckpoint(forkchoice.getBestJustifiedCheckpoint())).to.be.deep.equal(
                 bestJustifiedCheckpoint,
-                `Invalid best justified checkpoint time at step ${i}`
+                `Invalid best justified checkpoint at step ${i}`
               );
+            }
           }
         }
       },
@@ -154,12 +157,6 @@ export function forkChoiceTest(fork: ForkName): void {
         timeout: 10000,
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         expectFunc: () => {},
-
-        shouldSkip: (_, n) =>
-          // we should enable this for next spec test release
-          // refer to https://github.com/hwwhww/consensus-spec-tests/tree/fork-choice-pr2577
-          n === "new_justified_is_later_than_store_justified" ||
-          n === "on_block_finalized_skip_slots_not_in_skip_chain",
       }
     );
   }
@@ -250,8 +247,17 @@ function cacheState(
   stateCache.set(toHexString(blockRoot), wrappedState);
 }
 
+function toSpecTestCheckpoint(checkpoint: CheckpointWithHex): SpecTestCheckpoint {
+  return {
+    epoch: BigInt(checkpoint.epoch),
+    root: checkpoint.rootHex,
+  };
+}
+
 type Step = OnTick | OnAttestation | OnBlock | Checks;
 
+type SpecTestCheckpoint = {epoch: BigInt; root: string};
+
 // This test executes steps in sequence. There may be multiple items of the following types:
 // on_tick execution step
 
@@ -279,9 +285,9 @@ type Checks = {
   checks: {
     head: {slot: number; root: string};
     time?: number;
-    justifiedCheckpointRoot?: string;
-    finalizedCheckpointRoot?: string;
-    bestJustifiedCheckpoint?: string;
+    justifiedCheckpoint?: SpecTestCheckpoint;
+    finalizedCheckpoint?: SpecTestCheckpoint;
+    bestJustifiedCheckpoint?: SpecTestCheckpoint;
   };
 };
 

packages/spec-test-runner/test/spec/altair/merkle.test.ts

@@ -0,0 +1,61 @@
+import {join} from "path";
+import {altair, ssz} from "@chainsafe/lodestar-types";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
+import {ProofType, SingleProof} from "@chainsafe/persistent-merkle-tree";
+import {ACTIVE_PRESET} from "@chainsafe/lodestar-params";
+import {fromHexString, toHexString, TreeBacked} from "@chainsafe/ssz";
+import {SPEC_TEST_LOCATION} from "../../specTestVersioning";
+import {IBaseSpecTest} from "../type";
+import {verifyMerkleBranch} from "@chainsafe/lodestar-utils";
+import {expect} from "chai";
+
+describeDirectorySpecTest<IMerkleTestCase, IProof>(
+  `${ACTIVE_PRESET}/altair/transition`,
+  join(SPEC_TEST_LOCATION, `/tests/${ACTIVE_PRESET}/altair/merkle/single_proof/pyspec_tests`),
+  (testcase) => {
+    const {proof: specTestProof, state} = testcase;
+    const stateTB = state as TreeBacked<altair.BeaconState>;
+    const stateRoot = stateTB.hashTreeRoot();
+    const leaf = fromHexString(specTestProof.leaf);
+    const branch = specTestProof.branch.map((item) => fromHexString(item));
+    const depth = Math.floor(Math.log2(Number(specTestProof.leafIndex)));
+    const verified = verifyMerkleBranch(leaf, branch, depth, Number(specTestProof.leafIndex) % 2 ** depth, stateRoot);
+    expect(verified, "cannot verify merkle branch").to.be.true;
+    const lodestarProof = stateTB.tree.getProof({
+      gindex: specTestProof.leafIndex,
+      type: ProofType.single,
+    }) as SingleProof;
+    return {
+      leaf: toHexString(lodestarProof.leaf),
+      leafIndex: lodestarProof.gindex,
+      branch: lodestarProof.witnesses.map(toHexString),
+    };
+  },
+  {
+    inputTypes: {
+      state: {type: InputType.SSZ_SNAPPY as const, treeBacked: true as const},
+      proof: InputType.YAML as const,
+    },
+    getSszTypes: () => {
+      return {
+        state: ssz.altair.BeaconState,
+      };
+    },
+    timeout: 10000,
+    getExpected: (testCase) => testCase.proof,
+    expectFunc: (testCase, expected, actual) => {
+      expect(actual).to.be.deep.equal(expected, "incorrect proof");
+    },
+  }
+);
+
+interface IMerkleTestCase extends IBaseSpecTest {
+  state: altair.BeaconState;
+  proof: IProof;
+}
+
+interface IProof {
+  leaf: string;
+  leafIndex: bigint;
+  branch: string[];
+}

packages/spec-test-runner/test/spec/merge/genesis.test.ts

@@ -0,0 +1,4 @@
+import {ForkName} from "@chainsafe/lodestar-params";
+import {genesis} from "../allForks/genesis";
+
+genesis(ForkName.merge);

packages/spec-test-runner/test/specTestVersioning.ts

@@ -8,5 +8,5 @@ import path from "path";
 // The contents of this file MUST include the URL, version and target path, and nothing else.
 
 export const SPEC_TEST_REPO_URL = "https://github.com/ethereum/consensus-spec-tests";
-export const SPEC_TEST_VERSION = "v1.1.0-beta.3";
+export const SPEC_TEST_VERSION = "v1.1.0";
 export const SPEC_TEST_LOCATION = path.join(__dirname, "../spec-tests");

packages/types/src/merge/sszTypes.ts

@@ -24,7 +24,7 @@ import {ssz as altairSsz} from "../altair";
 import * as merge from "./types";
 import {LazyVariable} from "../utils/lazyVar";
 
-const {Bytes20, Bytes32, Number64, Slot, ValidatorIndex, Root, BLSSignature} = primitiveSsz;
+const {Bytes20, Bytes32, Number64, Slot, ValidatorIndex, Root, BLSSignature, Uint8} = primitiveSsz;
 
 // So the expandedRoots can be referenced, and break the circular dependency
 const typesRef = new LazyVariable<{
@@ -61,7 +61,8 @@ const executionPayloadFields = {
   gasLimit: Number64,
   gasUsed: Number64,
   timestamp: Number64,
-  extraData: new ByteVectorType({length: MAX_EXTRA_DATA_BYTES}),
+  // TODO: if there is perf issue, consider making ByteListType
+  extraData: new ListType({limit: MAX_EXTRA_DATA_BYTES, elementType: Uint8}),
   baseFeePerGas: Bytes32,
   // Extra payload fields
   blockHash: Root,