feat: use zig backed lodestar-z shuffle

packages/beacon-node/package.json

@@ -154,7 +154,6 @@
     "xxhash-wasm": "1.0.2"
   },
   "devDependencies": {
-    "@chainsafe/swap-or-not-shuffle": "^1.2.1",
     "@libp2p/interface-internal": "^3.1.12",
     "@libp2p/logger": "^6.2.13",
     "@libp2p/utils": "^7.4.0",

packages/beacon-node/test/spec/presets/shuffling.test.ts

@@ -1,12 +1,14 @@
 import path from "node:path";
-import {unshuffleList} from "@chainsafe/swap-or-not-shuffle";
+import bindings from "@chainsafe/lodestar-z";
 import {ACTIVE_PRESET, SHUFFLE_ROUND_COUNT} from "@lodestar/params";
 import {InputType} from "@lodestar/spec-test-util";
 import {bnToNum, fromHex} from "@lodestar/utils";
 import {ethereumConsensusSpecsTests} from "../specTestVersioning.js";
 import {specTestIterator} from "../utils/specTestIterator.js";
 import {RunnerType, TestRunnerFn} from "../utils/types.js";
 
+const {unshuffleList} = bindings.shuffle;
+
 const shuffling: TestRunnerFn<ShufflingTestCase, string> = () => {
   return {
     testFunction: (testcase) => {

packages/state-transition/package.json

@@ -69,7 +69,6 @@
     "@chainsafe/lodestar-z": "catalog:",
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
     "@chainsafe/ssz": "^1.6.3",
-    "@chainsafe/swap-or-not-shuffle": "^1.2.1",
     "@lodestar/config": "workspace:^",
     "@lodestar/params": "workspace:^",
     "@lodestar/types": "workspace:^",

packages/state-transition/src/util/epochShuffling.ts

@@ -1,4 +1,4 @@
-import {asyncUnshuffleList, unshuffleList} from "@chainsafe/swap-or-not-shuffle";
+import bindings from "@chainsafe/lodestar-z";
 import {BeaconConfig} from "@lodestar/config";
 import {
   DOMAIN_BEACON_ATTESTER,
@@ -16,6 +16,8 @@ import {computeAnchorCheckpoint} from "./computeAnchorCheckpoint.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {getSeed} from "./seed.js";
 
+const {unshuffleList} = bindings.shuffle;
+
 /**
  * Readonly interface for EpochShuffling.
  */
@@ -105,24 +107,6 @@ export function computeEpochShuffling(
   };
 }
 
-export async function computeEpochShufflingAsync(
-  // TODO: (@matthewkeil) remove state/epoch and pass in seed to clean this up
-  state: BeaconStateAllForks,
-  activeIndices: Uint32Array,
-  epoch: Epoch
-): Promise<EpochShuffling> {
-  const seed = getSeed(state, epoch, DOMAIN_BEACON_ATTESTER);
-  const shuffling = await asyncUnshuffleList(activeIndices, seed, SHUFFLE_ROUND_COUNT);
-  const committees = buildCommitteesFromShuffling(shuffling);
-  return {
-    epoch,
-    activeIndices,
-    shuffling,
-    committees,
-    committeesPerSlot: committees[0].length,
-  };
-}
-
 export function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
   const pivotSlot = Math.max(GENESIS_SLOT, computeStartSlotAtEpoch(epoch - 1) - 1);
   return toRootHex(getBlockRootAtSlot(state, pivotSlot));

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

@@ -1,8 +1,5 @@
 import {digest} from "@chainsafe/as-sha256";
-import {
-  computeProposerIndex as nativeComputeProposerIndex,
-  computeSyncCommitteeIndices as nativeComputeSyncCommitteeIndices,
-} from "@chainsafe/swap-or-not-shuffle";
+import bindings from "@chainsafe/lodestar-z";
 import {
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_PTC_ATTESTER,
@@ -24,6 +21,11 @@ import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js
 import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
 
+const {
+  computeProposerIndex: nativeComputeProposerIndex,
+  computeSyncCommitteeIndices: nativeComputeSyncCommitteeIndices,
+} = bindings.shuffle;
+
 /**
  * Compute proposer indices for an epoch
  */
@@ -117,7 +119,7 @@ export function computeProposerIndex(
   }
 
   let maxEffectiveBalance: number;
-  let randByteCount: number;
+  let randByteCount: 1 | 2;
   if (fork >= ForkSeq.electra) {
     maxEffectiveBalance = MAX_EFFECTIVE_BALANCE_ELECTRA;
     randByteCount = 2;
@@ -244,7 +246,7 @@ export function getNextSyncCommitteeIndices(
   effectiveBalanceIncrements: EffectiveBalanceIncrements
 ): Uint32Array {
   let maxEffectiveBalance: number;
-  let randByteCount: number;
+  let randByteCount: 1 | 2;
 
   if (fork >= ForkSeq.electra) {
     maxEffectiveBalance = MAX_EFFECTIVE_BALANCE_ELECTRA;

packages/state-transition/test/perf/hashing.test.ts

@@ -1,9 +1,11 @@
 import {beforeAll, bench, describe} from "@chainsafe/benchmark";
-import {unshuffleList} from "@chainsafe/swap-or-not-shuffle";
+import bindings from "@chainsafe/lodestar-z";
 import {SHUFFLE_ROUND_COUNT} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {generatePerfTestCachedStatePhase0, numValidators} from "../../src/testUtils/util.js";
 
+const {unshuffleList} = bindings.shuffle;
+
 // Test cost of hashing state after some modifications
 
 describe("BeaconState hashTreeRoot", () => {

packages/state-transition/test/unit/util/shuffling.test.ts

@@ -1,11 +1,12 @@
 import {describe, expect, it} from "vitest";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {computeEpochAtSlot} from "../../../src/index.js";
 import {generateState} from "../../../src/testUtils/state.js";
-import {computeEpochShuffling, computeEpochShufflingAsync} from "../../../src/util/epochShuffling.js";
+import {computeEpochShuffling} from "../../../src/util/epochShuffling.js";
 
 describe("EpochShuffling", () => {
-  it("async and sync versions should be identical", async () => {
+  it("should shuffle active indices into a permutation split into committees", () => {
     const numberOfValidators = 1000;
     const activeIndices = Uint32Array.from(Array.from({length: numberOfValidators}, (_, i) => i));
     const state = generateState();
@@ -24,9 +25,16 @@ describe("EpochShuffling", () => {
     );
     const epoch = computeEpochAtSlot(state.slot);
 
-    const sync = computeEpochShuffling(state, activeIndices, epoch);
-    const async = await computeEpochShufflingAsync(state, activeIndices, epoch);
+    const shuffling = computeEpochShuffling(state, activeIndices, epoch);
 
-    expect(sync).toStrictEqual(async);
+    expect(shuffling.epoch).toBe(epoch);
+    expect(shuffling.activeIndices).toBe(activeIndices);
+    expect(Array.from(shuffling.shuffling).sort((a, b) => a - b)).toEqual(Array.from(activeIndices));
+    expect(shuffling.committees.length).toBe(SLOTS_PER_EPOCH);
+    const committeeSize = shuffling.committees.flat().reduce((sum, c) => sum + c.length, 0);
+    expect(committeeSize).toBe(numberOfValidators);
+
+    // deterministic for the same state and epoch
+    expect(computeEpochShuffling(state, activeIndices, epoch)).toStrictEqual(shuffling);
   });
 });