@lodestar/beacon-node 1.35.0-dev.8689cc3545 → 1.35.0-dev.8b45b1e978

package/src/sync/backfill/errors.ts

@@ -1,23 +0,0 @@
-import {PeerId} from "@libp2p/interface";
-import {Root} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-
-export enum BackfillSyncErrorCode {
-  /** fetched block doesn't connect to anchor block */
-  NOT_ANCHORED = "not_anchored",
-  /** fetched blocks are not linear */
-  NOT_LINEAR = "not_linear",
-  /** peer doesn't have required block by root */
-  MISSING_BLOCK = "missing_blocks",
-  INVALID_SIGNATURE = "invalid_proposer_signature",
-  INTERNAL_ERROR = "backfill_internal_error",
-}
-
-export type BackfillSyncErrorType =
-  | {code: BackfillSyncErrorCode.NOT_ANCHORED}
-  | {code: BackfillSyncErrorCode.NOT_LINEAR}
-  | {code: BackfillSyncErrorCode.INVALID_SIGNATURE}
-  | {code: BackfillSyncErrorCode.MISSING_BLOCK; root: Root; peerId: PeerId}
-  | {code: BackfillSyncErrorCode.INTERNAL_ERROR; reason: string};
-
-export class BackfillSyncError extends LodestarError<BackfillSyncErrorType> {}

package/src/sync/backfill/index.ts

@@ -1 +0,0 @@
-export * from "./backfill.js";

package/src/sync/backfill/verify.ts

@@ -1,58 +0,0 @@
-import {BeaconConfig} from "@lodestar/config";
-import {GENESIS_SLOT} from "@lodestar/params";
-import {CachedBeaconStateAllForks, ISignatureSet, getBlockProposerSignatureSet} from "@lodestar/state-transition";
-import {Root, SignedBeaconBlock, Slot, WithBytes, ssz} from "@lodestar/types";
-import {IBlsVerifier} from "../../chain/bls/index.js";
-import {BackfillSyncError, BackfillSyncErrorCode} from "./errors.js";
-
-export type BackfillBlockHeader = {
-  slot: Slot;
-  root: Root;
-};
-
-export type BackfillBlock = BackfillBlockHeader & {block: SignedBeaconBlock};
-
-export function verifyBlockSequence(
-  config: BeaconConfig,
-  blocks: WithBytes<SignedBeaconBlock>[],
-  anchorRoot: Root
-): {
-  nextAnchor: BackfillBlock | null;
-  verifiedBlocks: WithBytes<SignedBeaconBlock>[];
-  error?: BackfillSyncErrorCode.NOT_LINEAR;
-} {
-  let nextRoot: Root = anchorRoot;
-  let nextAnchor: BackfillBlock | null = null;
-
-  const verifiedBlocks: WithBytes<SignedBeaconBlock>[] = [];
-  for (const block of blocks.reverse()) {
-    const blockRoot = config.getForkTypes(block.data.message.slot).BeaconBlock.hashTreeRoot(block.data.message);
-    if (!ssz.Root.equals(blockRoot, nextRoot)) {
-      if (ssz.Root.equals(nextRoot, anchorRoot)) {
-        throw new BackfillSyncError({code: BackfillSyncErrorCode.NOT_ANCHORED});
-      }
-      return {nextAnchor, verifiedBlocks, error: BackfillSyncErrorCode.NOT_LINEAR};
-    }
-    verifiedBlocks.push(block);
-    nextAnchor = {block: block.data, slot: block.data.message.slot, root: nextRoot};
-    nextRoot = block.data.message.parentRoot;
-  }
-  return {nextAnchor, verifiedBlocks};
-}
-
-export async function verifyBlockProposerSignature(
-  bls: IBlsVerifier,
-  state: CachedBeaconStateAllForks,
-  blocks: WithBytes<SignedBeaconBlock>[]
-): Promise<void> {
-  if (blocks.length === 1 && blocks[0].data.message.slot === GENESIS_SLOT) return;
-  const signatures = blocks.reduce((sigs: ISignatureSet[], block) => {
-    // genesis block doesn't have valid signature
-    if (block.data.message.slot !== GENESIS_SLOT) sigs.push(getBlockProposerSignatureSet(state, block.data));
-    return sigs;
-  }, []);
-
-  if (!(await bls.verifySignatureSets(signatures, {batchable: true}))) {
-    throw new BackfillSyncError({code: BackfillSyncErrorCode.INVALID_SIGNATURE});
-  }
-}

