public void Can_find_bloom_with_fromBlock_offset(long from, long to, long[] blocksSet, int[] levels)
{
BloomStorage storage = CreateBloomStorage(new BloomConfig {
IndexLevelBucketSizes = levels
});
Core.Bloom bloom = new();
byte[] bytes = { 1, 2, 3 };
bloom.Set(bytes);
foreach (long blockNumber in blocksSet)
{
if (blockNumber > storage.MaxBlockNumber + 1)
{
// Assert.Fail($"Missing blocks. Trying inserting {blockNumber}, when current max block is {storage.MaxBlockNumber}.");
}
storage.Store(blockNumber, bloom);
}
IBloomEnumeration bloomEnumeration = storage.GetBlooms(from, to);
IList <long> foundBlocks = new List <long>(blocksSet.Length);
foreach (Core.Bloom b in bloomEnumeration)
{
if (b.Matches(bytes) && bloomEnumeration.TryGetBlockNumber(out long block))
{
foundBlocks.Add(block);
}
}
long[] expectedFoundBlocks = blocksSet.Where(b => b >= from && b <= to).ToArray();
TestContext.Out.WriteLine($"Expected found blocks: {string.Join(", ", expectedFoundBlocks)}");
foundBlocks.Should().BeEquivalentTo(expectedFoundBlocks);
}
public bool Initialized_storage_contain_blocks_as_db(long from, long to)
{
var memColumnsDb = _bloomDb;
memColumnsDb.Set(BloomStorage.MinBlockNumberKey, 1L.ToBigEndianByteArrayWithoutLeadingZeros());
memColumnsDb.Set(BloomStorage.MaxBlockNumberKey, 11L.ToBigEndianByteArrayWithoutLeadingZeros());
var storage = new BloomStorage(_config, memColumnsDb, _fileStoreFactory);
return(storage.ContainsRange(from, to));
}
public bool Contain_blocks_after_store(long from, long to)
{
var storage = new BloomStorage(_config, _bloomDb, _fileStoreFactory);
for (long i = 1; i < 11; i++)
{
storage.Store(i, Core.Bloom.Empty);
}
return(storage.ContainsRange(from, to));
}
private static BloomStorage CreateBloomStorage(BloomConfig bloomConfig = null)
{
var storage = new BloomStorage(bloomConfig ?? new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
var bucketItems = storage.MaxBucketSize * Buckets;
for (long i = 0; i < bucketItems; i++)
{
storage.Store(i, Core.Bloom.Empty);
}
return(storage);
}
public void Flushes_on_get_after_store()
{
var fileStoreFactory = Substitute.For <IFileStoreFactory>();
var fileStore = new MockFileStore();
fileStoreFactory.Create(Arg.Any <string>()).Returns(fileStore);
var storage = new BloomStorage(_config, _bloomDb, fileStoreFactory);
storage.Store(1, Core.Bloom.Empty);
foreach (var _ in storage.GetBlooms(0, 1))
{
}
fileStoreFactory.Received().Create(Arg.Any <string>());
fileStore.Flushes.Should().BeGreaterThan(0);
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, new ReceiptsRecovery());
Bridge ??= new BlockchainBridge(StateReader, State, Storage, BlockTree, TxPool, ReceiptStorage, filterStore, filterManager, TestWallet, TxProcessor, EthereumEcdsa, NullBloomStorage.Instance, Timestamper, LimboLogs.Instance, false);
TxPoolBridge ??= new TxPoolBridge(TxPool, TestWallet, Timestamper, specProvider?.ChainId ?? 0);
EthModule = new EthModule(new JsonRpcConfig(), Bridge, TxPoolBridge, LimboLogs.Instance);
return(this);
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider, initialValues);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, receiptsRecovery);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(DbProvider, false),
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(BlockTree),
SpecProvider,
LimboLogs.Instance);
Bridge ??= new BlockchainBridge(processingEnv, TxPool, ReceiptStorage, filterStore, filterManager, EthereumEcdsa, Timestamper, LogFinder, SpecProvider, false, false);
BlockFinder ??= BlockTree;
ITxSigner txSigner = new WalletTxSigner(TestWallet, specProvider?.ChainId ?? 0);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper, TxPool);
TxSender ??= new TxPoolSender(TxPool, txSealer0, txSealer1);
EthRpcModule = new EthRpcModule(
new JsonRpcConfig(),
Bridge,
BlockFinder,
StateReader,
TxPool,
TxSender,
TestWallet,
LimboLogs.Instance,
SpecProvider);
return(this);
}
public void Can_safely_insert_concurrently()
{
_config.IndexLevelBucketSizes = new[] { byte.MaxValue + 1 };
var storage = new BloomStorage(_config, _bloomDb, _fileStoreFactory);
Core.Bloom expectedBloom = new Core.Bloom();
for (int i = 0; i <= byte.MaxValue; i++)
{
expectedBloom.Set(i);
}
Parallel.For(0, byte.MaxValue * byte.MaxValue * 2, i =>
{
var bloom = new Core.Bloom();
bloom.Set(i % Core.Bloom.BitLength);
storage.Store(i, bloom);
});
var first = storage.GetBlooms(0, byte.MaxValue * 3).First();
first.Should().Be(expectedBloom);
}
public void GlobalSetup()
{
var dbProvider = TestMemDbProvider.Init();
IDb codeDb = dbProvider.CodeDb;
IDb stateDb = dbProvider.StateDb;
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec;
var trieStore = new TrieStore(stateDb, LimboLogs.Instance);
StateProvider stateProvider = new(trieStore, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new(trieStore, stateProvider, LimboLogs.Instance);
StateReader stateReader = new(trieStore, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new (blockInfoDb);
BlockTree blockTree = new(dbProvider, chainLevelInfoRepository, specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(_blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider);
BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor,
stateProvider, storageProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance);
EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new(
blockTree,
blockProcessor,
new RecoverSignatures(
ecdsa,
NullTxPool.Instance,
specProvider,
LimboLogs.Instance),
LimboLogs.Instance,
BlockchainProcessor.Options.NoReceipts);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
LogFinder logFinder = new(
blockTree,
new InMemoryReceiptStorage(),
bloomStorage,
LimboLogs.Instance,
new ReceiptsRecovery(ecdsa, specProvider));
BlockchainBridge bridge = new(
new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(dbProvider, false),
trieStore.AsReadOnly(),
new ReadOnlyBlockTree(blockTree),
specProvider,
LimboLogs.Instance),
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
specProvider,
false);
GasPriceOracle gasPriceOracle = new(blockTree, specProvider);
FeeHistoryOracle feeHistoryOracle = new(blockTree, NullReceiptStorage.Instance, specProvider);
EthSyncingInfo ethSyncingInfo = new(blockTree);
_ethModule = new EthRpcModule(
new JsonRpcConfig(),
bridge,
blockTree,
stateReader,
NullTxPool.Instance,
NullTxSender.Instance,
NullWallet.Instance,
Substitute.For <IReceiptFinder>(),
LimboLogs.Instance,
specProvider,
gasPriceOracle,
ethSyncingInfo,
feeHistoryOracle);
}
public void GlobalSetup()
{
ISnapshotableDb codeDb = new StateDb();
ISnapshotableDb stateDb = new StateDb();
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IReleaseSpec spec = MainnetSpecProvider.Instance.GenesisSpec;
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, chainLevelInfoRepository, specProvider, NullTxPool.Instance, NullBloomStorage.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new TransactionProcessor(MainnetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionProcessor,
stateDb, codeDb, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance),
LimboLogs.Instance,
false);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
IBloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
BlockchainBridge bridge = new BlockchainBridge(
stateReader,
stateProvider,
storageProvider,
blockTree,
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance,
new DevWallet(new WalletConfig(), LimboLogs.Instance),
transactionProcessor,
new EthereumEcdsa(MainnetSpecProvider.Instance, LimboLogs.Instance),
bloomStorage,
LimboLogs.Instance,
false);
_ethModule = new EthModule(new JsonRpcConfig(), bridge, LimboLogs.Instance);
}
public void Empty_storage_does_not_contain_blocks(long from, long to)
{
var storage = new BloomStorage(_config, _bloomDb, _fileStoreFactory);
storage.ContainsRange(from, to).Should().BeFalse();
}
