@lodestar/beacon-node 1.39.0-dev.3bf4734ba9 → 1.39.0-dev.46c9c672fd

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);
-    }
-  }
-}

package/src/db/repositories/depositEvent.ts

@@ -1,32 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
-import {phase0, ssz} from "@lodestar/types";
-import {Bucket, getBucketNameByValue} from "../buckets.js";
-
-/**
- * DepositData indexed by deposit index
- * Removed when included on chain or old
- */
-export class DepositEventRepository extends Repository<number, phase0.DepositEvent> {
-  constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.phase0_depositEvent;
-    super(config, db, bucket, ssz.phase0.DepositEvent, getBucketNameByValue(bucket));
-  }
-
-  async deleteOld(depositCount: number): Promise<void> {
-    const firstDepositIndex = await this.firstKey();
-    if (firstDepositIndex === null) {
-      return;
-    }
-    await this.batchDelete(Array.from({length: depositCount - firstDepositIndex}, (_, i) => i + firstDepositIndex));
-  }
-
-  async batchPutValues(depositEvents: phase0.DepositEvent[]): Promise<void> {
-    await this.batchPut(
-      depositEvents.map((depositEvent) => ({
-        key: depositEvent.index,
-        value: depositEvent,
-      }))
-    );
-  }
-}

package/src/db/repositories/eth1Data.ts

@@ -1,33 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
-import {phase0, ssz} from "@lodestar/types";
-import {bytesToInt} from "@lodestar/utils";
-import {Bucket, getBucketNameByValue} from "../buckets.js";
-
-export class Eth1DataRepository extends Repository<number, phase0.Eth1DataOrdered> {
-  constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.phase0_eth1Data;
-    super(config, db, bucket, ssz.phase0.Eth1DataOrdered, getBucketNameByValue(bucket));
-  }
-
-  decodeKey(data: Buffer): number {
-    return bytesToInt(super.decodeKey(data) as unknown as Uint8Array, "be");
-  }
-
-  getId(_value: phase0.Eth1Data): number {
-    throw new Error("Unable to create timestamp from block hash");
-  }
-
-  async batchPutValues(eth1Datas: (phase0.Eth1DataOrdered & {timestamp: number})[]): Promise<void> {
-    await this.batchPut(
-      eth1Datas.map((eth1Data) => ({
-        key: eth1Data.timestamp,
-        value: eth1Data,
-      }))
-    );
-  }
-
-  async deleteOld(timestamp: number): Promise<void> {
-    await this.batchDelete(await this.keys({lt: timestamp}));
-  }
-}

package/src/db/single/index.ts

@@ -1,2 +0,0 @@
-export {PreGenesisState} from "./preGenesisState.js";
-export {PreGenesisStateLastProcessedBlock} from "./preGenesisStateLastProcessedBlock.js";

package/src/db/single/preGenesisState.ts

@@ -1,37 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {Db, DbReqOpts} from "@lodestar/db";
-import {ForkAll, GENESIS_SLOT} from "@lodestar/params";
-import {BeaconStateAllForks} from "@lodestar/state-transition";
-import {SSZTypesFor} from "@lodestar/types";
-import {Bucket, getBucketNameByValue} from "../buckets.js";
-
-export class PreGenesisState {
-  private readonly config: ChainForkConfig;
-  private readonly bucket: Bucket;
-  private readonly db: Db;
-  private readonly key: Uint8Array;
-  private readonly type: SSZTypesFor<ForkAll, "BeaconState">;
-  private readonly dbReqOpts: DbReqOpts;
-
-  constructor(config: ChainForkConfig, db: Db) {
-    this.config = config;
-    this.db = db;
-    this.bucket = Bucket.phase0_preGenesisState;
-    this.key = new Uint8Array([this.bucket]);
-    this.type = this.config.getForkTypes(GENESIS_SLOT).BeaconState;
-    this.dbReqOpts = {bucketId: getBucketNameByValue(this.bucket)};
-  }
-
-  async put(value: BeaconStateAllForks): Promise<void> {
-    await this.db.put(this.key, value.serialize(), this.dbReqOpts);
-  }
-
-  async get(): Promise<BeaconStateAllForks | null> {
-    const value = await this.db.get(this.key, this.dbReqOpts);
-    return value ? this.type.deserializeToViewDU(value) : null;
-  }
-
-  async delete(): Promise<void> {
-    await this.db.delete(this.key, this.dbReqOpts);
-  }
-}

package/src/db/single/preGenesisStateLastProcessedBlock.ts

@@ -1,34 +0,0 @@
-import {UintNumberType} from "@chainsafe/ssz";
-import {ChainForkConfig} from "@lodestar/config";
-import {Db, DbReqOpts} from "@lodestar/db";
-import {ssz} from "@lodestar/types";
-import {Bucket, getBucketNameByValue} from "../buckets.js";
-
-export class PreGenesisStateLastProcessedBlock {
-  private readonly bucket: Bucket;
-  private readonly type: UintNumberType;
-  private readonly db: Db;
-  private readonly key: Uint8Array;
-  private readonly dbReqOpts: DbReqOpts;
-
-  constructor(_config: ChainForkConfig, db: Db) {
-    this.db = db;
-    this.type = ssz.UintNum64;
-    this.bucket = Bucket.phase0_preGenesisStateLastProcessedBlock;
-    this.key = new Uint8Array([this.bucket]);
-    this.dbReqOpts = {bucketId: getBucketNameByValue(this.bucket)};
-  }
-
-  async put(value: number): Promise<void> {
-    await this.db.put(this.key, this.type.serialize(value), this.dbReqOpts);
-  }
-
-  async get(): Promise<number | null> {
-    const value = await this.db.get(this.key, this.dbReqOpts);
-    return value ? this.type.deserialize(value) : null;
-  }
-
-  async delete(): Promise<void> {
-    await this.db.delete(this.key, this.dbReqOpts);
-  }
-}

