@lodestar/beacon-node 1.39.0-dev.d4a47659a5 → 1.39.0-dev.dd21e36997

package/src/chain/genesis/genesis.ts

@@ -1,190 +0,0 @@
-import {Tree, toGindex} from "@chainsafe/persistent-merkle-tree";
-import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
-import {GENESIS_EPOCH, GENESIS_SLOT} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
-  applyDeposits,
-  applyEth1BlockHash,
-  applyTimestamp,
-  createCachedBeaconState,
-  createEmptyEpochCacheImmutableData,
-  getActiveValidatorIndices,
-  getGenesisBeaconState,
-  getTemporaryBlockHeader,
-} from "@lodestar/state-transition";
-import {phase0, ssz} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {DepositTree} from "../../db/repositories/depositDataRoot.js";
-import {IEth1Provider} from "../../eth1/index.js";
-import {IEth1StreamParams} from "../../eth1/interface.js";
-import {getDepositsAndBlockStreamForGenesis, getDepositsStream} from "../../eth1/stream.js";
-import {GenesisResult, IGenesisBuilder} from "./interface.js";
-
-export type GenesisBuilderKwargs = {
-  config: ChainForkConfig;
-  eth1Provider: IEth1Provider;
-  logger: Logger;
-
-  /** Use to restore pending progress */
-  pendingStatus?: {
-    state: BeaconStateAllForks;
-    depositTree: DepositTree;
-    lastProcessedBlockNumber: number;
-  };
-
-  signal?: AbortSignal;
-  maxBlocksPerPoll?: number;
-};
-
-export class GenesisBuilder implements IGenesisBuilder {
-  // Expose state to persist on error
-  readonly state: CachedBeaconStateAllForks;
-  readonly depositTree: DepositTree;
-  /** Is null if no block has been processed yet */
-  lastProcessedBlockNumber: number | null = null;
-
-  private readonly config: BeaconConfig;
-  private readonly eth1Provider: IEth1Provider;
-  private readonly logger: Logger;
-  private readonly signal?: AbortSignal;
-  private readonly eth1Params: IEth1StreamParams;
-  private readonly depositCache = new Set<number>();
-  private readonly fromBlock: number;
-  private readonly logEvery = 30 * 1000;
-  private lastLog = 0;
-  /** Current count of active validators in the state */
-  private activatedValidatorCount: number;
-
-  constructor({config, eth1Provider, logger, signal, pendingStatus, maxBlocksPerPoll}: GenesisBuilderKwargs) {
-    // at genesis builder, there is no genesis validator so we don't have a real BeaconConfig
-    // but we need BeaconConfig to temporarily create CachedBeaconState, the cast here is safe since we don't use any getDomain here
-    // the use of state as CachedBeaconState is just for convenient, GenesisResult returns TreeView anyway
-    this.eth1Provider = eth1Provider;
-    this.logger = logger;
-    this.signal = signal;
-    this.eth1Params = {
-      ...config,
-      maxBlocksPerPoll: maxBlocksPerPoll ?? 10000,
-    };
-
-    let stateView: BeaconStateAllForks;
-
-    if (pendingStatus) {
-      this.logger.info("Restoring pending genesis state", {block: pendingStatus.lastProcessedBlockNumber});
-      stateView = pendingStatus.state;
-      this.depositTree = pendingStatus.depositTree;
-      this.fromBlock = Math.max(pendingStatus.lastProcessedBlockNumber + 1, this.eth1Provider.deployBlock);
-    } else {
-      stateView = getGenesisBeaconState(
-        config,
-        ssz.phase0.Eth1Data.defaultValue(),
-        getTemporaryBlockHeader(config, config.getForkTypes(GENESIS_SLOT).BeaconBlock.defaultValue())
-      );
-      this.depositTree = ssz.phase0.DepositDataRootList.defaultViewDU();
-      this.fromBlock = this.eth1Provider.deployBlock;
-    }
-
-    // TODO - PENDING: Ensure EpochCacheImmutableData is created only once
-    this.state = createCachedBeaconState(stateView, createEmptyEpochCacheImmutableData(config, stateView));
-    this.config = this.state.config;
-    this.activatedValidatorCount = getActiveValidatorIndices(stateView, GENESIS_EPOCH).length;
-  }
-
-  /**
-   * Get eth1 deposit events and blocks and apply to this.state until we found genesis.
-   */
-  async waitForGenesis(): Promise<GenesisResult> {
-    await this.eth1Provider.validateContract();
-
-    // Load data from data from this.db.depositData, this.db.depositDataRoot
-    // And start from a more recent fromBlock
-    const blockNumberValidatorGenesis = await this.waitForGenesisValidators();
-
-    const depositsAndBlocksStream = getDepositsAndBlockStreamForGenesis(
-      blockNumberValidatorGenesis,
-      this.eth1Provider,
-      this.eth1Params,
-      this.signal
-    );
-
-    for await (const [depositEvents, block] of depositsAndBlocksStream) {
-      this.applyDeposits(depositEvents);
-      applyTimestamp(this.config, this.state, block.timestamp);
-      applyEth1BlockHash(this.state, block.blockHash);
-      this.lastProcessedBlockNumber = block.blockNumber;
-
-      if (
-        this.state.genesisTime >= this.config.MIN_GENESIS_TIME &&
-        this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
-      ) {
-        this.logger.info("Found genesis state", {blockNumber: block.blockNumber});
-        return {
-          state: this.state,
-          depositTree: this.depositTree,
-          block,
-        };
-      }
-
-      this.throttledLog(`Waiting for min genesis time ${block.timestamp} / ${this.config.MIN_GENESIS_TIME}`);
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  /**
-   * First phase of waiting for genesis.
-   * Stream deposits events in batches as big as possible without querying block data
-   * @returns Block number at which there are enough active validators is state for genesis
-   */
-  private async waitForGenesisValidators(): Promise<number> {
-    const depositsStream = getDepositsStream(this.fromBlock, this.eth1Provider, this.eth1Params, this.signal);
-
-    for await (const {depositEvents, blockNumber} of depositsStream) {
-      this.applyDeposits(depositEvents);
-      this.lastProcessedBlockNumber = blockNumber;
-
-      if (this.activatedValidatorCount >= this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT) {
-        this.logger.info("Found enough genesis validators", {blockNumber});
-        return blockNumber;
-      }
-
-      this.throttledLog(
-        `Found ${this.state.validators.length} / ${this.config.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT} validators to genesis`
-      );
-    }
-
-    throw Error("depositsStream stopped without a valid genesis state");
-  }
-
-  private applyDeposits(depositEvents: phase0.DepositEvent[]): void {
-    const newDeposits = depositEvents
-      .filter((depositEvent) => !this.depositCache.has(depositEvent.index))
-      .map((depositEvent) => {
-        this.depositCache.add(depositEvent.index);
-        this.depositTree.push(ssz.phase0.DepositData.hashTreeRoot(depositEvent.depositData));
-        const gindex = toGindex(this.depositTree.type.depth, BigInt(depositEvent.index));
-
-        // Apply changes from the push above
-        this.depositTree.commit();
-        const depositTreeNode = this.depositTree.node;
-        return {
-          proof: new Tree(depositTreeNode).getSingleProof(gindex),
-          data: depositEvent.depositData,
-        };
-      });
-
-    const {activatedValidatorCount} = applyDeposits(this.config, this.state, newDeposits, this.depositTree);
-    this.activatedValidatorCount += activatedValidatorCount;
-
-    // TODO: If necessary persist deposits here to this.db.depositData, this.db.depositDataRoot
-  }
-
-  /** Throttle genesis generation status log to prevent spamming */
-  private throttledLog(message: string): void {
-    if (Date.now() - this.lastLog > this.logEvery) {
-      this.lastLog = Date.now();
-      this.logger.info(message);
-    }
-  }
-}

package/src/chain/genesis/interface.ts

@@ -1,14 +0,0 @@
-import {CompositeViewDU, VectorCompositeType} from "@chainsafe/ssz";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {ssz} from "@lodestar/types";
-import {Eth1Block} from "../../eth1/interface.js";
-
-export type GenesisResult = {
-  state: CachedBeaconStateAllForks;
-  depositTree: CompositeViewDU<VectorCompositeType<typeof ssz.Root>>;
-  block: Eth1Block;
-};
-
-export interface IGenesisBuilder {
-  waitForGenesis: () => Promise<GenesisResult>;
-}

package/src/chain/rewards/attestationsRewards.ts

@@ -1,197 +0,0 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-import {routes} from "@lodestar/api";
-import {
-  EFFECTIVE_BALANCE_INCREMENT,
-  ForkName,
-  INACTIVITY_PENALTY_QUOTIENT_ALTAIR,
-  MAX_EFFECTIVE_BALANCE,
-  MAX_EFFECTIVE_BALANCE_ELECTRA,
-  PARTICIPATION_FLAG_WEIGHTS,
-  TIMELY_HEAD_FLAG_INDEX,
-  TIMELY_SOURCE_FLAG_INDEX,
-  TIMELY_TARGET_FLAG_INDEX,
-  WEIGHT_DENOMINATOR,
-  isForkPostElectra,
-} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateAltair,
-  EpochTransitionCache,
-  FLAG_ELIGIBLE_ATTESTER,
-  FLAG_PREV_HEAD_ATTESTER_UNSLASHED,
-  FLAG_PREV_SOURCE_ATTESTER_UNSLASHED,
-  FLAG_PREV_TARGET_ATTESTER_UNSLASHED,
-  beforeProcessEpoch,
-  hasMarkers,
-  isInInactivityLeak,
-} from "@lodestar/state-transition";
-import {ValidatorIndex} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
-
-export type AttestationsRewards = routes.beacon.AttestationsRewards;
-type IdealAttestationsReward = routes.beacon.IdealAttestationsReward;
-type TotalAttestationsReward = routes.beacon.TotalAttestationsReward;
-/** Attestations penalty with respect to effective balance in Gwei */
-type AttestationsPenalty = {target: number; source: number; effectiveBalance: number};
-
-const defaultAttestationsReward = {head: 0, target: 0, source: 0, inclusionDelay: 0, inactivity: 0};
-const defaultAttestationsPenalty = {target: 0, source: 0};
-
-export async function computeAttestationsRewards(
-  pubkey2index: PubkeyIndexMap,
-  state: CachedBeaconStateAllForks,
-  validatorIds?: (ValidatorIndex | string)[]
-): Promise<AttestationsRewards> {
-  const fork = state.config.getForkName(state.slot);
-  if (fork === ForkName.phase0) {
-    throw Error("Unsupported fork. Attestations rewards calculation is not available in phase0");
-  }
-
-  const stateAltair = state as CachedBeaconStateAltair;
-  const transitionCache = beforeProcessEpoch(stateAltair);
-
-  const [idealRewards, penalties] = computeIdealAttestationsRewardsAndPenaltiesAltair(stateAltair, transitionCache);
-  const totalRewards = computeTotalAttestationsRewardsAltair(
-    pubkey2index,
-    stateAltair,
-    transitionCache,
-    idealRewards,
-    penalties,
-    validatorIds
-  );
-
-  return {idealRewards, totalRewards};
-}
-
-function computeIdealAttestationsRewardsAndPenaltiesAltair(
-  state: CachedBeaconStateAllForks,
-  transitionCache: EpochTransitionCache
-): [IdealAttestationsReward[], AttestationsPenalty[]] {
-  const baseRewardPerIncrement = transitionCache.baseRewardPerIncrement;
-  const activeBalanceByIncrement = transitionCache.totalActiveStakeByIncrement;
-  const fork = state.config.getForkName(state.slot);
-  const maxEffectiveBalance = isForkPostElectra(fork) ? MAX_EFFECTIVE_BALANCE_ELECTRA : MAX_EFFECTIVE_BALANCE;
-  const maxEffectiveBalanceByIncrement = Math.floor(maxEffectiveBalance / EFFECTIVE_BALANCE_INCREMENT);
-
-  const idealRewards = Array.from({length: maxEffectiveBalanceByIncrement + 1}, (_, effectiveBalanceByIncrement) => ({
-    ...defaultAttestationsReward,
-    effectiveBalance: effectiveBalanceByIncrement * EFFECTIVE_BALANCE_INCREMENT,
-  }));
-
-  const attestationsPenalties: AttestationsPenalty[] = Array.from(
-    {length: maxEffectiveBalanceByIncrement + 1},
-    (_, effectiveBalanceByIncrement) => ({
-      ...defaultAttestationsPenalty,
-      effectiveBalance: effectiveBalanceByIncrement * EFFECTIVE_BALANCE_INCREMENT,
-    })
-  );
-
-  for (let i = 0; i < PARTICIPATION_FLAG_WEIGHTS.length; i++) {
-    const weight = PARTICIPATION_FLAG_WEIGHTS[i];
-
-    let unslashedStakeByIncrement: number;
-    let flagName: keyof IdealAttestationsReward;
-
-    switch (i) {
-      case TIMELY_SOURCE_FLAG_INDEX: {
-        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.sourceStakeByIncrement;
-        flagName = "source";
-        break;
-      }
-      case TIMELY_TARGET_FLAG_INDEX: {
-        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.targetStakeByIncrement;
-        flagName = "target";
-        break;
-      }
-      case TIMELY_HEAD_FLAG_INDEX: {
-        unslashedStakeByIncrement = transitionCache.prevEpochUnslashedStake.headStakeByIncrement;
-        flagName = "head";
-        break;
-      }
-      default: {
-        throw Error(`Unable to retrieve unslashed stake. Unknown participation flag index: ${i}`);
-      }
-    }
-
-    for (
-      let effectiveBalanceByIncrement = 0;
-      effectiveBalanceByIncrement <= maxEffectiveBalanceByIncrement;
-      effectiveBalanceByIncrement++
-    ) {
-      const baseReward = effectiveBalanceByIncrement * baseRewardPerIncrement;
-      const rewardNumerator = baseReward * weight * unslashedStakeByIncrement;
-      // Both idealReward and penalty are rounded to nearest integer. Loss of precision is minimal as unit is gwei
-      const idealReward = Math.round(rewardNumerator / activeBalanceByIncrement / WEIGHT_DENOMINATOR);
-      const penalty = Math.round((baseReward * weight) / WEIGHT_DENOMINATOR); // Positive number indicates penalty
-
-      const idealAttestationsReward = idealRewards[effectiveBalanceByIncrement];
-      idealAttestationsReward[flagName] = isInInactivityLeak(state) ? 0 : idealReward; // No attestations rewards during inactivity leak
-
-      if (flagName !== "head") {
-        const attestationPenalty = attestationsPenalties[effectiveBalanceByIncrement];
-        attestationPenalty[flagName] = penalty;
-      }
-    }
-  }
-
-  return [idealRewards, attestationsPenalties];
-}
-
-// Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
-function computeTotalAttestationsRewardsAltair(
-  pubkey2index: PubkeyIndexMap,
-  state: CachedBeaconStateAltair,
-  transitionCache: EpochTransitionCache,
-  idealRewards: IdealAttestationsReward[],
-  penalties: AttestationsPenalty[],
-  validatorIds: (ValidatorIndex | string)[] = []
-): TotalAttestationsReward[] {
-  const rewards = [];
-  const {flags} = transitionCache;
-  const {epochCtx, config} = state;
-  const validatorIndices = validatorIds
-    .map((id) => (typeof id === "number" ? id : pubkey2index.get(fromHex(id))))
-    .filter((index) => index !== undefined); // Validator indices to include in the result
-
-  const inactivityPenaltyDenominator = config.INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR;
-
-  for (let i = 0; i < flags.length; i++) {
-    if (validatorIndices.length && !validatorIndices.includes(i)) {
-      continue;
-    }
-
-    const flag = flags[i];
-    if (!hasMarkers(flag, FLAG_ELIGIBLE_ATTESTER)) {
-      continue;
-    }
-
-    const effectiveBalanceIncrement = epochCtx.effectiveBalanceIncrements[i];
-
-    const currentRewards = {...defaultAttestationsReward, validatorIndex: i};
-
-    if (hasMarkers(flag, FLAG_PREV_SOURCE_ATTESTER_UNSLASHED)) {
-      currentRewards.source = idealRewards[effectiveBalanceIncrement].source;
-    } else {
-      currentRewards.source = penalties[effectiveBalanceIncrement].source * -1; // Negative reward to indicate penalty
-    }
-
-    if (hasMarkers(flag, FLAG_PREV_TARGET_ATTESTER_UNSLASHED)) {
-      currentRewards.target = idealRewards[effectiveBalanceIncrement].target;
-    } else {
-      currentRewards.target = penalties[effectiveBalanceIncrement].target * -1;
-
-      // Also incur inactivity penalty if not voting target correctly
-      const inactivityPenaltyNumerator =
-        effectiveBalanceIncrement * EFFECTIVE_BALANCE_INCREMENT * state.inactivityScores.get(i);
-      currentRewards.inactivity = Math.floor(inactivityPenaltyNumerator / inactivityPenaltyDenominator) * -1;
-    }
-
-    if (hasMarkers(flag, FLAG_PREV_HEAD_ATTESTER_UNSLASHED)) {
-      currentRewards.head = idealRewards[effectiveBalanceIncrement].head;
-    }
-
-    rewards.push(currentRewards);
-  }
-
-  return rewards;
-}

package/src/chain/rewards/blockRewards.ts

@@ -1,150 +0,0 @@
-import {routes} from "@lodestar/api";
-import {
-  ForkName,
-  WHISTLEBLOWER_REWARD_QUOTIENT,
-  WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA,
-  isForkPostElectra,
-} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateAltair,
-  CachedBeaconStatePhase0,
-  getAttesterSlashableIndices,
-  processAttestationsAltair,
-} from "@lodestar/state-transition";
-import {BeaconBlock, altair, phase0} from "@lodestar/types";
-
-export type BlockRewards = routes.beacon.BlockRewards;
-type SubRewardValue = number; // All reward values should be integer
-
-/**
- * Calculate total proposer block rewards given block and the beacon state of the same slot before the block is applied (preState)
- * postState can be passed in to read reward cache if available
- * Standard (Non MEV) rewards for proposing a block consists of:
- *  1) Including attestations from (beacon) committee
- *  2) Including attestations from sync committee
- *  3) Reporting slashable behaviours from proposer and attester
- */
-export async function computeBlockRewards(
-  block: BeaconBlock,
-  preState: CachedBeaconStateAllForks,
-  postState?: CachedBeaconStateAllForks
-): Promise<BlockRewards> {
-  const fork = preState.config.getForkName(block.slot);
-  const {attestations: cachedAttestationsReward = 0, syncAggregate: cachedSyncAggregateReward = 0} =
-    postState?.proposerRewards ?? {};
-  let blockAttestationReward = cachedAttestationsReward;
-  let syncAggregateReward = cachedSyncAggregateReward;
-
-  if (blockAttestationReward === 0) {
-    blockAttestationReward =
-      fork === ForkName.phase0
-        ? computeBlockAttestationRewardPhase0(block as phase0.BeaconBlock, preState as CachedBeaconStatePhase0)
-        : computeBlockAttestationRewardAltair(block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
-  }
-
-  if (syncAggregateReward === 0) {
-    syncAggregateReward = computeSyncAggregateReward(block as altair.BeaconBlock, preState as CachedBeaconStateAltair);
-  }
-
-  const blockProposerSlashingReward = computeBlockProposerSlashingReward(fork, block, preState);
-  const blockAttesterSlashingReward = computeBlockAttesterSlashingReward(fork, block, preState);
-
-  const total =
-    blockAttestationReward + syncAggregateReward + blockProposerSlashingReward + blockAttesterSlashingReward;
-
-  return {
-    proposerIndex: block.proposerIndex,
-    total,
-    attestations: blockAttestationReward,
-    syncAggregate: syncAggregateReward,
-    proposerSlashings: blockProposerSlashingReward,
-    attesterSlashings: blockAttesterSlashingReward,
-  };
-}
-
-/**
- * TODO: Calculate rewards received by block proposer for including attestations.
- */
-function computeBlockAttestationRewardPhase0(
-  _block: phase0.BeaconBlock,
-  _preState: CachedBeaconStatePhase0
-): SubRewardValue {
-  throw new Error("Unsupported fork! Block attestation reward calculation is not available in phase0");
-}
-
-/**
- * Calculate rewards received by block proposer for including attestations since Altair.
- * Reuses `processAttestationsAltair()`. Has dependency on RewardCache
- */
-function computeBlockAttestationRewardAltair(
-  block: altair.BeaconBlock,
-  preState: CachedBeaconStateAltair
-): SubRewardValue {
-  const fork = preState.config.getForkSeq(block.slot);
-  const {attestations} = block.body;
-
-  processAttestationsAltair(fork, preState, attestations, false);
-
-  return preState.proposerRewards.attestations;
-}
-
-function computeSyncAggregateReward(block: altair.BeaconBlock, preState: CachedBeaconStateAltair): SubRewardValue {
-  if (block.body.syncAggregate !== undefined) {
-    const {syncCommitteeBits} = block.body.syncAggregate;
-    const {syncProposerReward} = preState.epochCtx;
-
-    return syncCommitteeBits.getTrueBitIndexes().length * Math.floor(syncProposerReward); // syncProposerReward should already be integer
-  }
-
-  return 0; // phase0 block does not have syncAggregate
-}
-
-/**
- * Calculate rewards received by block proposer for including proposer slashings.
- * All proposer slashing rewards go to block proposer and none to whistleblower as of Deneb
- */
-function computeBlockProposerSlashingReward(
-  fork: ForkName,
-  block: BeaconBlock,
-  state: CachedBeaconStateAllForks
-): SubRewardValue {
-  let proposerSlashingReward = 0;
-
-  for (const proposerSlashing of block.body.proposerSlashings) {
-    const offendingProposerIndex = proposerSlashing.signedHeader1.message.proposerIndex;
-    const offendingProposerBalance = state.validators.getReadonly(offendingProposerIndex).effectiveBalance;
-    const whistleblowerRewardQuotient = isForkPostElectra(fork)
-      ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
-      : WHISTLEBLOWER_REWARD_QUOTIENT;
-
-    proposerSlashingReward += Math.floor(offendingProposerBalance / whistleblowerRewardQuotient);
-  }
-
-  return proposerSlashingReward;
-}
-
-/**
- * Calculate rewards received by block proposer for including attester slashings.
- * All attester slashing rewards go to block proposer and none to whistleblower as of Deneb
- */
-function computeBlockAttesterSlashingReward(
-  fork: ForkName,
-  block: BeaconBlock,
-  preState: CachedBeaconStateAllForks
-): SubRewardValue {
-  let attesterSlashingReward = 0;
-
-  for (const attesterSlashing of block.body.attesterSlashings) {
-    for (const offendingAttesterIndex of getAttesterSlashableIndices(attesterSlashing)) {
-      const offendingAttesterBalance = preState.validators.getReadonly(offendingAttesterIndex).effectiveBalance;
-      const whistleblowerRewardQuotient = isForkPostElectra(fork)
-        ? WHISTLEBLOWER_REWARD_QUOTIENT_ELECTRA
-        : WHISTLEBLOWER_REWARD_QUOTIENT;
-
-      attesterSlashingReward += Math.floor(offendingAttesterBalance / whistleblowerRewardQuotient);
-    }
-  }
-
-  return attesterSlashingReward;
-}

package/src/chain/rewards/syncCommitteeRewards.ts

@@ -1,58 +0,0 @@
-import {routes} from "@lodestar/api";
-import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAllForks, CachedBeaconStateAltair, Index2PubkeyCache} from "@lodestar/state-transition";
-import {BeaconBlock, ValidatorIndex, altair} from "@lodestar/types";
-
-export type SyncCommitteeRewards = routes.beacon.SyncCommitteeRewards;
-type BalanceRecord = {val: number}; // Use val for convenient way to increment/decrement balance
-
-export async function computeSyncCommitteeRewards(
-  index2pubkey: Index2PubkeyCache,
-  block: BeaconBlock,
-  preState: CachedBeaconStateAllForks,
-  validatorIds: (ValidatorIndex | string)[] = []
-): Promise<SyncCommitteeRewards> {
-  const fork = preState.config.getForkName(block.slot);
-  if (fork === ForkName.phase0) {
-    throw Error("Cannot get sync rewards as phase0 block does not have sync committee");
-  }
-
-  const altairBlock = block as altair.BeaconBlock;
-  const preStateAltair = preState as CachedBeaconStateAltair;
-
-  // Bound syncCommitteeValidatorIndices in case it goes beyond SYNC_COMMITTEE_SIZE just to be safe
-  const syncCommitteeValidatorIndices = preStateAltair.epochCtx.currentSyncCommitteeIndexed.validatorIndices.slice(
-    0,
-    SYNC_COMMITTEE_SIZE
-  );
-  const {syncParticipantReward} = preStateAltair.epochCtx;
-  const {syncCommitteeBits} = altairBlock.body.syncAggregate;
-
-  // Use balance of each committee as starting point such that we cap the penalty to avoid balance dropping below 0
-  const balances: Map<ValidatorIndex, BalanceRecord> = new Map();
-  for (const i of syncCommitteeValidatorIndices) {
-    balances.set(i, {val: preStateAltair.balances.get(i)});
-  }
-
-  for (const i of syncCommitteeValidatorIndices) {
-    const balanceRecord = balances.get(i) as BalanceRecord;
-    if (syncCommitteeBits.get(i)) {
-      // Positive rewards for participants
-      balanceRecord.val += syncParticipantReward;
-    } else {
-      // Negative rewards for non participants
-      balanceRecord.val = Math.max(0, balanceRecord.val - syncParticipantReward);
-    }
-  }
-
-  const rewards = Array.from(balances, ([validatorIndex, v]) => ({validatorIndex, reward: v.val}));
-
-  if (validatorIds.length) {
-    const filtersSet = new Set(validatorIds);
-    return rewards.filter(
-      (reward) => filtersSet.has(reward.validatorIndex) || filtersSet.has(index2pubkey[reward.validatorIndex].toHex())
-    );
-  }
-
-  return rewards;
-}

