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);
}
