public async Task Can_ask_about_storage_in_parallel() { StorageCell storageCell = new StorageCell(_address1, UInt256.One); IReleaseSpec spec = MuirGlacier.Instance; StateDb stateDb = new StateDb(new MemDb()); StateProvider provider = new StateProvider(stateDb, new MemDb(), Logger); StorageProvider storageProvider = new StorageProvider(stateDb, provider, Logger); void UpdateStorageValue(byte[] newValue) { storageProvider.Set(storageCell, newValue); } void AddOneToBalance() { provider.AddToBalance(_address1, 1, spec); } void CommitEverything() { storageProvider.Commit(); storageProvider.CommitTrees(); provider.Commit(spec); provider.CommitTree(); } provider.CreateAccount(_address1, 1); CommitEverything(); AddOneToBalance(); UpdateStorageValue(new byte[] { 1 }); CommitEverything(); Keccak stateRoot0 = provider.StateRoot; AddOneToBalance(); UpdateStorageValue(new byte[] { 2 }); CommitEverything(); Keccak stateRoot1 = provider.StateRoot; AddOneToBalance(); UpdateStorageValue(new byte[] { 3 }); CommitEverything(); Keccak stateRoot2 = provider.StateRoot; AddOneToBalance(); UpdateStorageValue(new byte[] { 4 }); CommitEverything(); Keccak stateRoot3 = provider.StateRoot; stateDb.Commit(); StateReader reader = new StateReader(stateDb, Substitute.For <IDb>(), Logger); Task a = StartStorageTask(reader, stateRoot0, storageCell, new byte[] { 1 }); Task b = StartStorageTask(reader, stateRoot1, storageCell, new byte[] { 2 }); Task c = StartStorageTask(reader, stateRoot2, storageCell, new byte[] { 3 }); Task d = StartStorageTask(reader, stateRoot3, storageCell, new byte[] { 4 }); await Task.WhenAll(a, b, c, d); }
public void Non_existing() { StorageCell storageCell = new StorageCell(_address1, UInt256.One); IReleaseSpec spec = MuirGlacier.Instance; StateDb stateDb = new StateDb(new MemDb()); StateProvider provider = new StateProvider(stateDb, new MemDb(), Logger); StorageProvider storageProvider = new StorageProvider(stateDb, provider, Logger); void CommitEverything() { storageProvider.Commit(); storageProvider.CommitTrees(); provider.Commit(spec); provider.CommitTree(); } provider.CreateAccount(_address1, 1); storageProvider.Set(storageCell, new byte[] { 1 }); CommitEverything(); Keccak stateRoot0 = provider.StateRoot; stateDb.Commit(); StateReader reader = new StateReader(stateDb, Substitute.For <IDb>(), Logger); Keccak storageRoot = reader.GetStorageRoot(stateRoot0, _address1); reader.GetStorage(storageRoot, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 }); reader.GetStorage(Keccak.EmptyTreeHash, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 }); }
public void Capacity_grwoth_and_shrinkage() { StateDb db = new StateDb(new MemDb()); for (int i = 0; i < 16; i++) { _hash1 = Keccak.Compute(_hash1.Bytes); db.Set(_hash1, _bytes1); } db.Restore(-1); byte[] getResult = db.Get(_hash1); Assert.AreEqual(null, getResult); for (int i = 0; i < 16; i++) { _hash1 = Keccak.Compute(_hash1.Bytes); db.Set(_hash1, _bytes1); } db.Commit(); getResult = db.Get(_hash1); Assert.AreEqual(_bytes1, getResult); }
public void Can_collect_stats() { MemDb memDb = new MemDb(); ISnapshotableDb stateDb = new StateDb(memDb); StateTree stateTree = new StateTree(stateDb); StateProvider stateProvider = new StateProvider(stateTree, stateDb, LimboLogs.Instance); StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance); stateProvider.CreateAccount(TestItem.AddressA, 1); Keccak codeHash = stateProvider.UpdateCode(new byte[] { 1, 2, 3 }); stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, Istanbul.Instance); stateProvider.CreateAccount(TestItem.AddressB, 1); Keccak codeHash2 = stateProvider.UpdateCode(new byte[] { 1, 2, 3, 4 }); stateProvider.UpdateCodeHash(TestItem.AddressB, codeHash2, Istanbul.Instance); for (int i = 0; i < 1000; i++) { StorageCell storageCell = new StorageCell(TestItem.AddressA, (UInt256)i); storageProvider.Set(storageCell, new byte[] { (byte)i }); } storageProvider.Commit(); stateProvider.Commit(Istanbul.Instance); storageProvider.CommitTrees(); stateProvider.CommitTree(); stateDb.Commit(); memDb.Delete(codeHash2); // missing code Keccak storageKey = new Keccak("0x345e54154080bfa9e8f20c99d7a0139773926479bc59e5b4f830ad94b6425332"); memDb.Delete(storageKey); // deletes some storage TrieStatsCollector statsCollector = new TrieStatsCollector(stateDb, LimboLogs.Instance); stateTree.Accept(statsCollector, stateTree.RootHash, true); string stats = statsCollector.Stats.ToString(); statsCollector.Stats.CodeCount.Should().Be(1); statsCollector.Stats.MissingCode.Should().Be(1); statsCollector.Stats.NodesCount.Should().Be(1348); statsCollector.Stats.StateBranchCount.Should().Be(1); statsCollector.Stats.StateExtensionCount.Should().Be(1); statsCollector.Stats.AccountCount.Should().Be(2); statsCollector.Stats.StorageCount.Should().Be(1343); statsCollector.Stats.StorageBranchCount.Should().Be(337); statsCollector.Stats.StorageExtensionCount.Should().Be(12); statsCollector.Stats.StorageLeafCount.Should().Be(994); statsCollector.Stats.MissingStorage.Should().Be(1); }
public void Set_commit_get() { StateDb db = new StateDb(new MemDb()); db.Set(_hash1, _bytes1); db.Commit(); byte[] getResult = db.Get(_hash1); Assert.AreEqual(_bytes1, getResult); }
public async Task Can_ask_about_balance_in_parallel() { IReleaseSpec spec = MainnetSpecProvider.Instance.GetSpec(MainnetSpecProvider.ConstantinopleFixBlockNumber); StateDb stateDb = new StateDb(new MemDb()); StateProvider provider = new StateProvider(stateDb, Substitute.For <IDb>(), Logger); provider.CreateAccount(_address1, 0); provider.AddToBalance(_address1, 1, spec); provider.Commit(spec); provider.CommitTree(); Keccak stateRoot0 = provider.StateRoot; provider.AddToBalance(_address1, 1, spec); provider.Commit(spec); provider.CommitTree(); Keccak stateRoot1 = provider.StateRoot; provider.AddToBalance(_address1, 1, spec); provider.Commit(spec); provider.CommitTree(); Keccak stateRoot2 = provider.StateRoot; provider.AddToBalance(_address1, 1, spec); provider.Commit(spec); provider.CommitTree(); Keccak stateRoot3 = provider.StateRoot; provider.CommitTree(); stateDb.Commit(); StateReader reader = new StateReader(stateDb, Substitute.For <IDb>(), Logger); Task a = StartTask(reader, stateRoot0, 1); Task b = StartTask(reader, stateRoot1, 2); Task c = StartTask(reader, stateRoot2, 3); Task d = StartTask(reader, stateRoot3, 4); await Task.WhenAll(a, b, c, d); }
private SyncTestContext CreateSyncManager(int index) { Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly); var logManager = NoErrorLimboLogs.Instance; ConsoleAsyncLogger logger = new ConsoleAsyncLogger(LogLevel.Debug, "PEER " + index + " "); // var logManager = new OneLoggerLogManager(logger); var specProvider = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, MainNetSpecProvider.Instance.ChainId); MemDb traceDb = new MemDb(); MemDb blockDb = new MemDb(); MemDb headerDb = new MemDb(); MemDb blockInfoDb = new MemDb(); StateDb codeDb = new StateDb(); StateDb stateDb = new StateDb(); var stateProvider = new StateProvider(stateDb, codeDb, logManager); stateProvider.CreateAccount(TestItem.AddressA, 10000.Ether()); stateProvider.Commit(specProvider.GenesisSpec); stateProvider.CommitTree(); stateDb.Commit(); var storageProvider = new StorageProvider(stateDb, stateProvider, logManager); var receiptStorage = new InMemoryReceiptStorage(); var ecdsa = new EthereumEcdsa(specProvider, logManager); var txPool = new TxPool(new InMemoryTransactionStorage(), new PendingTransactionThresholdValidator(), new Timestamp(), ecdsa, specProvider, logManager); var tree = new BlockTree(blockDb, headerDb, blockInfoDb, specProvider, txPool, logManager); var blockhashProvider = new BlockhashProvider(tree, LimboLogs.Instance); var virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, logManager); var sealValidator = TestSealValidator.AlwaysValid; var headerValidator = new HeaderValidator(tree, sealValidator, specProvider, logManager); var txValidator = TestTxValidator.AlwaysValid; var ommersValidator = new OmmersValidator(tree, headerValidator, logManager); var blockValidator = new BlockValidator(txValidator, headerValidator, ommersValidator, specProvider, logManager); // var blockValidator = TestBlockValidator.AlwaysValid; SyncConfig syncConfig = new SyncConfig(); syncConfig.FastSync = _synchronizerType == SynchronizerType.Fast; var rewardCalculator = new RewardCalculator(specProvider); var txProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, logManager); var blockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, txProcessor, stateDb, codeDb, traceDb, stateProvider, storageProvider, txPool, receiptStorage, syncConfig, logManager); var step = new TxSignaturesRecoveryStep(ecdsa, txPool, logManager); var processor = new BlockchainProcessor(tree, blockProcessor, step, logManager, true, true); var nodeStatsManager = new NodeStatsManager(new StatsConfig(), logManager); var syncPeerPool = new EthSyncPeerPool(tree, nodeStatsManager, syncConfig, logManager); StateProvider devState = new StateProvider(stateDb, codeDb, logManager); StorageProvider devStorage = new StorageProvider(stateDb, devState, logManager); var devEvm = new VirtualMachine(devState, devStorage, blockhashProvider, logManager); var devTxProcessor = new TransactionProcessor(specProvider, devState, devStorage, devEvm, logManager); var devBlockProcessor = new BlockProcessor(specProvider, blockValidator, rewardCalculator, devTxProcessor, stateDb, codeDb, traceDb, devState, devStorage, txPool, receiptStorage, syncConfig, logManager); var devChainProcessor = new BlockchainProcessor(tree, devBlockProcessor, step, logManager, false, false); var producer = new DevBlockProducer(txPool, devChainProcessor, tree, new Timestamp(), logManager); NodeDataFeed feed = new NodeDataFeed(codeDb, stateDb, logManager); NodeDataDownloader downloader = new NodeDataDownloader(syncPeerPool, feed, logManager); Synchronizer synchronizer = new Synchronizer( tree, blockValidator, sealValidator, syncPeerPool, syncConfig, downloader, logManager); var syncServer = new SyncServer(stateDb, codeDb, tree, receiptStorage, TestSealValidator.AlwaysValid, syncPeerPool, synchronizer, logManager); ManualResetEventSlim waitEvent = new ManualResetEventSlim(); tree.NewHeadBlock += (s, e) => waitEvent.Set(); if (index == 0) { _genesis = Build.A.Block.Genesis.WithStateRoot(stateProvider.StateRoot).TestObject; producer.Start(); } syncPeerPool.Start(); synchronizer.Start(); processor.Start(); tree.SuggestBlock(_genesis); if (!waitEvent.Wait(1000)) { throw new Exception("No genesis"); } SyncTestContext context = new SyncTestContext(); context.Ecdsa = ecdsa; context.BlockchainProcessor = processor; context.PeerPool = syncPeerPool; context.StateProvider = stateProvider; context.Synchronizer = synchronizer; context.SyncServer = syncServer; context.Tree = tree; context.BlockProducer = producer; context.TxPool = txPool; context.Logger = logger; return(context); }