@lodestar/state-transition 1.35.0-dev.e18102ed8c → 1.35.0-dev.f45a2be721

package/src/util/seed.ts

@@ -0,0 +1,381 @@
+import {digest} from "@chainsafe/as-sha256";
+import {
+  computeProposerIndex as nativeComputeProposerIndex,
+  computeSyncCommitteeIndices as nativeComputeSyncCommitteeIndices,
+} from "@chainsafe/swap-or-not-shuffle";
+import {
+  DOMAIN_BEACON_PROPOSER,
+  DOMAIN_SYNC_COMMITTEE,
+  EFFECTIVE_BALANCE_INCREMENT,
+  EPOCHS_PER_HISTORICAL_VECTOR,
+  ForkSeq,
+  MAX_EFFECTIVE_BALANCE,
+  MAX_EFFECTIVE_BALANCE_ELECTRA,
+  MIN_SEED_LOOKAHEAD,
+  SHUFFLE_ROUND_COUNT,
+  SLOTS_PER_EPOCH,
+  SYNC_COMMITTEE_SIZE,
+} from "@lodestar/params";
+import {Bytes32, DomainType, Epoch, ValidatorIndex} from "@lodestar/types";
+import {assert, bytesToBigInt, bytesToInt, intToBytes} from "@lodestar/utils";
+import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
+import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
+
+/**
+ * Compute proposer indices for an epoch
+ */
+export function computeProposers(
+  fork: ForkSeq,
+  epochSeed: Uint8Array,
+  shuffling: {epoch: Epoch; activeIndices: Uint32Array},
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): number[] {
+  const startSlot = computeStartSlotAtEpoch(shuffling.epoch);
+  const proposers = [];
+  for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
+    proposers.push(
+      computeProposerIndex(
+        fork,
+        effectiveBalanceIncrements,
+        shuffling.activeIndices,
+        // TODO: if we use hashTree, we can precompute the roots for the next n loops
+        digest(Buffer.concat([epochSeed, intToBytes(slot, 8)]))
+      )
+    );
+  }
+  return proposers;
+}
+
+/**
+ * Return from ``indices`` a random index sampled by effective balance.
+ * This is just to make sure lodestar follows the spec, this is not for production.
+ *
+ * SLOW CODE - 🐢
+ */
+export function naiveComputeProposerIndex(
+  fork: ForkSeq,
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  indices: ArrayLike<ValidatorIndex>,
+  seed: Uint8Array
+): ValidatorIndex {
+  if (indices.length === 0) {
+    throw Error("Validator indices must not be empty");
+  }
+
+  if (fork >= ForkSeq.electra) {
+    const MAX_RANDOM_VALUE = 2 ** 16 - 1;
+    const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE_ELECTRA / EFFECTIVE_BALANCE_INCREMENT;
+
+    let i = 0;
+    while (true) {
+      const candidateIndex = indices[computeShuffledIndex(i % indices.length, indices.length, seed)];
+      const randomBytes = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 16), 8, "le")]));
+      const offset = (i % 16) * 2;
+      const randomValue = bytesToInt(randomBytes.subarray(offset, offset + 2));
+
+      const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+      if (effectiveBalanceIncrement * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomValue) {
+        return candidateIndex;
+      }
+
+      i += 1;
+    }
+  } else {
+    const MAX_RANDOM_BYTE = 2 ** 8 - 1;
+    const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE / EFFECTIVE_BALANCE_INCREMENT;
+
+    let i = 0;
+    while (true) {
+      const candidateIndex = indices[computeShuffledIndex(i % indices.length, indices.length, seed)];
+      const randomByte = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 32), 8, "le")]))[i % 32];
+
+      const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+      if (effectiveBalanceIncrement * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomByte) {
+        return candidateIndex;
+      }
+
+      i += 1;
+    }
+  }
+}
+
+/**
+ * Optimized version of `naiveComputeProposerIndex`.
+ * It shows > 3x speedup according to the perf test.
+ */
+export function computeProposerIndex(
+  fork: ForkSeq,
+  effectiveBalanceIncrements: EffectiveBalanceIncrements,
+  indices: Uint32Array,
+  seed: Uint8Array
+): ValidatorIndex {
+  if (indices.length === 0) {
+    throw Error("Validator indices must not be empty");
+  }
+
+  let maxEffectiveBalance: number;
+  let randByteCount: number;
+  if (fork >= ForkSeq.electra) {
+    maxEffectiveBalance = MAX_EFFECTIVE_BALANCE_ELECTRA;
+    randByteCount = 2;
+  } else {
+    maxEffectiveBalance = MAX_EFFECTIVE_BALANCE;
+    randByteCount = 1;
+  }
+
+  return nativeComputeProposerIndex(
+    seed,
+    indices,
+    effectiveBalanceIncrements,
+    randByteCount,
+    maxEffectiveBalance,
+    EFFECTIVE_BALANCE_INCREMENT,
+    SHUFFLE_ROUND_COUNT
+  );
+}
+
+/**
+ * Return the proposer indices for the given `epoch`.
+ * A more generic version of `computeProposers`
+ */
+export function computeProposerIndices(
+  fork: ForkSeq,
+  state: CachedBeaconStateAllForks,
+  shuffling: {activeIndices: Uint32Array},
+  epoch: Epoch
+): ValidatorIndex[] {
+  const startSlot = computeStartSlotAtEpoch(epoch);
+  const proposers = [];
+  const epochSeed = getSeed(state, epoch, DOMAIN_BEACON_PROPOSER);
+
+  for (let slot = startSlot; slot < startSlot + SLOTS_PER_EPOCH; slot++) {
+    proposers.push(
+      computeProposerIndex(
+        fork,
+        state.epochCtx.effectiveBalanceIncrements,
+        shuffling.activeIndices,
+        digest(Buffer.concat([epochSeed, intToBytes(slot, 8)]))
+      )
+    );
+  }
+  return proposers;
+}
+
+/**
+ * Naive version, this is not supposed to be used in production.
+ * See `computeProposerIndex` for the optimized version.
+ *
+ * Return the sync committee indices for a given state and epoch.
+ * Aligns `epoch` to `baseEpoch` so the result is the same with any `epoch` within a sync period.
+ *  Note: This function should only be called at sync committee period boundaries, as
+ *  ``get_sync_committee_indices`` is not stable within a given period.
+ *
+ * SLOW CODE - 🐢
+ */
+export function naiveGetNextSyncCommitteeIndices(
+  fork: ForkSeq,
+  state: BeaconStateAllForks,
+  activeValidatorIndices: ArrayLike<ValidatorIndex>,
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): ValidatorIndex[] {
+  const syncCommitteeValidatorIndices = [];
+
+  if (fork >= ForkSeq.electra) {
+    const MAX_RANDOM_VALUE = 2 ** 16 - 1;
+    const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE_ELECTRA / EFFECTIVE_BALANCE_INCREMENT;
+
+    const epoch = computeEpochAtSlot(state.slot) + 1;
+    const activeValidatorCount = activeValidatorIndices.length;
+    const seed = getSeed(state, epoch, DOMAIN_SYNC_COMMITTEE);
+
+    let i = 0;
+    while (syncCommitteeValidatorIndices.length < SYNC_COMMITTEE_SIZE) {
+      const shuffledIndex = computeShuffledIndex(i % activeValidatorCount, activeValidatorCount, seed);
+      const candidateIndex = activeValidatorIndices[shuffledIndex];
+      const randomBytes = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 16), 8, "le")]));
+      const offset = (i % 16) * 2;
+      const randomValue = bytesToInt(randomBytes.subarray(offset, offset + 2));
+
+      const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+      if (effectiveBalanceIncrement * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomValue) {
+        syncCommitteeValidatorIndices.push(candidateIndex);
+      }
+
+      i += 1;
+    }
+  } else {
+    const MAX_RANDOM_BYTE = 2 ** 8 - 1;
+    const MAX_EFFECTIVE_BALANCE_INCREMENT = MAX_EFFECTIVE_BALANCE / EFFECTIVE_BALANCE_INCREMENT;
+
+    const epoch = computeEpochAtSlot(state.slot) + 1;
+    const activeValidatorCount = activeValidatorIndices.length;
+    const seed = getSeed(state, epoch, DOMAIN_SYNC_COMMITTEE);
+
+    let i = 0;
+    while (syncCommitteeValidatorIndices.length < SYNC_COMMITTEE_SIZE) {
+      const shuffledIndex = computeShuffledIndex(i % activeValidatorCount, activeValidatorCount, seed);
+      const candidateIndex = activeValidatorIndices[shuffledIndex];
+      const randomByte = digest(Buffer.concat([seed, intToBytes(Math.floor(i / 32), 8, "le")]))[i % 32];
+
+      const effectiveBalanceIncrement = effectiveBalanceIncrements[candidateIndex];
+      if (effectiveBalanceIncrement * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_INCREMENT * randomByte) {
+        syncCommitteeValidatorIndices.push(candidateIndex);
+      }
+
+      i += 1;
+    }
+  }
+
+  return syncCommitteeValidatorIndices;
+}
+
+/**
+ * Optmized version of `naiveGetNextSyncCommitteeIndices`.
+ *
+ * In the worse case scenario, this could be >1000x speedup according to the perf test.
+ */
+export function getNextSyncCommitteeIndices(
+  fork: ForkSeq,
+  state: BeaconStateAllForks,
+  activeValidatorIndices: Uint32Array,
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): Uint32Array {
+  let maxEffectiveBalance: number;
+  let randByteCount: number;
+
+  if (fork >= ForkSeq.electra) {
+    maxEffectiveBalance = MAX_EFFECTIVE_BALANCE_ELECTRA;
+    randByteCount = 2;
+  } else {
+    maxEffectiveBalance = MAX_EFFECTIVE_BALANCE;
+    randByteCount = 1;
+  }
+
+  const epoch = computeEpochAtSlot(state.slot) + 1;
+  const seed = getSeed(state, epoch, DOMAIN_SYNC_COMMITTEE);
+  return nativeComputeSyncCommitteeIndices(
+    seed,
+    activeValidatorIndices,
+    effectiveBalanceIncrements,
+    randByteCount,
+    SYNC_COMMITTEE_SIZE,
+    maxEffectiveBalance,
+    EFFECTIVE_BALANCE_INCREMENT,
+    SHUFFLE_ROUND_COUNT
+  );
+}
+
+/**
+ * Return the shuffled validator index corresponding to ``seed`` (and ``index_count``).
+ *
+ * Swap or not
+ * https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf
+ *
+ * See the 'generalized domain' algorithm on page 3.
+ * This is the naive implementation just to make sure lodestar follows the spec, this is not for production.
+ * The optimized version is in `getComputeShuffledIndexFn`.
+ */
+export function computeShuffledIndex(index: number, indexCount: number, seed: Bytes32): number {
+  let permuted = index;
+  assert.lt(index, indexCount, "indexCount must be less than index");
+  assert.lte(indexCount, 2 ** 40, "indexCount too big");
+  const _seed = seed;
+  for (let i = 0; i < SHUFFLE_ROUND_COUNT; i++) {
+    const pivot = Number(
+      bytesToBigInt(digest(Buffer.concat([_seed, intToBytes(i, 1)])).slice(0, 8)) % BigInt(indexCount)
+    );
+    const flip = (pivot + indexCount - permuted) % indexCount;
+    const position = Math.max(permuted, flip);
+    const source = digest(Buffer.concat([_seed, intToBytes(i, 1), intToBytes(Math.floor(position / 256), 4)]));
+    const byte = source[Math.floor((position % 256) / 8)];
+    const bit = (byte >> (position % 8)) % 2;
+    permuted = bit ? flip : permuted;
+  }
+  return permuted;
+}
+
+type ComputeShuffledIndexFn = (index: number) => number;
+
+/**
+ * An optimized version of `computeShuffledIndex`, this is for production.
+ */
+export function getComputeShuffledIndexFn(indexCount: number, seed: Bytes32): ComputeShuffledIndexFn {
+  // there are possibly SHUFFLE_ROUND_COUNT (90 for mainnet) values for this cache
+  // this cache will always hit after the 1st call
+  const pivotByIndex: Map<number, number> = new Map();
+  // given 2M active validators, there are 2 M / 256 = 8k possible positionDiv
+  // it means there are at most 8k different sources for each round
+  const sourceByPositionDivByIndex: Map<number, Map<number, Uint8Array>> = new Map();
+  // 32 bytes seed + 1 byte i
+  const pivotBuffer = Buffer.alloc(32 + 1);
+  pivotBuffer.set(seed, 0);
+  // 32 bytes seed + 1 byte i + 4 bytes positionDiv
+  const sourceBuffer = Buffer.alloc(32 + 1 + 4);
+  sourceBuffer.set(seed, 0);
+
+  return (index): number => {
+    assert.lt(index, indexCount, "indexCount must be less than index");
+    assert.lte(indexCount, 2 ** 40, "indexCount too big");
+    let permuted = index;
+    // const _seed = seed;
+    for (let i = 0; i < SHUFFLE_ROUND_COUNT; i++) {
+      // optimized version of the below naive code
+      // const pivot = Number(
+      //   bytesToBigInt(digest(Buffer.concat([_seed, intToBytes(i, 1)])).slice(0, 8)) % BigInt(indexCount)
+      // );
+
+      let pivot = pivotByIndex.get(i);
+      if (pivot == null) {
+        // naive version always creates a new buffer, we can reuse the buffer
+        // pivot = Number(
+        //   bytesToBigInt(digest(Buffer.concat([_seed, intToBytes(i, 1)])).slice(0, 8)) % BigInt(indexCount)
+        // );
+        pivotBuffer[32] = i % 256;
+        pivot = Number(bytesToBigInt(digest(pivotBuffer).subarray(0, 8)) % BigInt(indexCount));
+        pivotByIndex.set(i, pivot);
+      }
+
+      const flip = (pivot + indexCount - permuted) % indexCount;
+      const position = Math.max(permuted, flip);
+
+      // optimized version of the below naive code
+      // const source = digest(Buffer.concat([_seed, intToBytes(i, 1), intToBytes(Math.floor(position / 256), 4)]));
+      let sourceByPositionDiv = sourceByPositionDivByIndex.get(i);
+      if (sourceByPositionDiv == null) {
+        sourceByPositionDiv = new Map<number, Uint8Array>();
+        sourceByPositionDivByIndex.set(i, sourceByPositionDiv);
+      }
+      const positionDiv256 = Math.floor(position / 256);
+      let source = sourceByPositionDiv.get(positionDiv256);
+      if (source == null) {
+        // naive version always creates a new buffer, we can reuse the buffer
+        // don't want to go through intToBytes() to avoid BigInt
+        sourceBuffer[32] = i % 256;
+        sourceBuffer.writeUint32LE(positionDiv256, 33);
+        source = digest(sourceBuffer);
+        sourceByPositionDiv.set(positionDiv256, source);
+      }
+      const byte = source[Math.floor((position % 256) / 8)];
+      const bit = (byte >> (position % 8)) % 2;
+      permuted = bit ? flip : permuted;
+    }
+    return permuted;
+  };
+}
+
+/**
+ * Return the randao mix at a recent [[epoch]].
+ */
+export function getRandaoMix(state: BeaconStateAllForks, epoch: Epoch): Bytes32 {
+  return state.randaoMixes.get(epoch % EPOCHS_PER_HISTORICAL_VECTOR);
+}
+
+/**
+ * Return the seed at [[epoch]].
+ */
+export function getSeed(state: BeaconStateAllForks, epoch: Epoch, domainType: DomainType): Uint8Array {
+  const mix = getRandaoMix(state, epoch + EPOCHS_PER_HISTORICAL_VECTOR - MIN_SEED_LOOKAHEAD - 1);
+
+  return digest(Buffer.concat([domainType as Buffer, intToBytes(epoch, 8), mix]));
+}