package/src/sync/constants.ts

@@ -1,71 +0,0 @@
-/** The number of head syncing chains to sync at a time. */
-export const PARALLEL_HEAD_CHAINS = 2;
-
-/** Minimum work we require a finalized chain to do before picking a chain with more peers. */
-export const MIN_FINALIZED_CHAIN_VALIDATED_EPOCHS = 10;
-
-/** The number of times to retry a batch before it is considered failed. */
-// export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 5;
-// this constant is increased a lot for peerDAS because we may have many failed download due to rate limit not implemented yet
-// TODO: change it back to 5 when this issue is implemented https://github.com/ChainSafe/lodestar/issues/8033
-export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 20;
-
-/**
- * Consider batch faulty after downloading and processing this number of times
- * as in https://github.com/ChainSafe/lodestar/issues/8147 we cannot proceed the sync chain if there is unknown parent
- * from prior batch. For example a peer may send us a non-canonical chain segment or not returning all blocks
- * in that case we should throw error and `RangeSync` should remove that error chain and add a new one.
- **/
-export const MAX_BATCH_PROCESSING_ATTEMPTS = 0;
-
-/**
- * Number of slots to offset batches.
- *
- * Before Jul2022 an offset of 1 was required to download the checkpoint block during finalized sync. Otherwise
- * the block necessary so switch from Finalized sync to Head sync won't be in the fork-choice and range sync would
- * be stuck in a loop downloading the previous epoch to finalized epoch, until we get rate-limited.
- *
- * After Jul2022 during finalized sync the entire epoch of finalized epoch will be downloaded fulfilling the goal
- * to switch to Head sync latter. This does not affect performance nor sync speed and just downloads a few extra
- * blocks that would be required by Head sync anyway. However, having an offset of 0 allows to send to the processor
- * blocks that belong to the same epoch, which enables batch verification optimizations.
- */
-export const BATCH_SLOT_OFFSET = 0;
-
-/** First epoch to allow to start gossip  */
-export const MIN_EPOCH_TO_START_GOSSIP = -1;
-
-/**
- * Blocks are downloaded in batches from peers. This constant specifies how many epochs worth of
- * blocks per batch are requested _at most_. A batch may request less blocks to account for
- * already requested slots. There is a timeout for each batch request. If this value is too high,
- * we will negatively report peers with poor bandwidth. This can be set arbitrarily high, in which
- * case the responder will fill the response up to the max request size, assuming they have the
- * bandwidth to do so.
- *
- * Jul2022: Current batch block processor wants only blocks in the same epoch. So we'll process only
- * one batch at a time. Metrics can confirm preliminary tests that speed is as good.
- */
-export const EPOCHS_PER_BATCH = 1;
-
-/**
- * The maximum number of batches to queue before requesting more.
- * In good network conditions downloading batches is much faster than processing them
- * A number > 10 epochs worth results in wasted progress when the chain completes syncing
- *
- * TODO: When switching branches usually all batches in AwaitingProcessing are dropped, could it be optimized?
- */
-export const BATCH_BUFFER_SIZE = Math.ceil(10 / EPOCHS_PER_BATCH);
-
-/**
- * Maximum number of concurrent requests to perform with a SyncChain.
- * This is according to the spec https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md
- */
-export const MAX_CONCURRENT_REQUESTS = 2;
-
-/**
- * Maximum number of epochs to download ahead when syncing.
- * In fulu, to fully process a batch we may need to download columns from multiple peers
- * so having this constant too big is a waste of resources and peers may rate limit us.
- */
-export const MAX_LOOK_AHEAD_EPOCHS = 2;

