public void SetUp()
{
_stepDelay = TimeSpan.FromMilliseconds(20);
_pendingTxSelector = Substitute.For <IPendingTxSelector>();
_blockchainProcessor = Substitute.For <IBlockchainProcessor>();
_sealer = Substitute.For <ISealer>();
_blockTree = Substitute.For <IBlockTree>();
_blockProcessingQueue = Substitute.For <IBlockProcessingQueue>();
_stateProvider = Substitute.For <IStateProvider>();
_timestamper = Substitute.For <ITimestamper>();
_auRaStepCalculator = Substitute.For <IAuRaStepCalculator>();
_auraConfig = Substitute.For <IAuraConfig>();
_nodeAddress = TestItem.AddressA;
_auRaBlockProducer = new AuRaBlockProducer(
_pendingTxSelector,
_blockchainProcessor,
_stateProvider,
_sealer,
_blockTree,
_blockProcessingQueue,
_timestamper,
LimboLogs.Instance, _auRaStepCalculator, _auraConfig, _nodeAddress);
_auraConfig.ForceSealing.Returns(true);
_pendingTxSelector.SelectTransactions(Arg.Any <long>()).Returns(Array.Empty <Transaction>());
_sealer.CanSeal(Arg.Any <long>(), Arg.Any <Keccak>()).Returns(true);
_sealer.SealBlock(Arg.Any <Block>(), Arg.Any <CancellationToken>()).Returns(c => Task.FromResult(c.Arg <Block>()));
_blockProcessingQueue.IsEmpty.Returns(true);
_auRaStepCalculator.TimeToNextStep.Returns(_stepDelay);
_blockTree.BestKnownNumber.Returns(1);
_blockTree.Head.Returns(Build.A.BlockHeader.WithAura(10, Bytes.Empty).TestObject);
_blockchainProcessor.Process(Arg.Any <Block>(), ProcessingOptions.ProducingBlock, Arg.Any <IBlockTracer>()).Returns(c => c.Arg <Block>());
}
public void InitProducer(IAuraConfig auraConfig)
{
AuRaBlockProducer = new AuRaBlockProducer(
TransactionSource,
BlockchainProcessor,
StateProvider,
Sealer,
BlockTree,
BlockProcessingQueue,
Timestamper,
LimboLogs.Instance,
AuRaStepCalculator,
auraConfig,
NodeAddress);
}
public void InitProducer(IAuraConfig auraConfig)
{
AuRaBlockProducer = new AuRaBlockProducer(
TransactionSource,
BlockchainProcessor,
StateProvider,
Sealer,
BlockTree,
BlockProcessingQueue,
Timestamper,
AuRaStepCalculator,
NullReportingValidator.Instance,
auraConfig,
FollowOtherMiners.Instance,
LimboLogs.Instance);
}
public Task <IBlockProducer> BuildProducer(IBlockProductionTrigger blockProductionTrigger, ITxSource?additionalTxSource = null)
{
if (_api.EngineSigner == null)
{
throw new StepDependencyException(nameof(_api.EngineSigner));
}
if (_api.ChainSpec == null)
{
throw new StepDependencyException(nameof(_api.ChainSpec));
}
ILogger logger = _api.LogManager.GetClassLogger();
if (logger.IsWarn)
{
logger.Warn("Starting AuRa block producer & sealer");
}
BlockProducerEnv producerEnv = GetProducerChain(additionalTxSource);
IGasLimitCalculator gasLimitCalculator = _api.GasLimitCalculator = CreateGasLimitCalculator(producerEnv.ReadOnlyTxProcessingEnv);
IBlockProducer blockProducer = new AuRaBlockProducer(
producerEnv.TxSource,
producerEnv.ChainProcessor,
blockProductionTrigger,
producerEnv.ReadOnlyStateProvider,
_api.Sealer,
_api.BlockTree,
_api.Timestamper,
StepCalculator,
_api.ReportingValidator,
_auraConfig,
gasLimitCalculator,
_api.SpecProvider,
_api.LogManager);
return(Task.FromResult(blockProducer));
}
public async Task AuraTestBlockProducer_IsProducingBlocks_returns_expected_results()
{
IBlockProcessingQueue blockProcessingQueue = Substitute.For <IBlockProcessingQueue>();
blockProcessingQueue.IsEmpty.Returns(true);
AuRaBlockProducer blockProducer = new AuRaBlockProducer(
Substitute.For <ITxSource>(),
Substitute.For <IBlockchainProcessor>(),
Substitute.For <IStateProvider>(),
Substitute.For <ISealer>(),
Substitute.For <IBlockTree>(),
Substitute.For <IBlockProcessingQueue>(),
Substitute.For <ITimestamper>(),
Substitute.For <IAuRaStepCalculator>(),
Substitute.For <IReportingValidator>(),
new AuRaConfig(),
Substitute.For <IGasLimitCalculator>(),
Substitute.For <ISpecProvider>(),
LimboLogs.Instance);
await AssertIsProducingBlocks(blockProducer);
}
