public DevBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITxPool txPool,
ITimestamper timestamper,
ISpecProvider specProvider,
IMiningConfig miningConfig,
ILogManager logManager)
: base(
txSource,
processor,
new NethDevSealEngine(),
blockTree,
blockProcessingQueue,
stateProvider,
FollowOtherMiners.Instance,
timestamper,
specProvider,
logManager)
{
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_miningConfig = miningConfig ?? throw new ArgumentNullException(nameof(miningConfig));
_timer = new Timer(_timeout.TotalMilliseconds);
_timer.Elapsed += TimerOnElapsed;
_timer.AutoReset = false;
}
public AuRaBlockProducer(ITxSource txSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITimestamper timestamper,
IAuRaStepCalculator auRaStepCalculator,
IReportingValidator reportingValidator,
IAuraConfig config,
IGasLimitCalculator gasLimitCalculator,
ISpecProvider specProvider,
ILogManager logManager)
: base(
new ValidatedTxSource(txSource, logManager),
processor,
sealer,
blockTree,
blockProcessingQueue,
stateProvider,
timestamper,
gasLimitCalculator,
specProvider,
logManager,
"AuRa")
{
_auRaStepCalculator = auRaStepCalculator ?? throw new ArgumentNullException(nameof(auRaStepCalculator));
_reportingValidator = reportingValidator ?? throw new ArgumentNullException(nameof(reportingValidator));
_config = config ?? throw new ArgumentNullException(nameof(config));
_canProduce = _config.AllowAuRaPrivateChains ? 1 : 0;
}
public PostMergeBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IBlockTree blockTree,
IBlockProductionTrigger blockProductionTrigger,
IStateProvider stateProvider,
IGasLimitCalculator gasLimitCalculator,
ISealEngine sealEngine,
ITimestamper timestamper,
ISpecProvider specProvider,
ILogManager logManager)
: base(
txSource,
processor,
sealEngine,
blockTree,
blockProductionTrigger,
stateProvider,
gasLimitCalculator,
timestamper,
specProvider,
logManager,
ConstantDifficulty.Zero)
{
}
public GeneratedTxSource(ITxSource innerSource, ITxSealer txSealer, IStateReader stateReader, ILogManager logManager)
{
_innerSource = innerSource ?? throw new ArgumentNullException(nameof(innerSource));
_txSealer = txSealer ?? throw new ArgumentNullException(nameof(txSealer));
_stateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
_logger = logManager?.GetClassLogger <GeneratedTxSource>() ?? throw new ArgumentNullException(nameof(logManager));
}
public TestAuraProducer(ITxSource transactionSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITimestamper timestamper,
ILogManager logManager,
IAuRaStepCalculator auRaStepCalculator,
IReportingValidator reportingValidator,
IAuraConfig config,
ISpecProvider specProvider)
: base(
transactionSource,
processor,
stateProvider,
sealer,
blockTree,
blockProcessingQueue,
timestamper,
auRaStepCalculator,
reportingValidator,
config,
FollowOtherMiners.Instance,
specProvider,
logManager)
{
}
public void To_string_does_not_throw()
{
ITxSource txSource = Substitute.For <ITxSource>();
CompositeTxSource selector = new CompositeTxSource(txSource);
_ = selector.ToString();
}
public MinedBlockProducer(ITxSource txSource,
IBlockchainProcessor processor,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
IStateProvider stateProvider,
IGasLimitCalculator gasLimitCalculator,
ITimestamper timestamper,
ISpecProvider specProvider,
ILogManager logManager,
IDifficultyCalculator difficultyCalculator)
: base(
txSource,
processor,
sealer,
blockTree,
blockProcessingQueue,
stateProvider,
gasLimitCalculator,
timestamper,
specProvider,
logManager)
{
_difficultyCalculator = difficultyCalculator ?? throw new ArgumentNullException(nameof(difficultyCalculator));
}
protected LoopBlockProducerBase(
ITxSource txSource,
IBlockchainProcessor processor,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
IStateProvider stateProvider,
ITimestamper timestamper,
IGasLimitCalculator gasLimitCalculator,
ISpecProvider specProvider,
ILogManager logManager,
string name)
: base(
txSource,
processor,
sealer,
blockTree,
blockProcessingQueue,
stateProvider,
gasLimitCalculator,
timestamper,
specProvider,
logManager)
{
_name = name;
}
public GeneratedTxSourceApprover(ITxSource innerSource, IBasicWallet wallet, ITimestamper timestamper, IStateReader stateReader, int chainId)
{
_innerSource = innerSource ?? throw new ArgumentNullException(nameof(innerSource));
_wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
_timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
_stateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
_chainId = chainId;
}
public ValidatedTxSource(ITxSource innerSource, ILogManager logManager)
{
_innerSource = innerSource;
_logger = logManager.GetClassLogger();
if (_logger.IsDebug)
{
_logger.Debug($"Transaction sources used when building blocks: {this}");
}
}
public void Can_serve_one_by_one()
{
ITxSource source = Substitute.For <ITxSource>();
source.GetTransactions(null, 0).Returns(new Transaction[5]);
ITxSource oneByOne = source.ServeTxsOneByOne();
oneByOne.GetTransactions(null, 0).Count().Should().Be(1);
}
public DevBackgroundBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
IStateProvider stateProvider,
ITimestamper timestamper,
ILogManager logManager) : base(txSource, processor, NullSealEngine.Instance, blockTree, blockProcessingQueue, stateProvider, timestamper, logManager, "Dev")
{
}
public Eth2TestBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
IStateProvider stateProvider,
IGasLimitCalculator gasLimitCalculator,
ISigner signer, ILogManager logManager)
: base(txSource, processor, blockTree, blockProcessingQueue, stateProvider, gasLimitCalculator, signer, logManager)
{
}
public DevBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITxPool txPool,
ITimestamper timestamper,
ILogManager logManager)
: base(txSource, processor, NethDevSealEngine.Instance, blockTree, blockProcessingQueue, stateProvider, timestamper, logManager)
{
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
}
protected BaseLoopBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
IStateProvider stateProvider,
ITimestamper timestamper,
ILogManager logManager,
string name)
: base(txSource, processor, sealer, blockTree, blockProcessingQueue, stateProvider, timestamper, logManager)
{
_name = name;
}
public MevBundler(IBundleTrigger trigger, ITxSource txSource, IBundlePool bundlePool, ILogger logger)
{
_trigger = trigger;
_txSource = txSource;
_bundlePool = bundlePool;
_logger = logger;
if (_logger.IsInfo)
{
_logger.Info("Starting Mev Bundler for Account Abstraction");
}
_trigger.TriggerBundle += OnTriggerBundle;
}
public AuRaBlockProducer(
ITxSource txSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITimestamper timestamper,
ILogManager logManager,
IAuRaStepCalculator auRaStepCalculator,
IAuraConfig config,
Address nodeAddress)
: base(txSource, processor, sealer, blockTree, blockProcessingQueue, stateProvider, timestamper, logManager, "AuRa")
{
_auRaStepCalculator = auRaStepCalculator ?? throw new ArgumentNullException(nameof(auRaStepCalculator));
_config = config ?? throw new ArgumentNullException(nameof(config));
CanProduce = _config.AllowAuRaPrivateChains;
_nodeAddress = nodeAddress ?? throw new ArgumentNullException(nameof(nodeAddress));
}
public void Reseal_generated_transactions()
{
ITxSource innerSource = Substitute.For <ITxSource>();
ITxSealer txSealer = Substitute.For <ITxSealer>();
IStateReader stateReader = Substitute.For <IStateReader>();
BlockHeader parent = Build.A.BlockHeader.TestObject;
long gasLimit = long.MaxValue;
Transaction poolTx = Build.A.Transaction.WithSenderAddress(TestItem.AddressA).TestObject;
GeneratedTransaction generatedTx = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressB).TestObject;
innerSource.GetTransactions(parent, gasLimit).Returns(new[] { poolTx, generatedTx });
var txSource = new GeneratedTxSource(innerSource, txSealer, stateReader, LimboLogs.Instance);
txSource.GetTransactions(parent, gasLimit).ToArray();
txSealer.Received().Seal(generatedTx, TxHandlingOptions.ManagedNonce | TxHandlingOptions.AllowReplacingSignature);
txSealer.DidNotReceive().Seal(poolTx, Arg.Any <TxHandlingOptions>());
}
protected BlockProducerBase(
ITxSource?txSource,
IBlockchainProcessor?processor,
ISealer?sealer,
IBlockTree?blockTree,
IBlockProcessingQueue?blockProcessingQueue,
IStateProvider?stateProvider,
IGasLimitCalculator?gasLimitCalculator,
ITimestamper?timestamper,
ILogManager?logManager)
{
_txSource = txSource ?? throw new ArgumentNullException(nameof(txSource));
Processor = processor ?? throw new ArgumentNullException(nameof(processor));
Sealer = sealer ?? throw new ArgumentNullException(nameof(sealer));
BlockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
BlockProcessingQueue = blockProcessingQueue ?? throw new ArgumentNullException(nameof(blockProcessingQueue));
_stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
_gasLimitCalculator = gasLimitCalculator ?? throw new ArgumentNullException(nameof(gasLimitCalculator));
Timestamper = timestamper ?? throw new ArgumentNullException(nameof(timestamper));
Logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
}
public void transactions_are_addable_to_block_after_sealing()
{
int chainId = 5;
BlockHeader blockHeader = Build.A.BlockHeader.TestObject;
GeneratedTransaction tx1 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
GeneratedTransaction tx2 = Build.A.GeneratedTransaction.WithSenderAddress(TestItem.AddressA).TestObject;
ITimestamper timestamper = Substitute.For <ITimestamper>();
IStateReader stateReader = Substitute.For <IStateReader>();
Address nodeAddress = TestItem.AddressA;
UInt256 expectedNonce = 10;
stateReader.GetAccount(blockHeader.StateRoot, nodeAddress).Returns(Account.TotallyEmpty.WithChangedNonce(expectedNonce));
ulong expectedTimeStamp = 100;
timestamper.UnixTime.Returns(UnixTime.FromSeconds(expectedTimeStamp));
int gasLimit = 200;
ITxSource innerTxSource = Substitute.For <ITxSource>();
innerTxSource.GetTransactions(blockHeader, gasLimit).Returns(new[] { tx1, tx2 });
TxSealer txSealer = new(new Signer((ulong)chainId, Build.A.PrivateKey.TestObject, LimboLogs.Instance), timestamper);
GeneratedTxSource transactionFiller = new(innerTxSource, txSealer, stateReader, LimboLogs.Instance);
Transaction[] sealedTxs = transactionFiller.GetTransactions(blockHeader, gasLimit).ToArray();
Transaction sealedTx1 = sealedTxs.First();
Transaction sealedTx2 = sealedTxs.Skip(1).First();
sealedTx1.IsSigned.Should().BeTrue();
sealedTx1.Nonce.Should().Be(expectedNonce);
sealedTx1.Hash.Should().Be(tx1.CalculateHash());
sealedTx1.Timestamp.Should().Be(expectedTimeStamp);
sealedTx2.IsSigned.Should().BeTrue();
sealedTx2.Nonce.Should().Be(expectedNonce + 1);
sealedTx2.Hash.Should().NotBe(tx1.CalculateHash());
sealedTx2.Timestamp.Should().Be(expectedTimeStamp);
}
public TestBlockProducer(
ITxSource transactionSource,
IBlockchainProcessor processor,
IStateProvider stateProvider,
ISealer sealer,
IBlockTree blockTree,
IBlockProcessingQueue blockProcessingQueue,
ITimestamper timestamper,
ILogManager logManager)
: base(
transactionSource,
processor,
sealer,
blockTree,
blockProcessingQueue,
stateProvider,
timestamper,
FollowOtherMiners.Instance,
logManager,
"test producer")
{
}
public MinedBlockProducer(ITxSource txSource,
IBlockchainProcessor processor,
ISealer sealer,
IBlockTree blockTree,
IBlockProductionTrigger blockProductionTrigger,
IStateProvider stateProvider,
IGasLimitCalculator gasLimitCalculator,
ITimestamper timestamper,
ISpecProvider specProvider,
ILogManager logManager)
: base(
txSource,
processor,
sealer,
blockTree,
blockProductionTrigger,
stateProvider,
gasLimitCalculator,
timestamper,
specProvider,
logManager,
new EthashDifficultyCalculator(specProvider))
{
}
public Eth2BlockProducer(ITxSource txSource,
IBlockchainProcessor processor,
IBlockTree blockTree,
IBlockProductionTrigger blockProductionTrigger,
IStateProvider stateProvider,
IGasLimitCalculator gasLimitCalculator,
ISigner signer,
ITimestamper timestamper,
ISpecProvider specProvider,
ILogManager logManager)
: base(
txSource,
processor,
new Eth2SealEngine(signer),
blockTree,
blockProductionTrigger,
stateProvider,
gasLimitCalculator,
timestamper,
specProvider,
logManager,
ConstantDifficultyCalculator.One)
{
}