package/src/eth1/errors.ts

@@ -1,40 +0,0 @@
-import {LodestarError} from "@lodestar/utils";
-
-export enum Eth1ErrorCode {
-  /** Deposit index too high */
-  DEPOSIT_INDEX_TOO_HIGH = "ETH1_ERROR_DEPOSIT_INDEX_TOO_HIGH",
-  /** Not enough deposits in DB */
-  NOT_ENOUGH_DEPOSITS = "ETH1_ERROR_NOT_ENOUGH_DEPOSITS",
-  /** Too many deposits returned by DB */
-  TOO_MANY_DEPOSITS = "ETH1_ERROR_TOO_MANY_DEPOSITS",
-  /** Deposit root tree does not match current eth1Data */
-  WRONG_DEPOSIT_ROOT = "ETH1_ERROR_WRONG_DEPOSIT_ROOT",
-
-  /** No deposits found for block range */
-  NO_DEPOSITS_FOR_BLOCK_RANGE = "ETH1_ERROR_NO_DEPOSITS_FOR_BLOCK_RANGE",
-  /** No depositRoot for depositCount */
-  NO_DEPOSIT_ROOT = "ETH1_ERROR_NO_DEPOSIT_ROOT",
-  /** Not enough deposit roots for index */
-  NOT_ENOUGH_DEPOSIT_ROOTS = "ETH1_ERROR_NOT_ENOUGH_DEPOSIT_ROOTS",
-
-  /** Attempted to insert a duplicate log for same index into the Eth1DepositsCache */
-  DUPLICATE_DISTINCT_LOG = "ETH1_ERROR_DUPLICATE_DISTINCT_LOG",
-  /** Attempted to insert a log with index != prev + 1 into the Eth1DepositsCache */
-  NON_CONSECUTIVE_LOGS = "ETH1_ERROR_NON_CONSECUTIVE_LOGS",
-  /** Expected a deposit log in the db for the index, missing log implies a corrupted db */
-  MISSING_DEPOSIT_LOG = "ETH1_ERROR_MISSING_DEPOSIT_LOG",
-}
-
-export type Eth1ErrorType =
-  | {code: Eth1ErrorCode.DEPOSIT_INDEX_TOO_HIGH; depositIndex: number; depositCount: number}
-  | {code: Eth1ErrorCode.NOT_ENOUGH_DEPOSITS; len: number; expectedLen: number}
-  | {code: Eth1ErrorCode.TOO_MANY_DEPOSITS; len: number; expectedLen: number}
-  | {code: Eth1ErrorCode.WRONG_DEPOSIT_ROOT; root: string; expectedRoot: string}
-  | {code: Eth1ErrorCode.NO_DEPOSITS_FOR_BLOCK_RANGE; fromBlock: number; toBlock: number}
-  | {code: Eth1ErrorCode.NO_DEPOSIT_ROOT; depositCount: number}
-  | {code: Eth1ErrorCode.NOT_ENOUGH_DEPOSIT_ROOTS; index: number; treeLength: number}
-  | {code: Eth1ErrorCode.DUPLICATE_DISTINCT_LOG; newIndex: number; lastLogIndex: number}
-  | {code: Eth1ErrorCode.NON_CONSECUTIVE_LOGS; newIndex: number; lastLogIndex: number}
-  | {code: Eth1ErrorCode.MISSING_DEPOSIT_LOG; newIndex: number; lastLogIndex: number};
-
-export class Eth1Error extends LodestarError<Eth1ErrorType> {}

package/src/eth1/eth1DataCache.ts

@@ -1,26 +0,0 @@
-import {ChainForkConfig} from "@lodestar/config";
-import {phase0} from "@lodestar/types";
-import {IBeaconDb} from "../db/index.js";
-
-export class Eth1DataCache {
-  db: IBeaconDb;
-  config: ChainForkConfig;
-
-  constructor(config: ChainForkConfig, db: IBeaconDb) {
-    this.config = config;
-    this.db = db;
-  }
-
-  async get({timestampRange}: {timestampRange: {gte: number; lte: number}}): Promise<phase0.Eth1DataOrdered[]> {
-    return this.db.eth1Data.values(timestampRange);
-  }
-
-  async add(eth1Datas: (phase0.Eth1DataOrdered & {timestamp: number})[]): Promise<void> {
-    await this.db.eth1Data.batchPutValues(eth1Datas);
-  }
-
-  async getHighestCachedBlockNumber(): Promise<number | null> {
-    const highestEth1Data = await this.db.eth1Data.lastValue();
-    return highestEth1Data?.blockNumber ?? null;
-  }
-}