@lodestar/beacon-node

import { PubkeyIndexMap } from "@chainsafe/pubkey-index-map"; import { CompositeTypeAny, TreeView, Type } from "@chainsafe/ssz"; import { BeaconConfig } from "@lodestar/config"; import { CheckpointWithHex, IForkChoice, ProtoBlock } from "@lodestar/fork-choice"; import { BeaconStateAllForks, CachedBeaconStateAllForks, EpochShuffling, Index2PubkeyCache } from "@lodestar/state-transition"; import { BeaconBlock, BlindedBeaconBlock, Epoch, ExecutionPayload, Root, RootHex, SignedBeaconBlock, Slot, UintNum64, ValidatorIndex, Wei, altair, capella, deneb, phase0 } from "@lodestar/types"; import { Logger } from "@lodestar/utils"; import { IEth1ForBlockProduction } from "../eth1/index.js"; import { IExecutionBuilder, IExecutionEngine } from "../execution/index.js"; import { Metrics } from "../metrics/metrics.js"; import { BufferPool } from "../util/bufferPool.js"; import { IClock } from "../util/clock.js"; import { SerializedCache } from "../util/serializedCache.js"; import { IArchiveStore } from "./archiveStore/interface.js"; import { CheckpointBalancesCache } from "./balancesCache.js"; import { BeaconProposerCache, ProposerPreparationData } from "./beaconProposerCache.js"; import { BlockInput, ImportBlockOpts } from "./blocks/types.js"; import { IBlsVerifier } from "./bls/index.js"; import { ChainEventEmitter } from "./emitter.js"; import { ForkchoiceCaller } from "./forkChoice/index.js"; import { LightClientServer } from "./lightClient/index.js"; import { AggregatedAttestationPool } from "./opPools/aggregatedAttestationPool.js"; import { AttestationPool, OpPool, SyncCommitteeMessagePool, SyncContributionAndProofPool } from "./opPools/index.js"; import { IChainOptions } from "./options.js"; import { AssembledBlockType, BlockAttributes, BlockType } from "./produceBlock/produceBlockBody.js"; import { IStateRegenerator, RegenCaller } from "./regen/index.js"; import { ReprocessController } from "./reprocess.js"; import { AttestationsRewards } from "./rewards/attestationsRewards.js"; import { BlockRewards } from "./rewards/blockRewards.js"; import { SyncCommitteeRewards } from "./rewards/syncCommitteeRewards.js"; import { SeenAggregators, SeenAttesters, SeenBlockProposers, SeenContributionAndProof, SeenSyncCommitteeMessages } from "./seenCache/index.js"; import { SeenGossipBlockInput } from "./seenCache/index.js"; import { SeenAggregatedAttestations } from "./seenCache/seenAggregateAndProof.js"; import { SeenAttestationDatas } from "./seenCache/seenAttestationData.js"; import { SeenBlockAttesters } from "./seenCache/seenBlockAttesters.js"; import { SeenBlockInputCache } from "./seenCache/seenBlockInput.js"; import { ShufflingCache } from "./shufflingCache.js"; import { ValidatorMonitor } from "./validatorMonitor.js"; export { BlockType, type AssembledBlockType }; export { type ProposerPreparationData }; export type BlockHash = RootHex; export type StateGetOpts = { allowRegen: boolean; }; export declare enum FindHeadFnName { recomputeForkChoiceHead = "recomputeForkChoiceHead", predictProposerHead = "predictProposerHead", getProposerHead = "getProposerHead" } /** * The IBeaconChain service deals with processing incoming blocks, advancing a state transition * and applying the fork choice rule to update the chain head */ export interface IBeaconChain { readonly genesisTime: UintNum64; readonly genesisValidatorsRoot: Root; readonly eth1: IEth1ForBlockProduction; readonly executionEngine: IExecutionEngine; readonly executionBuilder?: IExecutionBuilder; readonly config: BeaconConfig; readonly logger: Logger; readonly metrics: Metrics | null; readonly validatorMonitor: ValidatorMonitor | null; readonly bufferPool: BufferPool | null; /** The initial slot that the chain is started with */ readonly anchorStateLatestBlockSlot: Slot; readonly bls: IBlsVerifier; readonly forkChoice: IForkChoice; readonly clock: IClock; readonly emitter: ChainEventEmitter; readonly regen: IStateRegenerator; readonly lightClientServer?: LightClientServer; readonly reprocessController: ReprocessController; readonly pubkey2index: PubkeyIndexMap; readonly index2pubkey: Index2PubkeyCache; readonly archiveStore: IArchiveStore; readonly attestationPool: AttestationPool; readonly aggregatedAttestationPool: AggregatedAttestationPool; readonly syncCommitteeMessagePool: SyncCommitteeMessagePool; readonly syncContributionAndProofPool: SyncContributionAndProofPool; readonly opPool: OpPool; readonly seenAttesters: SeenAttesters; readonly seenAggregators: SeenAggregators; readonly seenAggregatedAttestations: SeenAggregatedAttestations; readonly seenBlockProposers: SeenBlockProposers; readonly seenSyncCommitteeMessages: SeenSyncCommitteeMessages; readonly seenContributionAndProof: SeenContributionAndProof; readonly seenAttestationDatas: SeenAttestationDatas; readonly seenBlockInputCache: SeenBlockInputCache; readonly seenGossipBlockInput: SeenGossipBlockInput; readonly seenBlockAttesters: SeenBlockAttesters; readonly beaconProposerCache: BeaconProposerCache; readonly checkpointBalancesCache: CheckpointBalancesCache; readonly producedContentsCache: Map<BlockHash, deneb.Contents>; readonly producedBlockRoot: Map<RootHex, ExecutionPayload | null>; readonly shufflingCache: ShufflingCache; readonly producedBlindedBlockRoot: Set<RootHex>; readonly blacklistedBlocks: Map<RootHex, Slot | null>; readonly serializedCache: SerializedCache; readonly opts: IChainOptions; /** Start the processing of chain and load state from disk and related actions */ init(): Promise<void>; /** Stop beacon chain processing */ close(): Promise<void>; /** Chain has seen the specified block root or not. The block may not be processed yet, use forkchoice.hasBlock to check it */ seenBlock(blockRoot: RootHex): boolean; /** Populate in-memory caches with persisted data. Call at least once on startup */ loadFromDisk(): Promise<void>; /** Persist in-memory data to the DB. Call at least once before stopping the process */ persistToDisk(): Promise<void>; validatorSeenAtEpoch(index: ValidatorIndex, epoch: Epoch): boolean; getHeadState(): CachedBeaconStateAllForks; getHeadStateAtCurrentEpoch(regenCaller: RegenCaller): Promise<CachedBeaconStateAllForks>; getHeadStateAtEpoch(epoch: Epoch, regenCaller: RegenCaller): Promise<CachedBeaconStateAllForks>; getHistoricalStateBySlot(slot: Slot): Promise<{ state: Uint8Array; executionOptimistic: boolean; finalized: boolean; } | null>; /** Returns a local state canonical at `slot` */ getStateBySlot(slot: Slot, opts?: StateGetOpts): Promise<{ state: BeaconStateAllForks; executionOptimistic: boolean; finalized: boolean; } | null>; /** Returns a local state by state root */ getStateByStateRoot(stateRoot: RootHex, opts?: StateGetOpts): Promise<{ state: BeaconStateAllForks; executionOptimistic: boolean; finalized: boolean; } | null>; /** Returns a cached state by checkpoint */ getStateByCheckpoint(checkpoint: CheckpointWithHex): { state: BeaconStateAllForks; executionOptimistic: boolean; finalized: boolean; } | null; /** Return state bytes by checkpoint */ getStateOrBytesByCheckpoint(checkpoint: CheckpointWithHex): Promise<{ state: CachedBeaconStateAllForks | Uint8Array; executionOptimistic: boolean; finalized: boolean; } | null>; /** * Since we can have multiple parallel chains, * this methods returns blocks in current chain head according to * forkchoice. Works for finalized slots as well */ getCanonicalBlockAtSlot(slot: Slot): Promise<{ block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean; } | null>; /** * Get local block by root, does not fetch from the network */ getBlockByRoot(root: RootHex): Promise<{ block: SignedBeaconBlock; executionOptimistic: boolean; finalized: boolean; } | null>; getContents(beaconBlock: deneb.BeaconBlock): deneb.Contents; produceCommonBlockBody(blockAttributes: BlockAttributes): Promise<CommonBlockBody>; produceBlock(blockAttributes: BlockAttributes & { commonBlockBodyPromise?: Promise<CommonBlockBody>; }): Promise<{ block: BeaconBlock; executionPayloadValue: Wei; consensusBlockValue: Wei; shouldOverrideBuilder?: boolean; }>; produceBlindedBlock(blockAttributes: BlockAttributes & { commonBlockBodyPromise?: Promise<CommonBlockBody>; }): Promise<{ block: BlindedBeaconBlock; executionPayloadValue: Wei; consensusBlockValue: Wei; }>; /** Process a block until complete */ processBlock(block: BlockInput, opts?: ImportBlockOpts): Promise<void>; /** Process a chain of blocks until complete */ processChainSegment(blocks: BlockInput[], opts?: ImportBlockOpts): Promise<void>; getStatus(): phase0.Status; recomputeForkChoiceHead(caller: ForkchoiceCaller): ProtoBlock; /** When proposerBoostReorg is enabled, this is called at slot n-1 to predict the head block to build on if we are proposing at slot n */ predictProposerHead(slot: Slot): ProtoBlock; /** When proposerBoostReorg is enabled and we are proposing a block, this is called to determine which head block to build on */ getProposerHead(slot: Slot): ProtoBlock; waitForBlock(slot: Slot, root: RootHex): Promise<boolean>; updateBeaconProposerData(epoch: Epoch, proposers: ProposerPreparationData[]): Promise<void>; persistBlock(data: BeaconBlock | BlindedBeaconBlock, suffix?: string): void; persistInvalidStateRoot(preState: CachedBeaconStateAllForks, postState: CachedBeaconStateAllForks, block: SignedBeaconBlock): Promise<void>; persistInvalidSszValue<T>(type: Type<T>, sszObject: T | Uint8Array, suffix?: string): void; persistInvalidSszBytes(type: string, sszBytes: Uint8Array, suffix?: string): void; /** Persist bad items to persistInvalidSszObjectsDir dir, for example invalid state, attestations etc. */ persistInvalidSszView(view: TreeView<CompositeTypeAny>, suffix?: string): void; regenStateForAttestationVerification(attEpoch: Epoch, shufflingDependentRoot: RootHex, attHeadBlock: ProtoBlock, regenCaller: RegenCaller): Promise<EpochShuffling>; updateBuilderStatus(clockSlot: Slot): void; regenCanAcceptWork(): boolean; blsThreadPoolCanAcceptWork(): boolean; getBlockRewards(blockRef: BeaconBlock | BlindedBeaconBlock): Promise<BlockRewards>; getAttestationsRewards(epoch: Epoch, validatorIds?: (ValidatorIndex | string)[]): Promise<{ rewards: AttestationsRewards; executionOptimistic: boolean; finalized: boolean; }>; getSyncCommitteeRewards(blockRef: BeaconBlock | BlindedBeaconBlock, validatorIds?: (ValidatorIndex | string)[]): Promise<SyncCommitteeRewards>; } export type SSZObjectType = "state" | "signedBlock" | "block" | "attestation" | "signedAggregatedAndProof" | "syncCommittee" | "contributionAndProof"; export type CommonBlockBody = phase0.BeaconBlockBody & Pick<capella.BeaconBlockBody, "blsToExecutionChanges"> & Pick<altair.BeaconBlockBody, "syncAggregate">; //# sourceMappingURL=interface.d.ts.map