package/src/db/repositories/depositDataRoot.ts

@@ -1,80 +0,0 @@
-import {ByteVectorType, CompositeViewDU, ListCompositeType} from "@chainsafe/ssz";
-import {ChainForkConfig} from "@lodestar/config";
-import {Db, KeyValue, Repository} from "@lodestar/db";
-import {Root, ssz} from "@lodestar/types";
-import {bytesToInt} from "@lodestar/utils";
-import {Bucket, getBucketNameByValue} from "../buckets.js";
-
-// TODO: Review where is best to put this type
-export type DepositTree = CompositeViewDU<ListCompositeType<ByteVectorType>>;
-
-export class DepositDataRootRepository extends Repository<number, Root> {
-  private depositRootTree?: DepositTree;
-
-  constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.index_depositDataRoot;
-    super(config, db, bucket, ssz.Root, getBucketNameByValue(bucket));
-  }
-
-  decodeKey(data: Buffer): number {
-    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
-  }
-
-  // depositDataRoots stored by depositData index
-  getId(_value: Root): number {
-    throw new Error("Unable to create depositIndex from root");
-  }
-
-  async put(index: number, value: Root): Promise<void> {
-    await super.put(index, value);
-    await this.depositRootTreeSet(index, value);
-  }
-
-  async batchPut(items: KeyValue<number, Root>[]): Promise<void> {
-    await super.batchPut(items);
-    for (const {key, value} of items) {
-      await this.depositRootTreeSet(key, value);
-    }
-  }
-
-  async putList(roots: Root[]): Promise<void> {
-    await this.batchPut(roots.map((root, index) => ({key: index, value: root})));
-  }
-
-  async batchPutValues(values: {index: number; root: Root}[]): Promise<void> {
-    await this.batchPut(
-      values.map(({index, root}) => ({
-        key: index,
-        value: root,
-      }))
-    );
-  }
-
-  async getDepositRootTree(): Promise<DepositTree> {
-    if (!this.depositRootTree) {
-      const values = await this.values();
-      this.depositRootTree = ssz.phase0.DepositDataRootList.toViewDU(values);
-    }
-    return this.depositRootTree;
-  }
-
-  async getDepositRootTreeAtIndex(depositIndex: number): Promise<DepositTree> {
-    const depositRootTree = await this.getDepositRootTree();
-    return depositRootTree.sliceTo(depositIndex);
-  }
-
-  private async depositRootTreeSet(index: number, value: Uint8Array): Promise<void> {
-    const depositRootTree = await this.getDepositRootTree();
-
-    // TODO: Review and fix properly
-    if (index > depositRootTree.length) {
-      throw Error(`Error setting depositRootTree index ${index} > length ${depositRootTree.length}`);
-    }
-
-    if (index === depositRootTree.length) {
-      depositRootTree.push(value);
-    } else {
-      depositRootTree.set(index, value);
-    }
-  }
-}