@lodestar/beacon-node 1.34.0-dev.0c7dfe25ea → 1.34.0-dev.11ca515d52

package/lib/sync/unknownBlock.d.ts

@@ -1,8 +1,12 @@
 import { ChainForkConfig } from "@lodestar/config";
 import { Logger } from "@lodestar/utils";
+import { BlockInput, NullBlockInput } from "../chain/blocks/types.js";
 import { IBeaconChain } from "../chain/index.js";
 import { Metrics } from "../metrics/index.js";
 import { INetwork } from "../network/index.js";
+import { PeerSyncMeta } from "../network/peers/peersData.js";
+import { CustodyConfig } from "../util/dataColumns.js";
+import { PeerIdStr } from "../util/peerId.js";
 import { SyncOptions } from "./options.js";
 export declare class UnknownBlockSync {
     private readonly config;
@@ -21,6 +25,7 @@ export declare class UnknownBlockSync {
     private subscribedToNetworkEvents;
     private engineGetBlobsCache;
     private blockInputsRetryTrackerCache;
+    private peerBalancer;
     constructor(config: ChainForkConfig, network: INetwork, chain: IBeaconChain, logger: Logger, metrics: Metrics | null, opts?: SyncOptions | undefined);
     subscribeToNetwork(): void;
     unsubscribeFromNetwork(): void;
@@ -40,13 +45,15 @@ export declare class UnknownBlockSync {
     private onUnknownParent;
     /**
      * When a blockInput comes with  an unknown parent:
-     * - add the block to pendingBlocks with status downloaded, blockRootHex as key. This is similar to
+     * - add the block to pendingBlocks with status downloaded or pending blockRootHex as key. This is similar to
      * an `onUnknownBlock` event, but the blocks is downloaded.
      * - add the parent root to pendingBlocks with status pending, parentBlockRootHex as key. This is
      * the same to an `onUnknownBlock` event with parentBlockRootHex as root.
      */
     private addUnknownParent;
     private addUnknownBlock;
+    private onPeerConnected;
+    private onPeerDisconnected;
     /**
      * Gather tip parent blocks with unknown parent and do a search for all of them
      */
@@ -55,6 +62,7 @@ export declare class UnknownBlockSync {
     /**
      * Send block to the processor awaiting completition. If processed successfully, send all children to the processor.
      * On error, remove and downscore all descendants.
+     * This function could run recursively for all descendant blocks
      */
     private processBlock;
     /**
@@ -63,7 +71,7 @@ export declare class UnknownBlockSync {
      *   - from deneb, fetch all missing blobs
      *   - from peerDAS, fetch sampled colmns
      * TODO: this means we only have block root, and nothing else. Consider to reflect this in the function name
-     * Will attempt a max of `MAX_ATTEMPTS_PER_BLOCK` on different peers if connectPeers.length > MAX_ATTEMPTS_PER_BLOCK.
+     * prefulu, will attempt a max of `MAX_ATTEMPTS_PER_BLOCK` on different peers, postfulu we may attempt more as defined in `getMaxDownloadAttempts()` function
      * Also verifies the received block root + returns the peer that provided the block for future downscoring.
      */
     private fetchUnknownBlockRoot;
@@ -71,8 +79,7 @@ export declare class UnknownBlockSync {
      * We have partial block input:
      * - we have block but not have all blobs (deneb) or needed columns (fulu)
      * - we don't have block and have some blobs (deneb) or some columns (fulu)
-     * Fetches missing blobs for the blockinput, in future can also pull block is thats also missing
-     * along with the blobs (i.e. only some blobs are available)
+     * Fetches missing block/data columns/block for the blockinput. This function returns either preData or availableData BlockInput.
      */
     private fetchUnavailableBlockInput;
     /**
@@ -83,5 +90,40 @@ export declare class UnknownBlockSync {
      */
     private removeAndDownscoreAllDescendants;
     private removeAllDescendants;
+    private getMaxDownloadAttempts;
+}
+/**
+ * Class to track active byRoots requests and balance them across eligible peers.
+ */
+export declare class UnknownBlockPeerBalancer {
+    readonly peersMeta: Map<PeerIdStr, PeerSyncMeta>;
+    readonly activeRequests: Map<PeerIdStr, number>;
+    private readonly custodyConfig;
+    constructor(custodyConfig: CustodyConfig);
+    /** Trigger on each peer re-status */
+    onPeerConnected(peerId: PeerIdStr, syncMeta: PeerSyncMeta): void;
+    onPeerDisconnected(peerId: PeerIdStr): void;
+    /**
+     * called from fetchUnknownBlockRoot() where we only have block root and nothing else
+     * excludedPeers are the peers that we requested already so we don't want to try again
+     * pendingColumns is empty for prefulu, or the 1st time we we download a block by root
+     */
+    bestPeerForPendingColumns(pendingColumns: Set<number> | null, excludedPeers: Set<PeerIdStr>): PeerSyncMeta | null;
+    /**
+     * called from fetchUnavailableBlockInput() where we have either BlockInput or NullBlockInput
+     * excludedPeers are the peers that we requested already so we don't want to try again
+     */
+    bestPeerForBlockInput(unavailableBlockInput: BlockInput | NullBlockInput, excludedPeers: Set<PeerIdStr>): PeerSyncMeta | null;
+    /**
+     * Consumers don't need to call this method directly, it is called internally by bestPeer*() methods
+     * make this public for testing
+     */
+    onRequest(peerId: PeerIdStr): void;
+    /**
+     * Consumers should call this method when a request is completed for a peer.
+     */
+    onRequestCompleted(peerId: PeerIdStr): void;
+    getTotalActiveRequests(): number;
+    private filterPeers;
 }
 //# sourceMappingURL=unknownBlock.d.ts.map