public Beatmap(Input input)
{
if (input.BeatmapId == null)
{
throw new Exception("No beatmap link provided");
}
Task <BeatmapData[]> beatmapRequest = OsuApi.Beatmap(input.BeatmapId, input.ModRequestNumber ?? 0, input.Gamemode);
Task <ScoreData[]> leaderboardRequest = OsuApi.Leaderboard(input.BeatmapId, input.Gamemode);
Task.WhenAll(
beatmapRequest,
leaderboardRequest
).Wait();
beatmap = beatmapRequest.Result[0];
leaderboard = leaderboardRequest.Result;
CountLeaderboardFullCombo();
difficultyCalculator = new DifficultyCalculator(input.BeatmapId, input.Gamemode, input.ModNumber);
difficulty = difficultyCalculator.Calculate();
Embed = CreateEmbed();
}
protected override void InitSealEngine()
{
_context.RewardCalculatorSource = RewardCalculator.GetSource(_context.SpecProvider);
DifficultyCalculator difficultyCalculator = new DifficultyCalculator(_context.SpecProvider);
_context.Sealer = _context.Config <IInitConfig>().IsMining ? (ISealer) new EthashSealer(new Ethash(_context.LogManager), _context.LogManager) : NullSealEngine.Instance;
_context.SealValidator = new EthashSealValidator(_context.LogManager, difficultyCalculator, _context.CryptoRandom, new Ethash(_context.LogManager));
}
public CalculatedScoreEntry(AudicaScore localScore)
{
this.localScore = localScore;
this.songID = localScore.songID;
this.maxScorePercent = localScore.maxScorePercent;
this.audicaPointsWeighted = 0f;
this.audicaPointsRaw = DifficultyCalculator.GetRating(songID, localScore.difficultyString).value *maxScorePercent * 30;
}
private void CalculateDifficultyAndExpectValue(int height, string expectedValue, List <Block> blocks)
{
uint secondsPerBlockGoal = 15;
int difficultyUpdateCycle = 10;
var blockchain = blocks == null ? new Blockchain(_netId) : new Blockchain(blocks, _netId);
var sut = new DifficultyCalculator();
var result = sut.CalculateDifficulty(blockchain, height, _protocol, secondsPerBlockGoal, difficultyUpdateCycle);
Assert.AreEqual(expectedValue, result.ToString());
}
public void GetPreviousDifficultyUpdateInformationFull_ForHeight9_ThrowException()
{
var difficultyUpdateCycle = 10;
var blockchainHeight = 9;
var sut = new DifficultyCalculator();
var blockchain = new Blockchain(_netId);
var ex = Assert.ThrowsException <DifficultyCalculationException>(
() => sut.GetPreviousDifficultyUpdateInformation(blockchainHeight, blockchain, difficultyUpdateCycle)
);
Assert.AreEqual("Unable to calculate the previous difficulty because the height is lower than the DifficultyUpdateCycle.", ex.Message);
}
protected void RunTest(DifficultyTests test, ISpecProvider specProvider)
{
IDifficultyCalculator calculator = new DifficultyCalculator(specProvider);
UInt256 difficulty = calculator.Calculate(
test.ParentDifficulty,
test.ParentTimestamp,
test.CurrentTimestamp,
test.CurrentBlockNumber,
test.ParentHasUncles);
Assert.AreEqual(test.CurrentDifficulty, difficulty, test.Name);
}
public static float GetRating(Audica audica, string difficulty)
{
var calc = new DifficultyCalculator(audica);
var diffLower = difficulty.ToLower();
switch (diffLower)
{
case "easy":
if (calc.beginner != null)
{
return(calc.beginner.difficultyRating);
}
else
{
return(0f);
}
case "normal":
if (calc.standard != null)
{
return(calc.standard.difficultyRating);
}
else
{
return(0f);
}
case "hard":
if (calc.advanced != null)
{
return(calc.advanced.difficultyRating);
}
else
{
return(0f);
}
case "expert":
if (calc.expert != null)
{
return(calc.expert.difficultyRating);
}
else
{
return(0f);
}
default:
return(0f);
}
}
public DifficultyGraph(Input input, BeatmapData beatmap)
{
this.beatmap = beatmap;
var difficultyCalculator = new DifficultyCalculator(input.BeatmapId, input.Gamemode, input.ModNumber);
difficulty = difficultyCalculator.Calculate();
double maxDifficulty = (double)beatmap.DifficultyRating > difficulty.StrainPeakTotal.Max() ? (double)beatmap.DifficultyRating : difficulty.StrainPeakTotal.Max();
var webClient = new WebClient();
Image background = null;
Graphics graphic = null;
try
{
byte[] backgroundBytes = webClient.DownloadData($"https://assets.ppy.sh/beatmaps/{beatmap.BeatmapSetId}/covers/cover.jpg");
var backgroundStream = new MemoryStream(backgroundBytes);
background = Image.FromStream(backgroundStream);
graphic = Graphics.FromImage(background);
}
catch (Exception e) { }
double[] dataX = CreateXRange();
var plt = new Plot(900, 250);
plt.Axis(0, beatmap.TotalLength, 0, maxDifficulty + 0.5);
plt.PlotScatter(dataX, difficulty.StrainPeakTotal, markerSize: 0, label: "Strain", lineWidth: 3, color: Color.DodgerBlue);
plt.PlotScatter(dataX, difficulty.StrainPeakAim, markerShape: MarkerShape.none, label: "Aim", lineWidth: 1, color: Color.MediumAquamarine, lineStyle: LineStyle.Solid);
plt.PlotScatter(dataX, difficulty.StrainPeakSpeed, markerShape: MarkerShape.none, label: "Speed", lineWidth: 1, color: Color.Firebrick);
plt.Title($"{beatmap.Artist} - {beatmap.Title} [{beatmap.Version}]", fontSize: 24);
plt.Ticks(displayTicksXminor: false, displayTicksYminor: false, fontSize: 16);
plt.PlotHLine((double)beatmap.DifficultyRating, lineWidth: 1, label: "SR", color: Color.Gold);
plt.Legend(location: legendLocation.upperLeft, fontSize: 10, fixedLineWidth: true, bold: true);
plt.Style(figBg: Color.FromArgb(150, 35, 39, 42), dataBg: Color.FromArgb(150, 35, 39, 42), tick: Color.White, title: Color.White, label: Color.White);
plt.Layout(xLabelHeight: 5, yLabelWidth: -10);
if (graphic != null && background != null)
{
graphic.DrawImage(plt.GetBitmap(), new Point(0, 0));
Graph = background;
}
else
{
Graph = plt.GetBitmap();
}
//background.Save("output.png", ImageFormat.Png);
}
public void TestOD(Mods mods)
{
var diffCalc = new DifficultyCalculator();
var beatmap = new Beatmap();
var resultValues = new List <float>();
for (var i = 10; i >= 0; i--)
{
beatmap.OverallDifficulty = i;
var odResult = diffCalc.ApplyMods(beatmap, mods)["OD"];
resultValues.Add((float)Math.Round(odResult, 2));
}
CollectionAssert.AreEqual(OD_VALUES[mods], resultValues);
}
public static void ExportDifficultyCalculation(bool extras)
{
var songIDs = GameObject.FindObjectOfType <SongSelect>().GetSongIDs(extras);
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(Application.dataPath + "/../" + "difficultyCalculatorOutput.txt"))
{
file.WriteLine("Song Name, Difficulty, Difficulty Rating, BPM, Author");
for (int i = 0; i < songIDs.Count; i++)
{
var songData = SongList.I.GetSong(songIDs[i]);
var calc = new DifficultyCalculator(songData);
if (calc.expert != null)
{
file.WriteLine($"{SongBrowser.RemoveFormatting(songData.artist).Replace(",", "")} - {SongBrowser.RemoveFormatting(songData.title).Replace(",", "")}," +
"Expert," +
$"{calc.expert.difficultyRating.ToString("n2")}," +
$"{songData.tempos[0].tempo.ToString("n2")}," +
$"{songData.author}");
}
if (calc.advanced != null)
{
file.WriteLine($"{SongBrowser.RemoveFormatting(songData.artist).Replace(",", "")} - {SongBrowser.RemoveFormatting(songData.title).Replace(",", "")}," +
"Advanced," +
$"{calc.advanced.difficultyRating.ToString("n2")}," +
$"{songData.tempos[0].tempo.ToString("n2")}," +
$"{songData.author}");
}
if (calc.standard != null)
{
file.WriteLine($"{SongBrowser.RemoveFormatting(songData.artist).Replace(",", "")} - {SongBrowser.RemoveFormatting(songData.title).Replace(",", "")}," +
"Standard," +
$"{calc.standard.difficultyRating.ToString("n2")}," +
$"{songData.tempos[0].tempo.ToString("n2")}," +
$"{songData.author}");
}
if (calc.beginner != null)
{
file.WriteLine($"{SongBrowser.RemoveFormatting(songData.artist).Replace(",", "")} - {SongBrowser.RemoveFormatting(songData.title).Replace(",", "")}," +
"Beginner," +
$"{calc.beginner.difficultyRating.ToString("n2")}," +
$"{songData.tempos[0].tempo.ToString("n2")}," +
$"{songData.author}");
}
}
}
}
public void Setup()
{
_ethash = new EthashSealEngine(new Ethash(NullLogManager.Instance), NullLogManager.Instance);
_testLogger = new TestLogger();
BlockTree blockStore = new BlockTree(new MemDb(), new MemDb(), new MemDb(), FrontierSpecProvider.Instance, NullLogManager.Instance);
DifficultyCalculator calculator = new DifficultyCalculator(new SingleReleaseSpecProvider(Frontier.Instance, ChainId.MainNet));
_validator = new HeaderValidator(calculator, blockStore, _ethash, new SingleReleaseSpecProvider(Byzantium.Instance, 3), new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1).TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithNonce(0).TestObject;
blockStore.SuggestBlock(_parentBlock);
blockStore.SuggestBlock(_block);
}
private ISealEngine ConfigureSealEngine()
{
// var sealEngine = NullSealEngine.Instance;
var difficultyCalculator = new DifficultyCalculator(_specProvider);
var sealEngine = new EthashSealEngine(new Ethash(_logManager), difficultyCalculator, _logManager);
// var blockMiningTime = TimeSpan.FromMilliseconds(_initConfig.FakeMiningDelay);
// var sealEngine = new FakeSealEngine(blockMiningTime, false);
// sealEngine.IsMining = _initConfig.IsMining;
// if (sealEngine.IsMining)
// {
// var transactionDelay = TimeSpan.FromMilliseconds(_initConfig.FakeMiningDelay / 4);
// TestTransactionsGenerator testTransactionsGenerator =
// new TestTransactionsGenerator(transactionStore, ethereumSigner, transactionDelay, _logManager);
// // stateProvider.CreateAccount(testTransactionsGenerator.SenderAddress, 1000.Ether());
return(sealEngine);
}
/// <summary>
/// Initializes this object.
/// </summary>
public void Initialize(DifficultyCalculator calc, float scale, int levelCreated)
{
if (isInitialized)
{
return;
}
LevelCreated = levelCreated;
gameObject.name = "Object " + objectsCreated + " Level " + levelCreated;
speed = calc.GetSpeed(scale, levelCreated);
score = calc.GetScore(scale);
isInitialized = true;
objectsCreated++;
Debug.Log("FallingObject.Initialize(): speed = " + speed + " score = " + score);
}
private static IEnumerator PostProcess()
{
MapperNames.FixMappers();
yield return(null);
if (SongBrowser.songDataLoaderInstalled)
{
SafeDataLoaderReload();
}
yield return(null);
// calculate song difficulties
// only slow the first time this runs since results are cached
songIDs.Clear();
songFilenames.Clear();
songDictionary.Clear();
for (int i = 0; i < SongList.I.songs.Count; i++)
{
string songID = SongList.I.songs[i].songID;
songIDs.Add(songID);
string path = Path.GetFileName(SongList.I.songs[i].zipPath);
songFilenames.Add(path);
songDictionary.Add(path, songID);
DifficultyCalculator.GetRating(songID, KataConfig.Difficulty.Easy.ToString());
DifficultyCalculator.GetRating(songID, KataConfig.Difficulty.Normal.ToString());
DifficultyCalculator.GetRating(songID, KataConfig.Difficulty.Hard.ToString());
DifficultyCalculator.GetRating(songID, KataConfig.Difficulty.Expert.ToString());
yield return(null);
}
SongSearch.Search(); // update the search results with any new songs (if there is a search)
yield return(null);
foreach (Action cb in postProcessingActions)
{
cb();
yield return(null);
}
KataConfig.I.CreateDebugText("Songs Loaded", new Vector3(0f, -1f, 5f), 5f, null, false, 0.2f);
EnableButtons();
searching = false;
yield return(null);
}
public void Setup()
{
DifficultyCalculator calculator = new DifficultyCalculator(new SingleReleaseSpecProvider(Frontier.Instance, ChainId.MainNet));
_ethash = new EthashSealValidator(LimboLogs.Instance, calculator, new CryptoRandom(), new Ethash(LimboLogs.Instance));
_testLogger = new TestLogger();
var blockInfoDb = new MemDb();
BlockTree blockStore = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), FrontierSpecProvider.Instance, Substitute.For <ITxPool>(), Substitute.For <IBloomStorage>(), LimboLogs.Instance);
_validator = new HeaderValidator(blockStore, _ethash, new SingleReleaseSpecProvider(Byzantium.Instance, 3), new OneLoggerLogManager(_testLogger));
_parentBlock = Build.A.Block.WithDifficulty(1).TestObject;
_block = Build.A.Block.WithParent(_parentBlock)
.WithDifficulty(131072)
.WithMixHash(new Keccak("0xd7db5fdd332d3a65d6ac9c4c530929369905734d3ef7a91e373e81d0f010b8e8"))
.WithNonce(0).TestObject;
blockStore.SuggestBlock(_parentBlock);
blockStore.SuggestBlock(_block);
}
private static void Postfix(SongPlayHistory __instance, string songID, int score, KataConfig.Difficulty difficulty, float percent, bool fullCombo, bool noFail)
{
if (counter % 2 == 0)
{
MelonLogger.Msg("Recorded new score!");
if (noFail)
{
return;
}
if (percent < 30f)
{
return;
}
float maxScorePercent = (float)score / (float)StarThresholds.I.GetMaxRawScore(songID, difficulty);
DifficultyCalculator.CachedCalculation difficultyRating = DifficultyCalculator.GetRating(songID, difficulty.ToString());
AddScore(songID, score, maxScorePercent, difficultyRating.value, ScoreKeeper.I.mStreak, ScoreKeeper.I.mMaxStreak, difficulty);
}
counter++;
}
public void CalculateCurrentDifficulty_Calls_CalculateDifficultyForHeight()
{
var expectedHeight = -1;
BigDecimal expectedDifficulty = 1;
var selfCallingMock = new Mock <DifficultyCalculator>(MockBehavior.Strict);
var blockchainMock = new Mock <Blockchain>(MockBehavior.Strict, new object[] { _netId });
blockchainMock.Setup(m => m.CurrentHeight).Returns(expectedHeight);
selfCallingMock.Setup(m => m.CalculateCurrentDifficulty(blockchainMock.Object)).CallBase();
selfCallingMock.Setup(m => m.CalculateDifficultyForHeight(blockchainMock.Object, expectedHeight)).Returns(expectedDifficulty);
DifficultyCalculator sut = selfCallingMock.Object;
var result = sut.CalculateCurrentDifficulty(blockchainMock.Object);
Assert.AreEqual(expectedDifficulty, result);
selfCallingMock.VerifyAll();
blockchainMock.VerifyAll();
}
public void CalculateDifficultyForHeight_Uses_ConstantValues()
{
uint protocol = 1;
uint secondsPerBlockGoal = 15;
int difficultyUpdateCycle = 10;
var blockchainHeight = -1;
BigDecimal expectedDifficulty = 1;
var selfCallingMock = new Mock <DifficultyCalculator>(MockBehavior.Strict);
var blockchain = new Blockchain(_netId);
selfCallingMock.Setup(m => m.CalculateDifficultyForHeight(blockchain, blockchainHeight)).CallBase();
selfCallingMock.Setup(m => m.CalculateDifficulty(blockchain, blockchainHeight, protocol, secondsPerBlockGoal, difficultyUpdateCycle)).Returns(expectedDifficulty);
DifficultyCalculator sut = selfCallingMock.Object;
var result = sut.CalculateDifficultyForHeight(blockchain, blockchainHeight);
Assert.AreEqual(expectedDifficulty, result);
selfCallingMock.VerifyAll();
}
private void ProcessBeatmap()
{
// In a lazer implementation, DifficultyPoints would be a property of HitObjects so
// there would be no need to recalculate the difficulty or do this messy sorting
DifficultyCalculator calculator = new DifficultyCalculator();
calculator.SetBeatmap(_beatmap);
calculator.SetMods(_mods);
calculator.CalculateDifficulty();
foreach (DifficultyPoint diffPoint in calculator.Aiming.CalculatedPoints)
{
if (_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject) == null)
{
_remainingScoreObjects.Add(new ScoreObject(diffPoint.BaseObject));
}
_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject).DifficultyPoints.Add(diffPoint);
}
foreach (DifficultyPoint diffPoint in calculator.Clicking.CalculatedPoints)
{
if (_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject) == null)
{
_remainingScoreObjects.Add(new ScoreObject(diffPoint.BaseObject));
}
_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject).DifficultyPoints.Add(diffPoint);
}
foreach (DifficultyPoint diffPoint in calculator.Reading.CalculatedPoints)
{
if (_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject) == null)
{
_remainingScoreObjects.Add(new ScoreObject(diffPoint.BaseObject));
}
_remainingScoreObjects.Find(s => s.BaseObject == diffPoint.BaseObject).DifficultyPoints.Add(diffPoint);
}
_remainingScoreObjects.OrderBy(s => s.BaseObject.Time);
}
public void GetPreviousDifficultyUpdateInformationFull_ForHeight62_ReturnsCorrectInformation()
{
var difficultyUpdateCycle = 10;
var blockchainHeight = 63; // = index and that starts at zero.
var sut = new DifficultyCalculator();
var blocks = new List <Block>();
// Add 64 blocks
for (int i = 10; i < 641; i = i + 10)
{
blocks.Add(new Block(new BlockHeader(_netId, _protocol, "abc", i, ""), new List <AbstractTransaction>()));
}
var blockchain = new Blockchain(blocks, _netId);
BlockDifficultyUpdate result = sut.GetPreviousDifficultyUpdateInformation(blockchainHeight, blockchain, difficultyUpdateCycle);
Assert.AreEqual(blockchain, result.Blockchain);
Assert.AreEqual(50, result.BeginHeight);
Assert.AreEqual(59, result.EndHeight);
Assert.AreEqual(90, result.TotalSecondsForBlocks); // It took 90 seconds to create 9 blocks
}
public static void LogCurrentSongDifficulty()
{
var calc = new DifficultyCalculator(SongDataHolder.I.songData);
MelonLogger.Log("\n" + calc.songID);
if (calc.expert != null)
{
MelonLogger.Log("\nExpert: " + calc.expert.difficultyRating.ToString());
}
if (calc.advanced != null)
{
MelonLogger.Log("\nAdvanced: " + calc.advanced.difficultyRating.ToString());
}
if (calc.standard != null)
{
MelonLogger.Log("\nStandard: " + calc.standard.difficultyRating.ToString());
}
if (calc.beginner != null)
{
MelonLogger.Log("\nBeginner: " + calc.beginner.difficultyRating.ToString());
}
}
// Use this for initialization
private void Start()
{
if (instance)
{
Debug.LogWarning("DifficultyCalculator.Start(): another instance detected");
Object.Destroy(gameObject);
return;
}
instance = this;
if (!config)
{
Debug.LogError("DifficultyCalculator.Start(): config is null");
return;
}
spawningPeriodMultiplier = new IndexedValue <float> {
Index = -1
};
speedMultiplier = new IndexedValue <float> {
Index = -1
};
}
public async Task Can_process_mined_blocks()
{
int timeMultiplier = 1; // for debugging
TimeSpan miningDelay = TimeSpan.FromMilliseconds(50 * timeMultiplier);
/* logging & instrumentation */
// OneLoggerLogManager logger = new OneLoggerLogManager(new SimpleConsoleLogger(true));
ILogManager logManager = NullLogManager.Instance;
ILogger logger = logManager.GetClassLogger();
/* spec */
FakeSealer sealer = new FakeSealer(miningDelay);
RopstenSpecProvider specProvider = RopstenSpecProvider.Instance;
/* store & validation */
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider, logManager);
MemDb receiptsDb = new MemDb();
MemDb traceDb = new MemDb();
TxPool txPool = new TxPool(NullTxStorage.Instance, Timestamp.Default, ecdsa, specProvider, new TxPoolConfig(), logManager);
IReceiptStorage receiptStorage = new PersistentReceiptStorage(receiptsDb, NullDb.Instance, specProvider, logManager);
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), new MemDb(), specProvider, txPool, logManager);
Timestamp timestamp = new Timestamp();
DifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider);
HeaderValidator headerValidator = new HeaderValidator(blockTree, sealer, specProvider, logManager);
OmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, logManager);
TxValidator txValidator = new TxValidator(ChainId.Ropsten);
BlockValidator blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager);
/* state & storage */
StateDb codeDb = new StateDb();
StateDb stateDb = new StateDb();
StateProvider stateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, logManager);
TestTransactionsGenerator generator = new TestTransactionsGenerator(txPool, ecdsa, TimeSpan.FromMilliseconds(5 * timeMultiplier), NullLogManager.Instance);
generator.Start();
/* blockchain processing */
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager);
RewardCalculator rewardCalculator = new RewardCalculator(specProvider);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator,
processor, stateDb, codeDb, traceDb, stateProvider, storageProvider, txPool, receiptStorage, logManager);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, new TxSignaturesRecoveryStep(ecdsa, NullTxPool.Instance, LimboLogs.Instance), logManager, false, false);
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
string path = "chainspec.json";
logManager.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllBytes(path));
foreach (var allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value.Balance);
if (allocation.Value.Code != null)
{
Keccak codeHash = stateProvider.UpdateCode(allocation.Value.Code);
stateProvider.UpdateCodeHash(allocation.Key, codeHash, specProvider.GenesisSpec);
}
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot; // TODO: shall it be HeaderSpec and not BlockHeader?
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != new Keccak("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
blockTree.SuggestBlock(chainSpec.Genesis);
blockchainProcessor.Start();
MinedBlockProducer minedBlockProducer = new MinedBlockProducer(difficultyCalculator, txPool, blockchainProcessor, sealer, blockTree, timestamp, NullLogManager.Instance);
minedBlockProducer.Start();
ManualResetEventSlim manualResetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 6)
{
manualResetEvent.Set();
}
};
manualResetEvent.Wait(miningDelay * 12 * timeMultiplier);
await minedBlockProducer.StopAsync();
int previousCount = 0;
int totalTx = 0;
for (int i = 0; i < 6; i++)
{
Block block = blockTree.FindBlock(i);
logger.Info($"Block {i} with {block.Transactions.Length} txs");
ManualResetEventSlim blockProcessedEvent = new ManualResetEventSlim(false);
blockchainProcessor.ProcessingQueueEmpty += (sender, args) => blockProcessedEvent.Set();
blockchainProcessor.SuggestBlock(block, ProcessingOptions.ForceProcessing | ProcessingOptions.StoreReceipts | ProcessingOptions.ReadOnlyChain);
blockProcessedEvent.Wait(1000);
Tracer tracer = new Tracer(blockchainProcessor, receiptStorage, blockTree, new MemDb());
int currentCount = receiptsDb.Keys.Count;
logger.Info($"Current count of receipts {currentCount}");
logger.Info($"Previous count of receipts {previousCount}");
if (block.Transactions.Length > 0)
{
GethLikeTxTrace trace = tracer.Trace(block.Transactions[0].Hash);
Assert.AreSame(GethLikeTxTrace.QuickFail, trace);
Assert.AreNotEqual(previousCount, currentCount, $"receipts at block {i}");
totalTx += block.Transactions.Length;
}
previousCount = currentCount;
}
Assert.AreNotEqual(0, totalTx, "no tx in blocks");
}
private async Task InitBlockchain()
{
/* spec */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else if (_chainSpec.ChainId == SturebySpecProvider.Instance.ChainId)
{
_specProvider = SturebySpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(LatestRelease.Instance, _chainSpec.ChainId);
}
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_transactionPool = new TransactionPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.BlockInfosDb,
_specProvider,
_transactionPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _transactionPool);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.CliquePeriod;
cliqueConfig.Epoch = _chainSpec.CliqueEpoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
var headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
headerValidator,
_logManager);
var txValidator = new TransactionValidator(
new SignatureValidator(_specProvider.ChainId));
_blockValidator = new BlockValidator(
txValidator,
headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateTree = new StateTree(_dbProvider.StateDb);
var stateProvider = new StateProvider(
stateTree,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_transactionPoolInfoProvider = new TransactionPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_transactionPool,
_receiptStorage,
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager, !statsConfig.CaptureNodeStatsEventHistory);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _transactionPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
// TODO: need to introduce snapshot provider for clique and pass it here instead of CliqueSealEngine
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_transactionPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_transactionPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
if (!HiveEnabled)
{
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
}
await InitializeNetwork(
_receiptStorage,
_sealValidator,
txValidator);
}
private async Task InitBlockchain()
{
_specProvider = new ChainSpecBasedSpecProvider(_chainSpec);
Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce;
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_syncConfig = _configProvider.GetConfig <ISyncConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider),
Timestamp.Default,
_ethereumEcdsa,
_specProvider,
_txPoolConfig, _logManager);
var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance;
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_syncConfig,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_txPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
if (HiveEnabled)
{
await InitHive();
}
if (HiveEnabled)
{
await InitHive();
}
var producers = new List <IProducer>();
if (_initConfig.PubSubEnabled)
{
var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>());
producers.Add(kafkaProducer);
}
var grpcClientConfig = _configProvider.GetConfig <IGrpcClientConfig>();
if (grpcClientConfig.Enabled)
{
var grpcProducer = new GrpcProducer(_grpcClient, _logManager);
producers.Add(grpcProducer);
}
ISubscription subscription;
if (producers.Any())
{
subscription = new Subscription(producers, _blockProcessor, _logManager);
}
else
{
subscription = new EmptySubscription();
}
_disposeStack.Push(subscription);
_dataBridge = new DataBridge(subscription, _receiptStorage, _blockTree, _logManager);
_dataBridge.Start();
await InitializeNetwork();
}
private static void InitBlockchain(ChainSpec chainSpec, bool isMining, int miningDelay)
{
/* spec */
var blockMiningTime = TimeSpan.FromMilliseconds(miningDelay);
var transactionDelay = TimeSpan.FromMilliseconds(miningDelay / 4);
var specProvider = RopstenSpecProvider.Instance;
var difficultyCalculator = new DifficultyCalculator(specProvider);
// var sealEngine = new EthashSealEngine(new Ethash());
var sealEngine = new FakeSealEngine(blockMiningTime, false);
/* sync */
var transactionStore = new TransactionStore();
var blockTree = new BlockTree(RopstenSpecProvider.Instance, ChainLogger);
/* validation */
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, ChainLogger);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, ChainLogger);
var txValidator = new TransactionValidator(new SignatureValidator(ChainId.Ropsten));
var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, ChainLogger);
/* state */
var dbProvider = new DbProvider(StateLogger);
var codeDb = new InMemoryDb();
var stateDb = new InMemoryDb();
var stateTree = new StateTree(stateDb);
var stateProvider = new StateProvider(stateTree, StateLogger, codeDb);
var storageProvider = new StorageProvider(dbProvider, stateProvider, StateLogger);
var storageDbProvider = new DbProvider(StateLogger);
/* blockchain */
var ethereumSigner = new EthereumSigner(specProvider, ChainLogger);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(specProvider, stateProvider, storageProvider, blockhashProvider, EvmLogger);
var transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, ethereumSigner, ChainLogger);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, transactionProcessor, storageDbProvider, stateProvider, storageProvider, transactionStore, ChainLogger);
_blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ChainLogger);
/* genesis */
foreach (KeyValuePair <Address, BigInteger> allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value);
}
stateProvider.Commit(specProvider.GenesisSpec);
var testTransactionsGenerator = new TestTransactionsGenerator(transactionStore, ethereumSigner, transactionDelay, ChainLogger);
stateProvider.CreateAccount(testTransactionsGenerator.SenderAddress, 1000.Ether());
stateProvider.Commit(specProvider.GenesisSpec);
if (isMining)
{
testTransactionsGenerator.Start();
}
Block genesis = chainSpec.Genesis;
genesis.Header.StateRoot = stateProvider.StateRoot;
genesis.Header.RecomputeHash();
// we are adding test transactions account so the state root will change (not an actual ropsten at the moment)
// var expectedGenesisHash = "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d";
// if (chainSpec.Genesis.Hash != new Keccak(expectedGenesisHash))
// {
// throw new Exception($"Unexpected genesis hash for Ropsten, expected {expectedGenesisHash}, but was {chainSpec.Genesis.Hash}");
// }
/* start test processing */
sealEngine.IsMining = isMining;
_blockchainProcessor.Start();
blockTree.AddBlock(genesis);
_syncManager = new SynchronizationManager(
blockTree,
blockValidator,
headerValidator,
transactionStore,
txValidator,
NetworkLogger);
_syncManager.Start();
}
// It takes dotCover to run it quite long, increased timeouts
public async Task Can_process_mined_blocks()
{
int timeMultiplier = 1; // for debugging
TimeSpan miningDelay = TimeSpan.FromMilliseconds(200 * timeMultiplier);
/* logging & instrumentation */
// OneLoggerLogManager logger = new OneLoggerLogManager(new SimpleConsoleLogger(true));
ILogManager logManager = LimboLogs.Instance;
ILogger logger = logManager.GetClassLogger();
/* spec */
FakeSealer sealer = new FakeSealer(miningDelay);
RopstenSpecProvider specProvider = RopstenSpecProvider.Instance;
/* state & storage */
StateDb codeDb = new StateDb();
StateDb stateDb = new StateDb();
StateProvider stateProvider = new StateProvider(stateDb, codeDb, logManager);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, logManager);
/* store & validation */
EthereumEcdsa ecdsa = new EthereumEcdsa(specProvider, logManager);
MemDb receiptsDb = new MemDb();
TxPool.TxPool txPool = new TxPool.TxPool(NullTxStorage.Instance, Timestamper.Default, ecdsa, specProvider, new TxPoolConfig(), stateProvider, logManager);
IReceiptStorage receiptStorage = new PersistentReceiptStorage(receiptsDb, specProvider, logManager);
var blockInfoDb = new MemDb();
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, txPool, NullBloomStorage.Instance, logManager);
Timestamper timestamper = new Timestamper();
DifficultyCalculator difficultyCalculator = new DifficultyCalculator(specProvider);
HeaderValidator headerValidator = new HeaderValidator(blockTree, sealer, specProvider, logManager);
OmmersValidator ommersValidator = new OmmersValidator(blockTree, headerValidator, logManager);
TxValidator txValidator = new TxValidator(ChainId.Ropsten);
BlockValidator blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager);
TestTransactionsGenerator generator = new TestTransactionsGenerator(txPool, ecdsa, TimeSpan.FromMilliseconds(50 * timeMultiplier), LimboLogs.Instance);
generator.Start();
/* blockchain processing */
BlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, logManager);
TransactionProcessor processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager);
RewardCalculator rewardCalculator = new RewardCalculator(specProvider);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator,
processor, stateDb, codeDb, stateProvider, storageProvider, txPool, receiptStorage, logManager);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, new TxSignaturesRecoveryStep(ecdsa, NullTxPool.Instance, LimboLogs.Instance), logManager, false);
/* load ChainSpec and init */
ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
string path = "chainspec.json";
logManager.GetClassLogger().Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllText(path));
foreach (var allocation in chainSpec.Allocations)
{
stateProvider.CreateAccount(allocation.Key, allocation.Value.Balance);
if (allocation.Value.Code != null)
{
Keccak codeHash = stateProvider.UpdateCode(allocation.Value.Code);
stateProvider.UpdateCodeHash(allocation.Key, codeHash, specProvider.GenesisSpec);
}
}
stateProvider.Commit(specProvider.GenesisSpec);
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot;
chainSpec.Genesis.Header.Hash = chainSpec.Genesis.Header.CalculateHash();
if (chainSpec.Genesis.Hash != new Keccak("0xafbc3c327d2d18ff2b843e89226ef288fcee379542f854f982e4cfb85916d126"))
{
throw new Exception("Unexpected genesis hash");
}
/* start processing */
blockTree.SuggestBlock(chainSpec.Genesis);
blockchainProcessor.Start();
var transactionSelector = new PendingTxSelector(txPool, stateProvider, logManager);
MinedBlockProducer minedBlockProducer = new MinedBlockProducer(transactionSelector, blockchainProcessor, sealer, blockTree, blockchainProcessor, stateProvider, timestamper, LimboLogs.Instance, difficultyCalculator);
minedBlockProducer.Start();
ManualResetEventSlim manualResetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (sender, args) =>
{
if (args.Block.Number == 6)
{
manualResetEvent.Set();
}
};
manualResetEvent.Wait(miningDelay * 100);
await minedBlockProducer.StopAsync();
int previousCount = 0;
int totalTx = 0;
for (int i = 0; i < 6; i++)
{
Block block = blockTree.FindBlock(i, BlockTreeLookupOptions.None);
Assert.That(block, Is.Not.Null, $"Block {i} not produced");
logger.Info($"Block {i} with {block.Transactions.Length} txs");
ManualResetEventSlim blockProcessedEvent = new ManualResetEventSlim(false);
blockchainProcessor.ProcessingQueueEmpty += (sender, args) => blockProcessedEvent.Set();
blockchainProcessor.Enqueue(block, ProcessingOptions.ForceProcessing | ProcessingOptions.StoreReceipts | ProcessingOptions.ReadOnlyChain);
blockProcessedEvent.Wait(miningDelay);
GethStyleTracer gethStyleTracer = new GethStyleTracer(blockchainProcessor, receiptStorage, blockTree);
int currentCount = receiptsDb.Keys.Count;
logger.Info($"Current count of receipts {currentCount}");
logger.Info($"Previous count of receipts {previousCount}");
if (block.Transactions.Length > 0)
{
Assert.AreNotEqual(previousCount, currentCount, $"receipts at block {i}");
totalTx += block.Transactions.Length;
}
previousCount = currentCount;
}
Assert.AreNotEqual(0, totalTx, "no tx in blocks");
}
private static async Task RunBenchmarkBlocks()
{
Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly);
/* logging & instrumentation */
_logManager = new NLogManager("perfTest.logs.txt", null);
_logger = _logManager.GetClassLogger();
if (_logger.IsInfo)
{
_logger.Info("Deleting state DBs");
}
DeleteDb(FullStateDbPath);
DeleteDb(FullCodeDbPath);
DeleteDb(FullReceiptsDbPath);
DeleteDb(FullPendingTxsDbPath);
if (_logger.IsInfo)
{
_logger.Info("State DBs deleted");
}
/* load spec */
ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
string path = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"chainspec", "ropsten.json"));
_logger.Info($"Loading ChainSpec from {path}");
ChainSpec chainSpec = loader.Load(File.ReadAllText(path));
_logger.Info($"ChainSpec loaded");
var specProvider = new ChainSpecBasedSpecProvider(chainSpec);
IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);
var dbProvider = new RocksDbProvider(DbBasePath, DbConfig.Default, _logManager, true, true);
var stateDb = dbProvider.StateDb;
var codeDb = dbProvider.CodeDb;
var traceDb = dbProvider.TraceDb;
var blocksDb = dbProvider.BlocksDb;
var headersDb = dbProvider.HeadersDb;
var blockInfosDb = dbProvider.BlockInfosDb;
var receiptsDb = dbProvider.ReceiptsDb;
/* state & storage */
var stateProvider = new StateProvider(stateDb, codeDb, _logManager);
var storageProvider = new StorageProvider(stateDb, stateProvider, _logManager);
var ethereumSigner = new EthereumEcdsa(specProvider, _logManager);
var transactionPool = new TxPool(
NullTxStorage.Instance,
Timestamper.Default,
ethereumSigner,
specProvider,
new TxPoolConfig(),
stateProvider,
_logManager);
var blockInfoRepository = new ChainLevelInfoRepository(blockInfosDb);
var blockTree = new UnprocessedBlockTreeWrapper(new BlockTree(blocksDb, headersDb, blockInfosDb, blockInfoRepository, specProvider, transactionPool, _logManager));
var receiptStorage = new InMemoryReceiptStorage();
IBlockDataRecoveryStep recoveryStep = new TxSignaturesRecoveryStep(ethereumSigner, transactionPool, _logManager);
/* blockchain processing */
IList <IAdditionalBlockProcessor> blockProcessors = new List <IAdditionalBlockProcessor>();
var blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, _logManager);
var processor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, _logManager);
ISealValidator sealValidator;
if (specProvider.ChainId == RopstenSpecProvider.Instance.ChainId)
{
var difficultyCalculator = new DifficultyCalculator(specProvider);
sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
}
else if (chainSpec.SealEngineType == SealEngineType.Clique)
{
var snapshotManager = new SnapshotManager(CliqueConfig.Default, blocksDb, blockTree, ethereumSigner, _logManager);
sealValidator = new CliqueSealValidator(CliqueConfig.Default, snapshotManager, _logManager);
rewardCalculator = NoBlockRewards.Instance;
recoveryStep = new CompositeDataRecoveryStep(recoveryStep, new AuthorRecoveryStep(snapshotManager));
}
else if (chainSpec.SealEngineType == SealEngineType.AuRa)
{
var abiEncoder = new AbiEncoder();
var validatorProcessor = new AuRaAdditionalBlockProcessorFactory(dbProvider.StateDb, stateProvider, abiEncoder, processor, blockTree, receiptStorage, _logManager)
.CreateValidatorProcessor(chainSpec.AuRa.Validators);
sealValidator = new AuRaSealValidator(chainSpec.AuRa, new AuRaStepCalculator(chainSpec.AuRa.StepDuration, new Timestamper()), validatorProcessor, ethereumSigner, _logManager);
rewardCalculator = new AuRaRewardCalculator(chainSpec.AuRa, abiEncoder, processor);
blockProcessors.Add(validatorProcessor);
}
else
{
throw new NotSupportedException();
}
/* store & validation */
var headerValidator = new HeaderValidator(blockTree, sealValidator, specProvider, _logManager);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
var transactionValidator = new TxValidator(chainSpec.ChainId);
var blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager);
/* blockchain processing */
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, stateDb, codeDb, traceDb, stateProvider, storageProvider, transactionPool, receiptStorage, _logManager, blockProcessors);
var blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, recoveryStep, _logManager, true, false);
if (chainSpec.SealEngineType == SealEngineType.AuRa)
{
stateProvider.CreateAccount(Address.Zero, UInt256.Zero);
storageProvider.Commit();
stateProvider.Commit(Homestead.Instance);
var finalizationManager = new AuRaBlockFinalizationManager(blockTree, blockInfoRepository, blockProcessor, blockProcessors.OfType <IAuRaValidator>().First(), _logManager);
}
foreach ((Address address, ChainSpecAllocation allocation) in chainSpec.Allocations)
{
stateProvider.CreateAccount(address, allocation.Balance);
if (allocation.Code != null)
{
Keccak codeHash = stateProvider.UpdateCode(allocation.Code);
stateProvider.UpdateCodeHash(address, codeHash, specProvider.GenesisSpec);
}
if (allocation.Constructor != null)
{
Transaction constructorTransaction = new Transaction(true)
{
SenderAddress = address,
Init = allocation.Constructor,
GasLimit = chainSpec.Genesis.GasLimit
};
processor.Execute(constructorTransaction, chainSpec.Genesis.Header, NullTxTracer.Instance);
}
}
_logger.Info($"Allocations configured, committing...");
stateProvider.Commit(specProvider.GenesisSpec);
_logger.Info($"Finalizing genesis...");
chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot;
chainSpec.Genesis.Header.Hash = BlockHeader.CalculateHash(chainSpec.Genesis.Header);
if (chainSpec.Genesis.Hash != blockTree.Genesis.Hash)
{
throw new Exception("Unexpected genesis hash");
}
_logger.Info($"Starting benchmark processor...");
/* start processing */
BigInteger totalGas = BigInteger.Zero;
Stopwatch stopwatch = new Stopwatch();
Block currentHead;
long maxMemory = 0;
blockTree.NewHeadBlock += (sender, args) =>
{
currentHead = args.Block;
if (currentHead.Number == 0)
{
return;
}
maxMemory = Math.Max(maxMemory, GC.GetTotalMemory(false));
totalGas += currentHead.GasUsed;
if ((BigInteger)args.Block.Number % 10000 == 9999)
{
stopwatch.Stop();
long ms = 1_000L * stopwatch.ElapsedTicks / Stopwatch.Frequency;
BigInteger number = args.Block.Number + 1;
_logger.Warn($"TOTAL after {number} (ms) : " + ms);
_logger.Warn($"TOTAL after {number} blocks/s : {(decimal) currentHead.Number / (ms / 1000m),5}");
_logger.Warn($"TOTAL after {number} Mgas/s : {((decimal) totalGas / 1000000) / (ms / 1000m),5}");
_logger.Warn($"TOTAL after {number} max mem : {maxMemory}");
_logger.Warn($"TOTAL after {number} GC (0/1/2) : {GC.CollectionCount(0)}/{GC.CollectionCount(1)}/{GC.CollectionCount(2)}");
_logger.Warn($"Is server GC {number} : {System.Runtime.GCSettings.IsServerGC}");
_logger.Warn($"GC latency mode {number} : {System.Runtime.GCSettings.LatencyMode}");
_logger.Warn($"TOTAL after {number} blocks DB reads : {Store.Metrics.BlocksDbReads}");
_logger.Warn($"TOTAL after {number} blocks DB writes : {Store.Metrics.BlocksDbWrites}");
_logger.Warn($"TOTAL after {number} infos DB reads : {Store.Metrics.BlockInfosDbReads}");
_logger.Warn($"TOTAL after {number} infos DB writes : {Store.Metrics.BlockInfosDbWrites}");
_logger.Warn($"TOTAL after {number} state tree reads : {Store.Metrics.StateTreeReads}");
_logger.Warn($"TOTAL after {number} state tree writes : {Store.Metrics.StateTreeWrites}");
_logger.Warn($"TOTAL after {number} state DB reads : {Store.Metrics.StateDbReads}");
_logger.Warn($"TOTAL after {number} state DB writes : {Store.Metrics.StateDbWrites}");
_logger.Warn($"TOTAL after {number} storage tree reads : {Store.Metrics.StorageTreeReads}");
_logger.Warn($"TOTAL after {number} storage tree writes : {Store.Metrics.StorageTreeWrites}");
_logger.Warn($"TOTAL after {number} tree node hash : {Store.Metrics.TreeNodeHashCalculations}");
_logger.Warn($"TOTAL after {number} tree node RLP decode : {Store.Metrics.TreeNodeRlpDecodings}");
_logger.Warn($"TOTAL after {number} tree node RLP encode : {Store.Metrics.TreeNodeRlpEncodings}");
_logger.Warn($"TOTAL after {number} code DB reads : {Store.Metrics.CodeDbReads}");
_logger.Warn($"TOTAL after {number} code DB writes : {Store.Metrics.CodeDbWrites}");
_logger.Warn($"TOTAL after {number} receipts DB reads : {Store.Metrics.ReceiptsDbReads}");
_logger.Warn($"TOTAL after {number} receipts DB writes : {Store.Metrics.ReceiptsDbWrites}");
_logger.Warn($"TOTAL after {number} other DB reads : {Store.Metrics.OtherDbReads}");
_logger.Warn($"TOTAL after {number} other DB writes : {Store.Metrics.OtherDbWrites}");
_logger.Warn($"TOTAL after {number} EVM exceptions : {Evm.Metrics.EvmExceptions}");
_logger.Warn($"TOTAL after {number} SLOAD opcodes : {Evm.Metrics.SloadOpcode}");
_logger.Warn($"TOTAL after {number} SSTORE opcodes : {Evm.Metrics.SstoreOpcode}");
_logger.Warn($"TOTAL after {number} EXP opcodes : {Evm.Metrics.ModExpOpcode}");
_logger.Warn($"TOTAL after {number} BLOCKHASH opcodes : {Evm.Metrics.BlockhashOpcode}");
_logger.Warn($"TOTAL after {number} EVM calls : {Evm.Metrics.Calls}");
_logger.Warn($"TOTAL after {number} RIPEMD Precompiles : {Evm.Metrics.Ripemd160Precompile}");
_logger.Warn($"TOTAL after {number} SHA256 Precompiles : {Evm.Metrics.Sha256Precompile}");
// disk space
stopwatch.Start();
}
};
bool isStarted = false;
TaskCompletionSource <object> completionSource = new TaskCompletionSource <object>();
blockTree.NewBestSuggestedBlock += (sender, args) =>
{
if (!isStarted)
{
blockchainProcessor.Process(blockTree.FindBlock(blockTree.Genesis.Hash, BlockTreeLookupOptions.RequireCanonical), ProcessingOptions.None, NullBlockTracer.Instance);
stopwatch.Start();
blockchainProcessor.Start();
isStarted = true;
}
if (args.Block.Number == BlocksToLoad)
{
completionSource.SetResult(null);
}
};
await Task.WhenAny(completionSource.Task, blockTree.LoadBlocksFromDb(CancellationToken.None, 0, 10000, BlocksToLoad));
await blockchainProcessor.StopAsync(true).ContinueWith(
t =>
{
if (t.IsFaulted)
{
_logger.Error("processing failed", t.Exception);
_logger.Error("inner", t.Exception.InnerException);
Console.ReadLine();
}
_logger.Info("Block processing completed.");
});
stopwatch.Stop();
Console.ReadLine();
}
new protected async Task StartRunners(IConfigProvider configProvider)
{
InitRlp();
_configProvider = configProvider;
_initConfig = _configProvider.GetConfig <IInitConfig>();
_logManager = new NLogManager(_initConfig.LogFileName, _initConfig.LogDirectory);
_logger = _logManager.GetClassLogger();
_networkHelper = new NetworkHelper(_logger);
SetupKeyStore();
LoadChainSpec();
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_dbProvider = new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
/* blockchain processing */
if (_chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
_specProvider = RopstenSpecProvider.Instance;
}
else if (_chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
_specProvider = MainNetSpecProvider.Instance;
}
else if (_chainSpec.ChainId == RinkebySpecProvider.Instance.ChainId)
{
_specProvider = RinkebySpecProvider.Instance;
}
else if (_chainSpec.ChainId == GoerliSpecProvider.Instance.ChainId)
{
_specProvider = GoerliSpecProvider.Instance;
}
else
{
_specProvider = new SingleReleaseSpecProvider(Latest.Release, _chainSpec.ChainId);
}
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval,
_initConfig.RemovePendingTransactionInterval), new Timestamp(),
_ethereumEcdsa, _specProvider, _logManager, _initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_configProvider.GetConfig <ISyncConfig>(),
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
string chainFile = Path.Join(Path.GetDirectoryName(_initConfig.ChainSpecPath), "chain.rlp");
if (!File.Exists(chainFile))
{
_logger.Info($"Chain file does not exist: {chainFile}, skipping");
return;
}
var chainFileContent = File.ReadAllBytes(chainFile);
var context = new Rlp.DecoderContext(chainFileContent);
var blocks = new List <Block>();
while (context.ReadNumberOfItemsRemaining() > 0)
{
context.PeekNextItem();
blocks.Add(Rlp.Decode <Block>(context));
}
for (int i = 0; i < blocks.Count; i++)
{
ProcessBlock(blocks[i]);
}
}
private async Task InitBlockchain(InitParams initParams)
{
ChainSpec chainSpec = LoadChainSpec(initParams.ChainSpecPath);
/* spec */
// TODO: rebuild to use chainspec
ISpecProvider specProvider;
if (chainSpec.ChainId == RopstenSpecProvider.Instance.ChainId)
{
specProvider = RopstenSpecProvider.Instance;
}
else if (chainSpec.ChainId == MainNetSpecProvider.Instance.ChainId)
{
specProvider = MainNetSpecProvider.Instance;
}
else
{
throw new NotSupportedException($"Not yet tested, not yet supported ChainId {chainSpec.ChainId}");
}
var ethereumSigner = new EthereumSigner(specProvider, _logManager);
var transactionStore = new TransactionStore();
var sealEngine = ConfigureSealEngine(transactionStore, ethereumSigner, initParams);
/* sync */
var blocksDb = new DbOnTheRocks(Path.Combine(_dbBasePath, DbOnTheRocks.BlocksDbPath));
var blockInfosDb = new DbOnTheRocks(Path.Combine(_dbBasePath, DbOnTheRocks.BlockInfosDbPath));
var receiptsDb = new DbOnTheRocks(Path.Combine(_dbBasePath, DbOnTheRocks.ReceiptsDbPath));
/* blockchain */
var blockTree = new BlockTree(blocksDb, blockInfosDb, receiptsDb, specProvider, _logManager);
var difficultyCalculator = new DifficultyCalculator(specProvider);
/* validation */
var headerValidator = new HeaderValidator(difficultyCalculator, blockTree, sealEngine, specProvider, _logManager);
var ommersValidator = new OmmersValidator(blockTree, headerValidator, _logManager);
var txValidator = new TransactionValidator(new SignatureValidator(specProvider.ChainId));
var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, _logManager);
/* state */
var dbProvider = new RocksDbProvider(_dbBasePath, _logManager);
var codeDb = new DbOnTheRocks(Path.Combine(_dbBasePath, DbOnTheRocks.CodeDbPath));
var stateDb = new DbOnTheRocks(Path.Combine(_dbBasePath, DbOnTheRocks.StateDbPath));
var stateTree = new StateTree(stateDb);
var stateProvider = new StateProvider(stateTree, codeDb, _logManager);
var storageProvider = new StorageProvider(dbProvider, stateProvider, _logManager);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(blockTree);
var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, _logManager);
var transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, _tracer, _logManager);
var rewardCalculator = new RewardCalculator(specProvider);
var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, transactionProcessor, dbProvider, stateProvider, storageProvider, transactionStore, _logManager);
_blockchainProcessor = new BlockchainProcessor(blockTree, sealEngine, transactionStore, difficultyCalculator, blockProcessor, ethereumSigner, _logManager);
// create shared objects between discovery and peer manager
_nodeFactory = new NodeFactory();
_nodeStatsProvider = new NodeStatsProvider(_configProvider);
var jsonSerializer = new JsonSerializer(_logManager);
var encrypter = new AesEncrypter(_configProvider, _logManager);
_keyStore = new FileKeyStore(_configProvider, jsonSerializer, encrypter, _cryptoRandom, _logManager);
//creating blockchain bridge
BlockchainBridge = new BlockchainBridge(ethereumSigner, stateProvider, _keyStore, blockTree, stateDb, transactionStore);
EthereumSigner = ethereumSigner;
_blockchainProcessor.Start();
LoadGenesisBlock(chainSpec, string.IsNullOrWhiteSpace(initParams.GenesisHash) ? null : new Keccak(initParams.GenesisHash), blockTree, stateProvider, specProvider);
await StartProcessing(blockTree, transactionStore, blockValidator, headerValidator, txValidator, initParams);
}