package/src/util/shufflingDecisionRoot.ts

@@ -0,0 +1,78 @@
+import {Epoch, Root, Slot} from "@lodestar/types";
+import {CachedBeaconStateAllForks} from "../types.js";
+import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeStartSlotAtEpoch} from "./epoch.js";
+
+/**
+ * Returns the block root which decided the proposer shuffling for the current epoch. This root
+ * can be used to key this proposer shuffling.
+ *
+ * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
+ * It should be set to the latest block applied to this `state` or the genesis block root.
+ */
+export function proposerShufflingDecisionRoot(state: CachedBeaconStateAllForks): Root | null {
+  const decisionSlot = proposerShufflingDecisionSlot(state);
+  if (state.slot === decisionSlot) {
+    return null;
+  }
+  return getBlockRootAtSlot(state, decisionSlot);
+}
+
+/**
+ * Returns the slot at which the proposer shuffling was decided. The block root at this slot
+ * can be used to key the proposer shuffling for the current epoch.
+ */
+function proposerShufflingDecisionSlot(state: CachedBeaconStateAllForks): Slot {
+  const startSlot = computeStartSlotAtEpoch(state.epochCtx.epoch);
+  return Math.max(startSlot - 1, 0);
+}
+
+/**
+ * Returns the block root which decided the attester shuffling for the given `requestedEpoch`.
+ * This root can be used to key that attester shuffling.
+ *
+ * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
+ * It should be set to the latest block applied to this `state` or the genesis block root.
+ */
+export function attesterShufflingDecisionRoot(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Root | null {
+  const decisionSlot = attesterShufflingDecisionSlot(state, requestedEpoch);
+  if (state.slot === decisionSlot) {
+    return null;
+  }
+  return getBlockRootAtSlot(state, decisionSlot);
+}
+
+/**
+ * Returns the slot at which the proposer shuffling was decided. The block root at this slot
+ * can be used to key the proposer shuffling for the current epoch.
+ */
+function attesterShufflingDecisionSlot(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Slot {
+  const epoch = attesterShufflingDecisionEpoch(state, requestedEpoch);
+  const slot = computeStartSlotAtEpoch(epoch);
+  return Math.max(slot - 1, 0);
+}
+
+/**
+ * Returns the epoch at which the attester shuffling was decided.
+ *
+ * Spec ref: https://github.com/ethereum/beacon-APIs/blob/v2.1.0/apis/validator/duties/attester.yaml#L15
+ *
+ * Throws an error when:
+ * - `EpochTooLow` when `requestedEpoch` is more than 1 prior to `currentEpoch`.
+ * - `EpochTooHigh` when `requestedEpoch` is more than 1 after `currentEpoch`.
+ */
+function attesterShufflingDecisionEpoch(state: CachedBeaconStateAllForks, requestedEpoch: Epoch): Epoch {
+  const currentEpoch = state.epochCtx.epoch;
+
+  // Next
+  if (requestedEpoch === currentEpoch + 1) return currentEpoch;
+  // Current
+  if (requestedEpoch === currentEpoch) return Math.max(currentEpoch - 1, 0);
+  // Previous
+  if (requestedEpoch === currentEpoch - 1) return Math.max(currentEpoch - 2, 0);
+
+  if (requestedEpoch < currentEpoch) {
+    throw Error(`EpochTooLow: current ${currentEpoch} requested ${requestedEpoch}`);
+  }
+  throw Error(`EpochTooHigh: current ${currentEpoch} requested ${requestedEpoch}`);
+}

package/src/util/signatureSets.ts

@@ -0,0 +1,65 @@
+import {PublicKey, Signature, fastAggregateVerify, verify} from "@chainsafe/blst";
+import {Root} from "@lodestar/types";
+
+export enum SignatureSetType {
+  single = "single",
+  aggregate = "aggregate",
+}
+
+export type SingleSignatureSet = {
+  type: SignatureSetType.single;
+  pubkey: PublicKey;
+  signingRoot: Root;
+  signature: Uint8Array;
+};
+
+export type AggregatedSignatureSet = {
+  type: SignatureSetType.aggregate;
+  pubkeys: PublicKey[];
+  signingRoot: Root;
+  signature: Uint8Array;
+};
+
+export type ISignatureSet = SingleSignatureSet | AggregatedSignatureSet;
+
+export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
+  // All signatures are not trusted and must be group checked (p2.subgroup_check)
+  const signature = Signature.fromBytes(signatureSet.signature, true);
+
+  switch (signatureSet.type) {
+    case SignatureSetType.single:
+      return verify(signatureSet.signingRoot, signatureSet.pubkey, signature);
+
+    case SignatureSetType.aggregate:
+      return fastAggregateVerify(signatureSet.signingRoot, signatureSet.pubkeys, signature);
+
+    default:
+      throw Error("Unknown signature set type");
+  }
+}
+
+export function createSingleSignatureSetFromComponents(
+  pubkey: PublicKey,
+  signingRoot: Root,
+  signature: Uint8Array
+): SingleSignatureSet {
+  return {
+    type: SignatureSetType.single,
+    pubkey,
+    signingRoot,
+    signature,
+  };
+}
+
+export function createAggregateSignatureSetFromComponents(
+  pubkeys: PublicKey[],
+  signingRoot: Root,
+  signature: Uint8Array
+): AggregatedSignatureSet {
+  return {
+    type: SignatureSetType.aggregate,
+    pubkeys,
+    signingRoot,
+    signature,
+  };
+}

package/src/util/signingRoot.ts

@@ -0,0 +1,13 @@
+import {Type} from "@chainsafe/ssz";
+import {Domain, phase0, ssz} from "@lodestar/types";
+
+/**
+ * Return the signing root of an object by calculating the root of the object-domain tree.
+ */
+export function computeSigningRoot<T>(type: Type<T>, sszObject: T, domain: Domain): Uint8Array {
+  const domainWrappedObject: phase0.SigningData = {
+    objectRoot: type.hashTreeRoot(sszObject),
+    domain,
+  };
+  return ssz.phase0.SigningData.hashTreeRoot(domainWrappedObject);
+}

package/src/util/slot.ts

@@ -0,0 +1,22 @@
+import {ChainConfig} from "@lodestar/config";
+import {GENESIS_SLOT} from "@lodestar/params";
+import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
+import {computeEpochAtSlot, computeStartSlotAtEpoch} from "./epoch.js";
+
+export function getSlotsSinceGenesis(config: ChainConfig, genesisTime: TimeSeconds): Slot {
+  const diffInSeconds = Date.now() / 1000 - genesisTime;
+  return Math.floor(diffInSeconds / (config.SLOT_DURATION_MS / 1000));
+}
+
+export function getCurrentSlot(config: ChainConfig, genesisTime: TimeSeconds): Slot {
+  return GENESIS_SLOT + getSlotsSinceGenesis(config, genesisTime);
+}
+
+export function computeSlotsSinceEpochStart(slot: Slot, epoch?: Epoch): Slot {
+  const computeEpoch = epoch ?? computeEpochAtSlot(slot);
+  return slot - computeStartSlotAtEpoch(computeEpoch);
+}
+
+export function computeTimeAtSlot(config: ChainConfig, slot: Slot, genesisTime: TimeSeconds): TimeSeconds {
+  return genesisTime + slot * (config.SLOT_DURATION_MS / 1000);
+}

package/src/util/sszBytes.ts

@@ -0,0 +1,52 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkAll, ForkSeq} from "@lodestar/params";
+import {SSZTypesFor, Slot} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
+
+/**
+ * Slot	uint64
+ */
+const SLOT_BYTE_COUNT = 8;
+
+/**
+ * 48 + 32 + 8 + 1 + 8 + 8 + 8 + 8 = 121
+ * ```
+ * class Validator(Container):
+    pubkey: BLSPubkey [fixed - 48 bytes]
+    withdrawal_credentials: Bytes32 [fixed - 32 bytes]
+    effective_balance: Gwei [fixed - 8 bytes]
+    slashed: boolean [fixed - 1 byte]
+    # Status epochs
+    activation_eligibility_epoch: Epoch [fixed - 8 bytes]
+    activation_epoch: Epoch [fixed - 8 bytes]
+    exit_epoch: Epoch [fixed - 8 bytes]
+    withdrawable_epoch: Epoch [fixed - 8 bytes]
+  ```
+ */
+export const VALIDATOR_BYTES_SIZE = 121;
+
+/**
+ * 8 + 32 = 40
+ * ```
+ * class BeaconState(Container):
+ *   genesis_time: uint64 [fixed - 8 bytes]
+ *   genesis_validators_root: Root [fixed - 32 bytes]
+ *   slot: Slot [fixed - 8 bytes]
+ *   ...
+ * ```
+ */
+const SLOT_BYTES_POSITION_IN_STATE = 40;
+
+export function getForkFromStateBytes(config: ChainForkConfig, bytes: Uint8Array): ForkSeq {
+  const slot = bytesToInt(bytes.subarray(SLOT_BYTES_POSITION_IN_STATE, SLOT_BYTES_POSITION_IN_STATE + SLOT_BYTE_COUNT));
+  return config.getForkSeq(slot);
+}
+
+export function getStateTypeFromBytes(config: ChainForkConfig, bytes: Uint8Array): SSZTypesFor<ForkAll, "BeaconState"> {
+  const slot = getStateSlotFromBytes(bytes);
+  return config.getForkTypes(slot).BeaconState;
+}
+
+export function getStateSlotFromBytes(bytes: Uint8Array): Slot {
+  return bytesToInt(bytes.subarray(SLOT_BYTES_POSITION_IN_STATE, SLOT_BYTES_POSITION_IN_STATE + SLOT_BYTE_COUNT));
+}