package/src/sync/index.ts

@@ -1,2 +0,0 @@
-export * from "./interface.js";
-export * from "./sync.js";

package/src/sync/interface.ts

@@ -1,55 +0,0 @@
-import {routes} from "@lodestar/api";
-import {BeaconConfig} from "@lodestar/config";
-import {Slot, phase0} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {IBeaconChain} from "../chain/index.js";
-import {IBeaconDb} from "../db/index.js";
-import {Metrics} from "../metrics/index.js";
-import {INetwork} from "../network/index.js";
-import {SyncChainDebugState} from "./range/chain.js";
-export type {SyncChainDebugState};
-
-export type SyncingStatus = routes.node.SyncingStatus;
-
-export interface IBeaconSync {
-  state: SyncState;
-  close(): void;
-  getSyncStatus(): SyncingStatus;
-  isSynced(): boolean;
-  isSyncing(): boolean;
-  getSyncChainsDebugState(): SyncChainDebugState[];
-}
-
-export enum SyncState {
-  /** No useful peers are connected */
-  Stalled = "Stalled",
-  /** The node is performing a long-range sync over a finalized chain */
-  SyncingFinalized = "SyncingFinalized",
-  /** The node is performing a long-range sync over head chains */
-  SyncingHead = "SyncingHead",
-  /** The node is up to date with all known peers */
-  Synced = "Synced",
-}
-
-/** Map a SyncState to an integer for rendering in Grafana */
-export const syncStateMetric: {[K in SyncState]: number} = {
-  [SyncState.Stalled]: 0,
-  [SyncState.SyncingFinalized]: 1,
-  [SyncState.SyncingHead]: 2,
-  [SyncState.Synced]: 3,
-};
-
-export type SlotRange = {
-  start: Slot;
-  end: Slot;
-};
-
-export interface SyncModules {
-  config: BeaconConfig;
-  network: INetwork;
-  db: IBeaconDb;
-  metrics: Metrics | null;
-  logger: Logger;
-  chain: IBeaconChain;
-  wsCheckpoint?: phase0.Checkpoint;
-}

package/src/sync/options.ts

@@ -1,45 +0,0 @@
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
-
-export type SyncOptions = {
-  /**
-   * Allow node to consider itself synced without being connected to a peer.
-   * Use only for local networks with a single node, can be dangerous in regular networks.
-   */
-  isSingleNode?: boolean;
-  /**
-   * For RangeSync disable processing batches of blocks at once.
-   * Should only be used for debugging or testing.
-   */
-  disableProcessAsChainSegment?: boolean;
-
-  /** USE FOR TESTING ONLY. Disable range sync completely */
-  disableRangeSync?: boolean;
-  /** USE FOR TESTING ONLY. Disable unknown block sync completely */
-  disableBlockInputSync?: boolean;
-  /**
-   * The batch size of slots for backfill sync can attempt to sync/process before yielding
-   * to sync loop. This number can be increased or decreased to make a suitable resource
-   * allocation to backfill sync. The default of 0 would mean backfill sync will be skipped
-   */
-  backfillBatchSize: number;
-  /** For testing only, MAX_PENDING_BLOCKS by default */
-  maxPendingBlocks?: number;
-
-  /**
-   * The number of slots ahead of us that is allowed before starting a RangeSync
-   * If a peer is within this tolerance (forwards or backwards), it is treated as a fully sync'd peer.
-   *
-   * This means that we consider ourselves synced (and hence subscribe to all subnets and block
-   * gossip if no peers are further than this range ahead of us that we have not already downloaded
-   * blocks for.
-   */
-  slotImportTolerance?: number;
-};
-
-export const defaultSyncOptions: SyncOptions = {
-  isSingleNode: false,
-  disableProcessAsChainSegment: false,
-  /** By default skip the backfill sync */
-  backfillBatchSize: 0,
-  slotImportTolerance: SLOTS_PER_EPOCH,
-};