public MergeSealValidator(
IPoSSwitcher poSSwitcher,
ISealValidator preMergeSealValidator)
{
_poSSwitcher = poSSwitcher;
_preMergeSealValidator = preMergeSealValidator;
}
public MergeUnclesValidator(
IPoSSwitcher poSSwitcher,
IUnclesValidator preMergeUnclesValidator)
{
_poSSwitcher = poSSwitcher;
_preMergeUnclesValidator = preMergeUnclesValidator;
}
public ExchangeTransitionConfigurationV1Handler(
IPoSSwitcher poSSwitcher,
ILogManager logManager)
{
_poSSwitcher = poSSwitcher;
_logger = logManager.GetClassLogger();
}
public void Should_allocate_by_speed_post_merge()
{
ulong[] totalDifficulties = { 1, 3, 2 };
int[] averageSpeed = { 5, 8, 10 };
PublicKey[] publicKeys = { TestItem.PublicKeyA, TestItem.PublicKeyB, TestItem.PublicKeyC };
PeerInfo[] peers = new PeerInfo[3];
INodeStatsManager _nodeStatsManager = Substitute.For <INodeStatsManager>();
for (int i = 0; i < 3; i++)
{
ISyncPeer syncPeer = Substitute.For <ISyncPeer>();
syncPeer.IsInitialized.Returns(true);
Node node = new Node(publicKeys[i], "192.168.1.18", i);
syncPeer.Node.Returns(node);
syncPeer.TotalDifficulty.Returns(new UInt256(totalDifficulties[i]));
peers[i] = new PeerInfo(syncPeer);
peers[i].HeadNumber.Returns(1);
INodeStats nodeStats = Substitute.For <INodeStats>();
nodeStats.GetAverageTransferSpeed(Arg.Any <TransferSpeedType>()).Returns(averageSpeed[i]);
_nodeStatsManager.GetOrAdd(peers[i].SyncPeer.Node).Returns(nodeStats);
}
IPoSSwitcher poSSwitcher = Substitute.For <IPoSSwitcher>();
poSSwitcher.TerminalTotalDifficulty.Returns(new UInt256(1));
poSSwitcher.HasEverReachedTerminalBlock().Returns(true);
IBeaconPivot beaconPivot = Substitute.For <IBeaconPivot>();
IPeerAllocationStrategy mergePeerAllocationStrategy =
(new MergeBlocksSyncPeerAllocationStrategyFactory(poSSwitcher, beaconPivot, Substitute.For <ILogManager>())).Create(new BlocksRequest());
IBlockTree _blockTree = Substitute.For <IBlockTree>();
PeerInfo? info = mergePeerAllocationStrategy.Allocate(null, peers, _nodeStatsManager, _blockTree);
Assert.AreEqual(info, peers[2]); // peer with highest highest speed
}
public MergeBlockDownloaderFactory(IPoSSwitcher poSSwitcher,
IBeaconPivot beaconPivot,
ISpecProvider specProvider,
IBlockTree blockTree,
IBlockCacheService blockCacheService,
IReceiptStorage receiptStorage,
IBlockValidator blockValidator,
ISealValidator sealValidator,
ISyncPeerPool peerPool,
ISyncConfig syncConfig,
IBetterPeerStrategy betterPeerStrategy,
ISyncReport syncReport,
ISyncProgressResolver syncProgressResolver,
ILogManager logManager)
{
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_beaconPivot = beaconPivot ?? throw new ArgumentNullException(nameof(beaconPivot));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_sealValidator = sealValidator ?? throw new ArgumentNullException(nameof(sealValidator));
_syncPeerPool = peerPool ?? throw new ArgumentNullException(nameof(peerPool));
_betterPeerStrategy = betterPeerStrategy ?? throw new ArgumentNullException(nameof(betterPeerStrategy));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_syncReport = syncReport ?? throw new ArgumentNullException(nameof(syncReport));
_chainLevelHelper = new ChainLevelHelper(_blockTree, _beaconPivot, syncConfig, _logManager);
_syncProgressResolver = syncProgressResolver ?? throw new ArgumentNullException(nameof(syncProgressResolver));;
}
public MergeBlockDownloader(
IPoSSwitcher posSwitcher,
IBeaconPivot beaconPivot,
ISyncFeed <BlocksRequest?>?feed,
ISyncPeerPool?syncPeerPool,
IBlockTree?blockTree,
IBlockValidator?blockValidator,
ISealValidator?sealValidator,
ISyncReport?syncReport,
IReceiptStorage?receiptStorage,
ISpecProvider specProvider,
IBetterPeerStrategy betterPeerStrategy,
IChainLevelHelper chainLevelHelper,
ISyncProgressResolver syncProgressResolver,
ILogManager logManager)
: base(feed, syncPeerPool, blockTree, blockValidator, sealValidator, syncReport, receiptStorage,
specProvider, new MergeBlocksSyncPeerAllocationStrategyFactory(posSwitcher, beaconPivot, logManager),
betterPeerStrategy, logManager)
{
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_chainLevelHelper = chainLevelHelper ?? throw new ArgumentNullException(nameof(chainLevelHelper));
_poSSwitcher = posSwitcher ?? throw new ArgumentNullException(nameof(posSwitcher));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_syncReport = syncReport ?? throw new ArgumentNullException(nameof(syncReport));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_beaconPivot = beaconPivot;
_receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, logManager), specProvider);
_syncProgressResolver = syncProgressResolver ?? throw new ArgumentNullException(nameof(syncProgressResolver));
_logger = logManager.GetClassLogger();
}
public AuRaMergeBlockProcessor(
IPoSSwitcher poSSwitcher,
ISpecProvider specProvider,
IBlockValidator blockValidator,
IRewardCalculator rewardCalculator,
IBlockProcessor.IBlockTransactionsExecutor blockTransactionsExecutor,
IStateProvider stateProvider,
IStorageProvider storageProvider,
IReceiptStorage receiptStorage,
ILogManager logManager,
IBlockTree blockTree,
ITxFilter?txFilter = null,
AuRaContractGasLimitOverride?gasLimitOverride = null,
ContractRewriter?contractRewriter = null
) : base(
specProvider,
blockValidator,
rewardCalculator,
blockTransactionsExecutor,
stateProvider,
storageProvider,
receiptStorage,
logManager,
blockTree,
txFilter,
gasLimitOverride,
contractRewriter
)
{
_poSSwitcher = poSSwitcher;
}
public MergeRewardCalculatorSource(
IRewardCalculatorSource?beforeTheMerge,
IPoSSwitcher poSSwitcher)
{
_beforeTheMerge = beforeTheMerge ?? throw new ArgumentNullException(nameof(beforeTheMerge));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
}
public virtual Task Init(INethermindApi nethermindApi)
{
_api = nethermindApi;
_mergeConfig = nethermindApi.Config <IMergeConfig>();
_syncConfig = nethermindApi.Config <ISyncConfig>();
_logger = _api.LogManager.GetClassLogger();
if (MergeEnabled)
{
if (_api.DbProvider == null)
{
throw new ArgumentException(nameof(_api.DbProvider));
}
if (_api.BlockTree == null)
{
throw new ArgumentException(nameof(_api.BlockTree));
}
if (_api.SpecProvider == null)
{
throw new ArgumentException(nameof(_api.SpecProvider));
}
if (_api.ChainSpec == null)
{
throw new ArgumentException(nameof(_api.ChainSpec));
}
if (_api.SealValidator == null)
{
throw new ArgumentException(nameof(_api.SealValidator));
}
EnsureJsonRpcUrl();
EnsureReceiptAvailable();
_blockCacheService = new BlockCacheService();
_poSSwitcher = new PoSSwitcher(
_mergeConfig,
_syncConfig,
_api.DbProvider.GetDb <IDb>(DbNames.Metadata),
_api.BlockTree,
_api.SpecProvider,
_api.LogManager);
_invalidChainTracker = new InvalidChainTracker.InvalidChainTracker(
_poSSwitcher,
_api.BlockTree,
_blockCacheService,
_api.LogManager);
_api.DisposeStack.Push(_invalidChainTracker);
_blockFinalizationManager = new ManualBlockFinalizationManager();
_api.RewardCalculatorSource = new MergeRewardCalculatorSource(
_api.RewardCalculatorSource ?? NoBlockRewards.Instance, _poSSwitcher);
_api.SealValidator = new MergeSealValidator(_poSSwitcher, _api.SealValidator);
_api.GossipPolicy = new MergeGossipPolicy(_api.GossipPolicy, _poSSwitcher, _blockCacheService);
_api.BlockPreprocessor.AddFirst(new MergeProcessingRecoveryStep(_poSSwitcher));
}
return(Task.CompletedTask);
}
public ForkchoiceUpdatedV1Handler(
IBlockTree blockTree,
IManualBlockFinalizationManager manualBlockFinalizationManager,
IPoSSwitcher poSSwitcher,
IPayloadPreparationService payloadPreparationService,
IBlockProcessingQueue processingQueue,
IBlockCacheService blockCacheService,
IInvalidChainTracker invalidChainTracker,
IMergeSyncController mergeSyncController,
IBeaconPivot beaconPivot,
IPeerRefresher peerRefresher,
ILogManager logManager)
{
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_manualBlockFinalizationManager = manualBlockFinalizationManager ?? throw new ArgumentNullException(nameof(manualBlockFinalizationManager));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_payloadPreparationService = payloadPreparationService;
_processingQueue = processingQueue;
_blockCacheService = blockCacheService;
_invalidChainTracker = invalidChainTracker;
_mergeSyncController = mergeSyncController;
_beaconPivot = beaconPivot;
_peerRefresher = peerRefresher;
_logger = logManager.GetClassLogger();
}
public MergeBlocksSyncPeerAllocationStrategyFactory(
IPoSSwitcher poSSwitcher,
IBeaconPivot beaconPivot,
ILogManager logManager)
{
_poSSwitcher = poSSwitcher;
_beaconPivot = beaconPivot;
_logManager = logManager;
}
public MergeGossipPolicy(
IGossipPolicy?apiGossipPolicy,
IPoSSwitcher?poSSwitcher,
IBlockCacheService blockCacheService)
{
_preMergeGossipPolicy = apiGossipPolicy ?? throw new ArgumentNullException(nameof(apiGossipPolicy));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_blockCacheService = blockCacheService ?? throw new ArgumentNullException(nameof(blockCacheService));
}
public MergePeerAllocationStrategy(
IPeerAllocationStrategy preMergeAllocationStrategy,
IPeerAllocationStrategy postMergeAllocationStrategy,
IPoSSwitcher poSSwitcher,
ILogManager logManager)
{
_preMergeAllocationStrategy = preMergeAllocationStrategy;
_postMergeAllocationStrategy = postMergeAllocationStrategy;
_poSSwitcher = poSSwitcher;
_logger = logManager.GetClassLogger();
}
public MergeSealEngine(
ISealEngine preMergeSealEngine,
IPoSSwitcher?poSSwitcher,
ISealValidator mergeSealValidator,
ILogManager?logManager)
{
_preMergeSealValidator =
preMergeSealEngine ?? throw new ArgumentNullException(nameof(preMergeSealEngine));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_mergeSealValidator = mergeSealValidator;
}
public MergeBetterPeerStrategy(
IBetterPeerStrategy preMergeBetterPeerStrategy,
IPoSSwitcher poSSwitcher,
IBeaconPivot beaconPivot,
ILogManager logManager)
{
_preMergeBetterPeerStrategy = preMergeBetterPeerStrategy;
_poSSwitcher = poSSwitcher;
_beaconPivot = beaconPivot;
_logger = logManager.GetClassLogger();
}
public MergeBlockProducer(IBlockProducer?preMergeProducer, IBlockProducer?postMergeBlockProducer, IPoSSwitcher?poSSwitcher)
{
_preMergeProducer = preMergeProducer;
_eth2BlockProducer = postMergeBlockProducer ?? throw new ArgumentNullException(nameof(postMergeBlockProducer));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_poSSwitcher.TerminalBlockReached += OnSwitchHappened;
if (HasPreMergeProducer)
{
_preMergeProducer !.BlockProduced += OnBlockProduced;
}
postMergeBlockProducer.BlockProduced += OnBlockProduced;
}
public MergeHeaderValidator(
IPoSSwitcher poSSwitcher,
IHeaderValidator preMergeHeaderValidator,
IBlockTree blockTree,
ISpecProvider specProvider,
ISealValidator sealValidator,
ILogManager logManager)
: base(blockTree, sealValidator, specProvider, logManager)
{
_poSSwitcher = poSSwitcher;
_preMergeHeaderValidator = preMergeHeaderValidator;
_blockTree = blockTree;
_specProvider = specProvider;
}
public void givenAnInvalidBlock_ifParentIsNotPostMerge_thenLastValidHashShouldBeZero()
{
IBlockFinder blockFinder = Substitute.For <IBlockFinder>();
IBlockCacheService blockCacheService = new BlockCacheService();
Keccak invalidBlock = Keccak.Compute("A");
BlockHeader parentBlockHeader = new BlockHeaderBuilder().TestObject;
blockCacheService.BlockCache[parentBlockHeader.Hash] = new Block(parentBlockHeader);
IPoSSwitcher poSSwitcher = Substitute.For <IPoSSwitcher>();
poSSwitcher.IsPostMerge(parentBlockHeader).Returns(false);
_tracker = new(poSSwitcher, blockFinder, blockCacheService, new TestLogManager()); // Small max section size, to make sure things propagate correctly
_tracker.OnInvalidBlock(invalidBlock, parentBlockHeader.Hash);
AssertInvalid(invalidBlock, Keccak.Zero);
}
public BeaconHeadersSyncFeed(
IPoSSwitcher poSSwitcher,
ISyncModeSelector syncModeSelector,
IBlockTree?blockTree,
ISyncPeerPool?syncPeerPool,
ISyncConfig?syncConfig,
ISyncReport?syncReport,
IPivot?pivot,
IMergeConfig?mergeConfig,
IInvalidChainTracker invalidChainTracker,
ILogManager logManager)
: base(syncModeSelector, blockTree, syncPeerPool, syncConfig, syncReport, logManager,
true) // alwaysStartHeaderSync = true => for the merge we're forcing header sync start. It doesn't matter if it is archive sync or fast sync
{
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
_pivot = pivot ?? throw new ArgumentNullException(nameof(pivot));
_mergeConfig = mergeConfig ?? throw new ArgumentNullException(nameof(mergeConfig));
_invalidChainTracker = invalidChainTracker;
_logger = logManager.GetClassLogger();
}
private MergeBetterPeerStrategy CreateStrategy(long?beaconPivotNum = null)
{
const long ttd = 5;
IPoSSwitcher poSSwitcher = Substitute.For <IPoSSwitcher>();
poSSwitcher.TerminalTotalDifficulty.Returns((UInt256)ttd);
IBeaconPivot beaconPivot = Substitute.For <IBeaconPivot>();
if (beaconPivotNum != null)
{
beaconPivot.BeaconPivotExists().Returns(true);
beaconPivot.PivotNumber.Returns((long)beaconPivotNum);
}
TotalDifficultyBetterPeerStrategy preMergeBetterPeerStrategy = new(LimboLogs.Instance);
MergeBetterPeerStrategy betterPeerStrategy = new(preMergeBetterPeerStrategy, poSSwitcher, beaconPivot, LimboLogs.Instance);
return(betterPeerStrategy);
}
public void givenAnInvalidBlock_WithUnknownParent_thenGetParentFromCache()
{
IBlockFinder blockFinder = Substitute.For <IBlockFinder>();
IBlockCacheService blockCacheService = new BlockCacheService();
BlockHeader parentBlockHeader = new BlockHeaderBuilder()
.TestObject;
BlockHeader blockHeader = new BlockHeaderBuilder()
.WithParentHash(parentBlockHeader.Hash).TestObject;
blockCacheService.BlockCache[blockHeader.Hash] = new Block(blockHeader);
blockCacheService.BlockCache[parentBlockHeader.Hash] = new Block(parentBlockHeader);
IPoSSwitcher alwaysPos = Substitute.For <IPoSSwitcher>();
alwaysPos.IsPostMerge(Arg.Any <BlockHeader>()).Returns(true);
_tracker = new(alwaysPos, blockFinder, blockCacheService, new TestLogManager()); // Small max section size, to make sure things propagate correctly
_tracker.OnInvalidBlock(blockHeader.Hash, null);
AssertInvalid(blockHeader.Hash, parentBlockHeader.Hash);
}
public MergeSynchronizer(
IDbProvider dbProvider,
ISpecProvider specProvider,
IBlockTree blockTree,
IReceiptStorage receiptStorage,
ISyncPeerPool peerPool,
INodeStatsManager nodeStatsManager,
ISyncModeSelector syncModeSelector,
ISyncConfig syncConfig,
ISnapProvider snapProvider,
IBlockDownloaderFactory blockDownloaderFactory,
IPivot pivot,
IPoSSwitcher poSSwitcher,
IMergeConfig mergeConfig,
IInvalidChainTracker invalidChainTracker,
ILogManager logManager,
ISyncReport syncReport)
: base(
dbProvider,
specProvider,
blockTree,
receiptStorage,
peerPool,
nodeStatsManager,
syncModeSelector,
syncConfig,
snapProvider,
blockDownloaderFactory,
pivot,
syncReport,
logManager)
{
_invalidChainTracker = invalidChainTracker;
_poSSwitcher = poSSwitcher;
_mergeConfig = mergeConfig;
}
public static bool BlockBeforeTerminalTotalDifficulty(this IPoSSwitcher poSSwitcher, BlockHeader blockHeader) => blockHeader.TotalDifficulty < poSSwitcher.TerminalTotalDifficulty;
public MergeFinalizationManager(IManualBlockFinalizationManager manualBlockFinalizationManager,
IBlockFinalizationManager?blockFinalizationManager, IPoSSwitcher poSSwitcher)
{
_manualBlockFinalizationManager = manualBlockFinalizationManager;
_auRaBlockFinalizationManager = blockFinalizationManager as IAuRaBlockFinalizationManager;
poSSwitcher.TerminalBlockReached += OnSwitchHappened;
if (poSSwitcher.HasEverReachedTerminalBlock())
{
IsPostMerge = true;
}
_manualBlockFinalizationManager.BlocksFinalized += OnBlockFinalized;
if (HasAuRaFinalizationManager)
{
_auRaBlockFinalizationManager !.BlocksFinalized += OnBlockFinalized;
}
}
public AuRaMergeTxFilter(IPoSSwitcher poSSwitcher, ITxFilter preMergeTxFilter, ITxFilter?postMergeTxFilter = null)
{
_poSSwitcher = poSSwitcher;
_preMergeTxFilter = preMergeTxFilter;
_postMergeTxFilter = postMergeTxFilter ?? NullTxFilter.Instance;
}
public MergeHealthHintService(IHealthHintService?healthHintService, IPoSSwitcher?poSSwitcher)
{
_healthHintService = healthHintService ?? throw new ArgumentNullException(nameof(healthHintService));
_poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher));
}
public static bool MisconfiguredTerminalTotalDifficulty(this IPoSSwitcher poSSwitcher) => poSSwitcher.TerminalTotalDifficulty is null;
private IBetterPeerStrategy CreateMergePeerChoiceStrategy(IPoSSwitcher poSSwitcher, IBeaconPivot beaconPivot)
{
TotalDifficultyBetterPeerStrategy preMergePeerStrategy = new(LimboLogs.Instance);
return(new MergeBetterPeerStrategy(preMergePeerStrategy, poSSwitcher, beaconPivot, LimboLogs.Instance));
}
public MergeProcessingRecoveryStep(
IPoSSwitcher poSSwitcher)
{
_poSSwitcher = poSSwitcher;
}
