public void should_add_bundle_with_correct_timestamps()
{
ITimestamper timestamper = new ManualTimestamper(DateTime.UtcNow);
ulong timestamp = timestamper.UnixTime.Seconds;
TestContext test = new TestContext(timestamper);
BundleTransaction[] tx1 =
{
Build.A.TypedTransaction <BundleTransaction>().SignedAndResolved(TestItem.PrivateKeyD).TestObject
};
BundleTransaction[] tx2 =
{
Build.A.TypedTransaction <BundleTransaction>().SignedAndResolved(TestItem.PrivateKeyA).TestObject
};
MevConfig mevConfig = new MevConfig();
UInt256 bundleHorizon = mevConfig.BundleHorizon;
MevBundle[] bundles = new[]
{
new MevBundle(1, tx1, 0, 0), new MevBundle(2, tx1, timestamp + 5, timestamp), //min > max
new MevBundle(3, tx1, timestamp - 5, timestamp + 5),
new MevBundle(4, tx2, timestamp - 10, timestamp - 5), //max < curr
new MevBundle(4, tx2, timestamp + bundleHorizon, timestamp + bundleHorizon + 10),
new MevBundle(5, tx2, timestamp + bundleHorizon + 1, timestamp + bundleHorizon + 10) //min too large
};
bundles.Select(b => test.BundlePool.AddBundle(b))
.Should().BeEquivalentTo(new bool[] { true, false, true, false, true, false });
}
public MergeTestBlockchain(ManualTimestamper timestamper)
{
Timestamper = timestamper;
GenesisBlockBuilder = Core.Test.Builders.Build.A.Block.Genesis.Genesis
.WithTimestamp(UInt256.One);
Signer = new Eth2Signer(MinerAddress);
}
public AssembleBlockHandler(IBlockTree blockTree, IManualBlockProductionTrigger blockProductionTrigger, ManualTimestamper timestamper, ILogManager logManager)
{
_blockTree = blockTree;
_blockProductionTrigger = blockProductionTrigger;
_timestamper = timestamper;
_logger = logManager.GetClassLogger();
}
public async Task SetUp()
{
_dbProvider = await TestMemDbProvider.InitAsync();
_timestamper = new ManualTimestamper();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_transactionProcessor = Substitute.For <ITransactionProcessor>();
_ethereumEcdsa = Substitute.For <IEthereumEcdsa>();
_specProvider = MainnetSpecProvider.Instance;
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(_dbProvider, false),
new TrieStore(_dbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(_blockTree),
_specProvider,
LimboLogs.Instance);
processingEnv.TransactionProcessor = _transactionProcessor;
_blockchainBridge = new BlockchainBridge(
processingEnv,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_ethereumEcdsa,
_timestamper,
Substitute.For <ILogFinder>(),
false,
false);
}
public void step_is_calculated_correctly(long milliSeconds, int stepDuration)
{
var time = DateTimeOffset.FromUnixTimeMilliseconds(milliSeconds);
var timestamper = new ManualTimestamper(time.UtcDateTime);
var calculator = new AuRaStepCalculator(GetStepDurationsForSingleStep(stepDuration), timestamper, LimboLogs.Instance);
calculator.CurrentStep.Should().Be(time.ToUnixTimeSeconds() / stepDuration);
}
public void after_waiting_for_next_step_timeToNextStep_should_be_close_to_stepDuration_in_seconds(int stepDuration)
{
var manualTimestamper = new ManualTimestamper(DateTime.Now);
var calculator = new AuRaStepCalculator(GetStepDurationsForSingleStep(stepDuration), manualTimestamper, LimboLogs.Instance);
manualTimestamper.Add(calculator.TimeToNextStep);
calculator.TimeToNextStep.Should().BeCloseTo(TimeSpan.FromSeconds(stepDuration), TimeSpan.FromMilliseconds(200));
}
public void step_increases_after_timeToNextStep(int stepDuration)
{
var manualTimestamper = new ManualTimestamper(DateTime.Now);
var calculator = new AuRaStepCalculator(GetStepDurationsForSingleStep(stepDuration), manualTimestamper, LimboLogs.Instance);
var step = calculator.CurrentStep;
manualTimestamper.Add(calculator.TimeToNextStep);
calculator.CurrentStep.Should().Be(step + 1, calculator.TimeToNextStep.ToString());
}
public void Current_starting_from_non_zero()
{
ManualTimestamper manualTimestamper = new ManualTimestamper();
MeasuredProgress measuredProgress = new MeasuredProgress(manualTimestamper);
measuredProgress.Update(10L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(20L);
Assert.LessOrEqual(measuredProgress.CurrentPerSecond, 105M);
}
public void Update_twice_current_per_second()
{
ManualTimestamper manualTimestamper = new ManualTimestamper();
MeasuredProgress measuredProgress = new MeasuredProgress(manualTimestamper);
measuredProgress.Update(0L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(1L);
Assert.LessOrEqual(measuredProgress.CurrentPerSecond, 10M);
Assert.GreaterOrEqual(measuredProgress.CurrentPerSecond, 4M);
}
public void time_to_step_is_calculated_correctly(long milliSeconds, int stepDuration, int checkedStep)
{
const long currentStep = 50000030;
TimeSpan timeToNextStep = TimeSpan.FromMilliseconds(1995);
var time = DateTimeOffset.FromUnixTimeMilliseconds(milliSeconds);
var timestamper = new ManualTimestamper(time.UtcDateTime);
var calculator = new AuRaStepCalculator(GetStepDurationsForSingleStep(stepDuration), timestamper, LimboLogs.Instance);
TimeSpan expected = checkedStep <= currentStep?TimeSpan.FromMilliseconds(0) : TimeSpan.FromSeconds((checkedStep - currentStep - 1) * stepDuration) + timeToNextStep;
TestContext.Out.WriteLine($"Expected time to step {checkedStep} is {expected}");
calculator.TimeToStep(checkedStep).Should().Be(expected);
}
public async Task Update_thrice_result_per_second()
{
ManualTimestamper manualTimestamper = new ManualTimestamper();
MeasuredProgress measuredProgress = new MeasuredProgress(manualTimestamper);
measuredProgress.Update(0L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(1L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(3L);
Assert.GreaterOrEqual(measuredProgress.TotalPerSecond, 6M);
Assert.LessOrEqual(measuredProgress.TotalPerSecond, 15M);
Assert.GreaterOrEqual(measuredProgress.CurrentPerSecond, 6M);
Assert.LessOrEqual(measuredProgress.CurrentPerSecond, 30M);
}
public void GetBlockProcessorAndProducerIntervalHint_returns_expected_result(
[ValueSource(nameof(BlockProcessorIntervalHintTestCases))]
BlockProcessorIntervalHint test)
{
ManualTimestamper manualTimestamper = new ManualTimestamper(DateTime.Now);
AuRaStepCalculator stepCalculator = new AuRaStepCalculator(new Dictionary <long, long>()
{
{ 0, test.StepDuration }
}, manualTimestamper, LimboLogs.Instance);
IValidatorStore validatorStore = Substitute.For <IValidatorStore>();
validatorStore.GetValidators().Returns(new Address[test.ValidatorsCount]);
IHealthHintService healthHintService = new AuraHealthHintService(stepCalculator, validatorStore);
ulong?actualProcessing = healthHintService.MaxSecondsIntervalForProcessingBlocksHint();
ulong?actualProducing = healthHintService.MaxSecondsIntervalForProducingBlocksHint();
Assert.AreEqual(test.ExpectedProcessingHint, actualProcessing);
Assert.AreEqual(test.ExpectedProducingHint, actualProducing);
}
public void After_ending_does_not_update_total_or_current()
{
ManualTimestamper manualTimestamper = new ManualTimestamper();
MeasuredProgress measuredProgress = new MeasuredProgress(manualTimestamper);
measuredProgress.Update(0L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(1L);
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.Update(3L);
measuredProgress.MarkEnd();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.SetMeasuringPoint();
manualTimestamper.Add(TimeSpan.FromMilliseconds(100));
measuredProgress.SetMeasuringPoint();
Assert.GreaterOrEqual(measuredProgress.TotalPerSecond, 6M);
Assert.LessOrEqual(measuredProgress.TotalPerSecond, 15M);
Assert.AreEqual(0M, measuredProgress.CurrentPerSecond);
}
public void SetUp()
{
_dbProvider = new MemDbProvider();
_stateReader = new StateReader(_dbProvider.StateDb, _dbProvider.CodeDb, LimboLogs.Instance);
_stateProvider = new StateProvider(_dbProvider.StateDb, _dbProvider.CodeDb, LimboLogs.Instance);
_storageProvider = new StorageProvider(_dbProvider.StateDb, _stateProvider, LimboLogs.Instance);
_timestamper = new ManualTimestamper();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_wallet = Substitute.For <IWallet>();
_transactionProcessor = Substitute.For <ITransactionProcessor>();
_ethereumEcdsa = Substitute.For <IEthereumEcdsa>();
_bloomStorage = Substitute.For <IBloomStorage>();
_specProvider = MainnetSpecProvider.Instance;
_blockchainBridge = new BlockchainBridge(
_stateReader,
_stateProvider,
_storageProvider,
_blockTree,
_txPool,
_receiptStorage,
_filterStore,
_filterManager,
_wallet,
_transactionProcessor,
_ethereumEcdsa,
_bloomStorage,
_timestamper,
LimboLogs.Instance,
false);
}
public void Test()
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
DbProvider dbProvider = new(DbModeHint.Mem);
dbProvider.RegisterDb(DbNames.BlockInfos, new MemDb());
dbProvider.RegisterDb(DbNames.Blocks, new MemDb());
dbProvider.RegisterDb(DbNames.Headers, new MemDb());
dbProvider.RegisterDb(DbNames.State, new MemDb());
dbProvider.RegisterDb(DbNames.Code, new MemDb());
dbProvider.RegisterDb(DbNames.Metadata, new MemDb());
BlockTree blockTree = new(
dbProvider,
new ChainLevelInfoRepository(dbProvider),
specProvider,
NullBloomStorage.Instance,
LimboLogs.Instance);
TrieStore trieStore = new(
dbProvider.RegisteredDbs[DbNames.State],
NoPruning.Instance,
Archive.Instance,
LimboLogs.Instance);
StateProvider stateProvider = new(
trieStore,
dbProvider.RegisteredDbs[DbNames.Code],
LimboLogs.Instance);
StateReader stateReader = new(trieStore, dbProvider.GetDb <IDb>(DbNames.State), LimboLogs.Instance);
StorageProvider storageProvider = new(trieStore, stateProvider, LimboLogs.Instance);
BlockhashProvider blockhashProvider = new(blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new(
blockhashProvider,
specProvider,
LimboLogs.Instance);
TransactionProcessor txProcessor = new(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
LimboLogs.Instance);
BlockProcessor blockProcessor = new(
specProvider,
Always.Valid,
NoBlockRewards.Instance,
new BlockProcessor.BlockValidationTransactionsExecutor(txProcessor, stateProvider),
stateProvider,
storageProvider,
NullReceiptStorage.Instance,
NullWitnessCollector.Instance,
LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new(
blockTree,
blockProcessor,
NullRecoveryStep.Instance,
stateReader,
LimboLogs.Instance,
BlockchainProcessor.Options.Default);
BuildBlocksWhenRequested trigger = new();
ManualTimestamper timestamper = new ManualTimestamper();
DevBlockProducer devBlockProducer = new(
EmptyTxSource.Instance,
blockchainProcessor,
stateProvider,
blockTree,
trigger,
timestamper,
specProvider,
new MiningConfig {
Enabled = true
},
LimboLogs.Instance);
blockchainProcessor.Start();
devBlockProducer.Start();
ProducedBlockSuggester suggester = new ProducedBlockSuggester(blockTree, devBlockProducer);
AutoResetEvent autoResetEvent = new(false);
blockTree.NewHeadBlock += (s, e) => autoResetEvent.Set();
blockTree.SuggestBlock(Build.A.Block.Genesis.TestObject);
autoResetEvent.WaitOne(1000).Should().BeTrue("genesis");
trigger.BuildBlock();
autoResetEvent.WaitOne(1000).Should().BeTrue("1");
blockTree.Head.Number.Should().Be(1);
}
protected virtual async Task <TestBlockchain> Build(ISpecProvider specProvider = null)
{
Timestamper = new ManualTimestamper(new DateTime(2020, 2, 15, 12, 50, 30, DateTimeKind.Utc));
JsonSerializer = new EthereumJsonSerializer();
SpecProvider = specProvider ?? MainnetSpecProvider.Instance;
EthereumEcdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
DbProvider = new MemDbProvider();
State = new StateProvider(StateDb, CodeDb, LimboLogs.Instance);
State.CreateAccount(TestItem.AddressA, 1000.Ether());
State.CreateAccount(TestItem.AddressB, 1000.Ether());
State.CreateAccount(TestItem.AddressC, 1000.Ether());
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
State.UpdateCode(code);
State.UpdateCodeHash(TestItem.AddressA, codeHash, SpecProvider.GenesisSpec);
Storage = new StorageProvider(StateDb, State, LimboLogs.Instance);
Storage.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
Storage.Commit();
State.Commit(SpecProvider.GenesisSpec);
State.CommitTree();
TxPool = new TxPool.TxPool(txStorage, Timestamper, EthereumEcdsa, SpecProvider, new TxPoolConfig(), State, LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockDb), SpecProvider, TxPool, NullBloomStorage.Instance, LimboLogs.Instance);
ReceiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(State, Storage, new BlockhashProvider(BlockTree, LimboLogs.Instance), SpecProvider, LimboLogs.Instance);
TxProcessor = new TransactionProcessor(SpecProvider, State, Storage, virtualMachine, LimboLogs.Instance);
BlockProcessor = CreateBlockProcessor();
BlockchainProcessor chainProcessor = new BlockchainProcessor(BlockTree, BlockProcessor, new TxSignaturesRecoveryStep(EthereumEcdsa, TxPool, LimboLogs.Instance), LimboLogs.Instance, BlockchainProcessor.Options.Default);
chainProcessor.Start();
StateReader = new StateReader(StateDb, CodeDb, LimboLogs.Instance);
TxPoolTxSource txPoolTxSource = new TxPoolTxSource(TxPool, StateReader, LimboLogs.Instance);
ISealer sealer = new FakeSealer(TimeSpan.Zero);
BlockProducer = new TestBlockProducer(txPoolTxSource, chainProcessor, State, sealer, BlockTree, chainProcessor, Timestamper, LimboLogs.Instance);
BlockProducer.Start();
_resetEvent = new AutoResetEvent(false);
BlockTree.NewHeadBlock += (s, e) =>
{
Console.WriteLine(e.Block.Header.Hash);
_resetEvent.Set();
};
var genesis = GetGenesisBlock();
BlockTree.SuggestBlock(genesis);
await _resetEvent.WaitOneAsync(CancellationToken.None);
await AddBlocksOnStart();
return(this);
}
protected virtual async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
Timestamper = new ManualTimestamper(new DateTime(2020, 2, 15, 12, 50, 30, DateTimeKind.Utc));
JsonSerializer = new EthereumJsonSerializer();
SpecProvider = specProvider ?? MainnetSpecProvider.Instance;
EthereumEcdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
DbProvider = await TestMemDbProvider.InitAsync();
State = new StateProvider(StateDb, CodeDb, LimboLogs.Instance);
State.CreateAccount(TestItem.AddressA, (initialValues ?? 1000.Ether()));
State.CreateAccount(TestItem.AddressB, (initialValues ?? 1000.Ether()));
State.CreateAccount(TestItem.AddressC, (initialValues ?? 1000.Ether()));
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
State.UpdateCode(code);
State.UpdateCodeHash(TestItem.AddressA, codeHash, SpecProvider.GenesisSpec);
Storage = new StorageProvider(StateDb, State, LimboLogs.Instance);
Storage.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
Storage.Commit();
State.Commit(SpecProvider.GenesisSpec);
State.CommitTree();
TxPool = new TxPool.TxPool(
txStorage,
EthereumEcdsa,
SpecProvider,
new TxPoolConfig(),
new StateProvider(StateDb, CodeDb, LimboLogs.Instance),
LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
BlockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockDb), SpecProvider, NullBloomStorage.Instance, LimboLogs.Instance);
new OnChainTxWatcher(BlockTree, TxPool, SpecProvider, LimboLogs.Instance);
ReceiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(State, Storage, new BlockhashProvider(BlockTree, LimboLogs.Instance), SpecProvider, LimboLogs.Instance);
TxProcessor = new TransactionProcessor(SpecProvider, State, Storage, virtualMachine, LimboLogs.Instance);
BlockProcessor = CreateBlockProcessor();
BlockchainProcessor chainProcessor = new BlockchainProcessor(BlockTree, BlockProcessor, new RecoverSignatures(EthereumEcdsa, TxPool, SpecProvider, LimboLogs.Instance), LimboLogs.Instance, Nethermind.Blockchain.Processing.BlockchainProcessor.Options.Default);
BlockchainProcessor = chainProcessor;
chainProcessor.Start();
StateReader = new StateReader(StateDb, CodeDb, LimboLogs.Instance);
TxPoolTxSource txPoolTxSource = CreateTxPoolTxSource();
ISealer sealer = new NethDevSealEngine(TestItem.AddressD);
BlockProducer = new TestBlockProducer(txPoolTxSource, chainProcessor, State, sealer, BlockTree, chainProcessor, Timestamper, LimboLogs.Instance);
BlockProducer.Start();
_resetEvent = new SemaphoreSlim(0);
_suggestedBlockResetEvent = new ManualResetEvent(true);
BlockTree.NewHeadBlock += (s, e) =>
{
_resetEvent.Release(1);
};
BlockProducer.LastProducedBlockChanged += (s, e) =>
{
_suggestedBlockResetEvent.Set();
};
var genesis = GetGenesisBlock();
BlockTree.SuggestBlock(genesis);
await _resetEvent.WaitAsync();
//if (!await _resetEvent.WaitAsync(1000))
// {
// throw new InvalidOperationException("Failed to process genesis in 1s.");
// }
await AddBlocksOnStart();
return(this);
}
public void Setup()
{
_manualTimestamper = new ManualTimestamper(_startTime);
_testLogger = new TestLogger();
_logManager = new OneLoggerLogManager(_testLogger);
}