package/src/util/syncCommittee.ts

@@ -0,0 +1,69 @@
+import {aggregateSerializedPublicKeys} from "@chainsafe/blst";
+import {
+  BASE_REWARD_FACTOR,
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkSeq,
+  SLOTS_PER_EPOCH,
+  SYNC_COMMITTEE_SIZE,
+  SYNC_REWARD_WEIGHT,
+  WEIGHT_DENOMINATOR,
+} from "@lodestar/params";
+import {altair} from "@lodestar/types";
+import {bigIntSqrt} from "@lodestar/utils";
+import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
+import {BeaconStateAllForks} from "../types.js";
+import {getNextSyncCommitteeIndices} from "./seed.js";
+
+/**
+ * Return the sync committee for a given state and epoch.
+ *
+ * SLOW CODE - 🐢
+ */
+export function getNextSyncCommittee(
+  fork: ForkSeq,
+  state: BeaconStateAllForks,
+  activeValidatorIndices: Uint32Array,
+  effectiveBalanceIncrements: EffectiveBalanceIncrements
+): {indices: Uint32Array; syncCommittee: altair.SyncCommittee} {
+  const indices = getNextSyncCommitteeIndices(fork, state, activeValidatorIndices, effectiveBalanceIncrements);
+
+  // Using the index2pubkey cache is slower because it needs the serialized pubkey.
+  const pubkeys = [];
+  for (const index of indices) {
+    pubkeys.push(state.validators.getReadonly(index).pubkey);
+  }
+
+  return {
+    indices,
+    syncCommittee: {
+      pubkeys,
+      aggregatePubkey: aggregateSerializedPublicKeys(pubkeys).toBytes(),
+    },
+  };
+}
+
+/**
+ * Same logic in https://github.com/ethereum/eth2.0-specs/blob/v1.1.0-alpha.5/specs/altair/beacon-chain.md#sync-committee-processing
+ */
+export function computeSyncParticipantReward(totalActiveBalanceIncrements: number): number {
+  const totalActiveBalance = BigInt(totalActiveBalanceIncrements) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+  const baseRewardPerIncrement = Math.floor(
+    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) / Number(bigIntSqrt(totalActiveBalance))
+  );
+  const totalBaseRewards = baseRewardPerIncrement * totalActiveBalanceIncrements;
+  const maxParticipantRewards = Math.floor(
+    Math.floor((totalBaseRewards * SYNC_REWARD_WEIGHT) / WEIGHT_DENOMINATOR) / SLOTS_PER_EPOCH
+  );
+  return Math.floor(maxParticipantRewards / SYNC_COMMITTEE_SIZE);
+}
+
+/**
+ * Before we manage bigIntSqrt(totalActiveStake) as BigInt and return BigInt.
+ * bigIntSqrt(totalActiveStake) should fit a number (2 ** 53 -1 max)
+ **/
+export function computeBaseRewardPerIncrement(totalActiveStakeByIncrement: number): number {
+  return Math.floor(
+    (EFFECTIVE_BALANCE_INCREMENT * BASE_REWARD_FACTOR) /
+      Number(bigIntSqrt(BigInt(totalActiveStakeByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT)))
+  );
+}