Verkle/unittests

src/Nethermind/Nethermind.AccountAbstraction.Test/UserOperationTracerTests.cs

@@ -20,7 +20,8 @@
 
 namespace Nethermind.AccountAbstraction.Test
 {
-    [TestFixture]
+    [TestFixture(VirtualMachineTestsStateProvider.MerkleTrie)]
+    [TestFixture(VirtualMachineTestsStateProvider.VerkleTrie)]
     public class UserOperationTracerTests : VirtualMachineTestsBase
     {
         [TestCase(Instruction.GASPRICE, false)]
@@ -246,5 +247,8 @@ public void Should_allow_gas_only_if_followed_by_call(Instruction instruction, b
         }
 
         protected override long BlockNumber { get; } = MainnetSpecProvider.LondonBlockNumber;
+        public UserOperationTracerTests(VirtualMachineTestsStateProvider stateProvider) : base(stateProvider)
+        {
+        }
     }
 }

src/Nethermind/Nethermind.Api/IApiWithBlockchain.cs

@@ -21,6 +21,8 @@
 using Nethermind.State;
 using Nethermind.Trie.Pruning;
 using Nethermind.TxPool;
+using Nethermind.Verkle;
+using Nethermind.Verkle.Tree;
 
 namespace Nethermind.Api
 {
@@ -42,6 +44,8 @@ public interface IApiWithBlockchain : IApiWithStores, IBlockchainBridgeFactory
         IUnclesValidator? UnclesValidator { get; set; }
         IHeaderValidator? HeaderValidator { get; set; }
         IManualBlockProductionTrigger ManualBlockProductionTrigger { get; }
+        VerkleStateStore VerkleTrieStore { get; set; }
+        ReadOnlyVerkleStateStore ReadOnlyVerkleTrieStore { get; set; }
         IReadOnlyTrieStore? ReadOnlyTrieStore { get; set; }
         IRewardCalculatorSource? RewardCalculatorSource { get; set; }
         ISealer? Sealer { get; set; }

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -57,6 +57,8 @@
 using Nethermind.State.Snap;
 using Nethermind.Synchronization.SnapSync;
 using Nethermind.Synchronization.Blocks;
+using Nethermind.Verkle;
+using Nethermind.Verkle.Tree;
 
 namespace Nethermind.Api
 {
@@ -74,9 +76,19 @@ public IBlockchainBridge CreateBlockchainBridge()
         {
             ReadOnlyBlockTree readOnlyTree = BlockTree.AsReadOnly();
             LazyInitializer.EnsureInitialized(ref _readOnlyDbProvider, () => new ReadOnlyDbProvider(DbProvider, false));
+            IReadOnlyTxProcessorSourceExt readOnlyTxProcessingEnv;
+            switch (SpecProvider.GenesisSpec.VerkleTreeEnabled)
+            {
+                case true:
+                    // TODO: reuse the same trie cache here
+                    readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(_readOnlyDbProvider, ReadOnlyVerkleTrieStore, readOnlyTree, SpecProvider, LogManager);
+                    break;
+                case false:
+                    // TODO: reuse the same trie cache here
+                    readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(_readOnlyDbProvider, ReadOnlyTrieStore, readOnlyTree, SpecProvider, LogManager);
+                    break;
+            }
 
-            // TODO: reuse the same trie cache here
-            IReadOnlyTxProcessorSourceExt readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(_readOnlyDbProvider, ReadOnlyTrieStore, readOnlyTree, SpecProvider, LogManager);
 
             IMiningConfig miningConfig = ConfigProvider.GetConfig<IMiningConfig>();
             IBlocksConfig blocksConfig = ConfigProvider.GetConfig<IBlocksConfig>();
@@ -126,6 +138,8 @@ public IBlockchainBridge CreateBlockchainBridge()
 
         public IManualBlockProductionTrigger ManualBlockProductionTrigger { get; set; } =
             new BuildBlocksWhenRequested();
+        public VerkleStateStore VerkleTrieStore { get; set; }
+        public ReadOnlyVerkleStateStore ReadOnlyVerkleTrieStore { get; set; }
 
         public IIPResolver? IpResolver { get; set; }
         public IJsonSerializer EthereumJsonSerializer { get; set; }

src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs

@@ -108,5 +108,88 @@ public void Test()
             autoResetEvent.WaitOne(1000).Should().BeTrue("1");
             blockTree.Head.Number.Should().Be(1);
         }
+
+        [Test]
+        public void TestVerkle()
+        {
+            ISpecProvider specProvider = MainnetSpecProvider.Instance;
+            DbProvider dbProvider = new(DbModeHint.Mem);
+            dbProvider.RegisterDb(DbNames.BlockInfos, new MemDb());
+            dbProvider.RegisterDb(DbNames.Blocks, new MemDb());
+            dbProvider.RegisterDb(DbNames.Headers, new MemDb());
+            dbProvider.RegisterDb(DbNames.State, new MemDb());
+            dbProvider.RegisterDb(DbNames.Code, new MemDb());
+            dbProvider.RegisterDb(DbNames.Metadata, new MemDb());
+            dbProvider.RegisterDb(DbNames.Leaf, new MemDb());
+            dbProvider.RegisterDb(DbNames.Branch, new MemDb());
+            dbProvider.RegisterDb(DbNames.Stem, new MemDb());
+            dbProvider.RegisterDb(DbNames.ForwardDiff, new MemDb());
+            dbProvider.RegisterDb(DbNames.ReverseDiff, new MemDb());
+            dbProvider.RegisterDb(DbNames.StateRootToBlock, new MemDb());
+
+            BlockTree blockTree = new(
+                dbProvider,
+                new ChainLevelInfoRepository(dbProvider),
+                specProvider,
+                NullBloomStorage.Instance,
+                LimboLogs.Instance);
+            VerkleStateTree stateTree = new VerkleStateTree(dbProvider);
+            VerkleStateReader stateReader = new(stateTree, dbProvider.GetDb<IDb>(DbNames.Code), LimboLogs.Instance);
+            VerkleWorldState worldState = new VerkleWorldState(stateTree, dbProvider.RegisteredDbs[DbNames.Code], LimboLogs.Instance);
+            BlockhashProvider blockhashProvider = new(blockTree, LimboLogs.Instance);
+            VirtualMachine virtualMachine = new(
+                blockhashProvider,
+                specProvider,
+                LimboLogs.Instance);
+            TransactionProcessor txProcessor = new(
+                specProvider,
+                worldState,
+                virtualMachine,
+                LimboLogs.Instance);
+            BlockProcessor blockProcessor = new(
+                specProvider,
+                Always.Valid,
+                NoBlockRewards.Instance,
+                new BlockProcessor.BlockValidationTransactionsExecutor(txProcessor, new VerkleWorldState(stateTree, dbProvider.RegisteredDbs[DbNames.Code], LimboLogs.Instance)),
+                worldState,
+                NullReceiptStorage.Instance,
+                NullWitnessCollector.Instance,
+                LimboLogs.Instance);
+            BlockchainProcessor blockchainProcessor = new(
+                blockTree,
+                blockProcessor,
+                NullRecoveryStep.Instance,
+                stateReader,
+                LimboLogs.Instance,
+                BlockchainProcessor.Options.Default);
+            BuildBlocksWhenRequested trigger = new();
+            ManualTimestamper timestamper = new ManualTimestamper();
+            DevBlockProducer devBlockProducer = new(
+                EmptyTxSource.Instance,
+                blockchainProcessor,
+                worldState,
+                blockTree,
+                trigger,
+                timestamper,
+                specProvider,
+                new BlocksConfig(),
+                LimboLogs.Instance);
+
+            blockchainProcessor.Start();
+            devBlockProducer.Start();
+            ProducedBlockSuggester suggester = new ProducedBlockSuggester(blockTree, devBlockProducer);
+
+            AutoResetEvent autoResetEvent = new(false);
+
+            blockTree.NewHeadBlock += (s, e) => autoResetEvent.Set();
+            blockTree.SuggestBlock(Build.A.Block.Genesis.TestObject);
+
+            autoResetEvent.WaitOne(1000).Should().BeTrue("genesis");
+
+            trigger.BuildBlock();
+            autoResetEvent.WaitOne(1000).Should().BeTrue("1");
+            blockTree.Head.Number.Should().Be(1);
+        }
+
     }
 }

src/Nethermind/Nethermind.Blockchain.Test/TransactionSelectorTests.cs

@@ -155,9 +155,7 @@ public void Proper_transactions_selected(ProperTransactionsSelectedTestCase test
             MemDb stateDb = new();
             MemDb codeDb = new();
             TrieStore trieStore = new(stateDb, LimboLogs.Instance);
-            StateProvider stateProvider = new(trieStore, codeDb, LimboLogs.Instance);
-            StateReader stateReader =
-                new(new TrieStore(stateDb, LimboLogs.Instance), codeDb, LimboLogs.Instance);
+            IWorldState stateProvider = new WorldState(trieStore, codeDb, LimboLogs.Instance);
             ISpecProvider specProvider = Substitute.For<ISpecProvider>();
 
             void SetAccountStates(IEnumerable<Address> missingAddresses)

src/Nethermind/Nethermind.Blockchain/TrieStoreBoundaryWatcher.cs

@@ -13,11 +13,11 @@ namespace Nethermind.Blockchain
     /// </summary>
     public class TrieStoreBoundaryWatcher : IDisposable
     {
-        private readonly ITrieStore _trieStore;
+        private readonly IStoreWithReorgBoundary _trieStore;
         private readonly IBlockTree _blockTree;
         private readonly ILogger _logger;
 
-        public TrieStoreBoundaryWatcher(ITrieStore trieStore, IBlockTree blockTree, ILogManager logManager)
+        public TrieStoreBoundaryWatcher(IStoreWithReorgBoundary trieStore, IBlockTree blockTree, ILogManager logManager)
         {
             _trieStore = trieStore;
             _blockTree = blockTree;

src/Nethermind/Nethermind.Consensus.Ethash/EthashDifficultyCalculator.cs

@@ -24,7 +24,7 @@ public EthashDifficultyCalculator(ISpecProvider specProvider)
             _specProvider = specProvider;
         }
 
-        private const long OfGenesisBlock = 131_072;
+        private const long OfGenesisBlock = 5000;
 
         public UInt256 Calculate(BlockHeader header, BlockHeader parent) =>
             Calculate(parent.Difficulty,

src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs

@@ -65,7 +65,7 @@ public Task<IBlockProducer> InitBlockProducer(IBlockProductionTrigger? blockProd
             if (logger.IsWarn) logger.Warn("Starting Neth Dev block producer & sealer");
 
 
-            IReadOnlyTxProcessorSource producerEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, getFromApi.ReadOnlyTrieStore, readOnlyBlockTree, getFromApi.SpecProvider, getFromApi.LogManager);
+            IReadOnlyTxProcessorSource producerEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, getFromApi.ReadOnlyVerkleTrieStore, readOnlyBlockTree, getFromApi.SpecProvider, getFromApi.LogManager);
 
             BlockProcessor producerProcessor = new(
                 getFromApi!.SpecProvider,
@@ -85,16 +85,14 @@ public Task<IBlockProducer> InitBlockProducer(IBlockProductionTrigger? blockProd
                 getFromApi.LogManager,
                 BlockchainProcessor.Options.NoReceipts);
 
-            DefaultBlockProductionTrigger = new BuildBlocksRegularly(TimeSpan.FromMilliseconds(200))
-                .IfPoolIsNotEmpty(getFromApi.TxPool)
-                .Or(getFromApi.ManualBlockProductionTrigger);
+            DefaultBlockProductionTrigger = getFromApi.ManualBlockProductionTrigger;
 
             IBlockProducer blockProducer = new DevBlockProducer(
                 additionalTxSource.Then(txPoolTxSource).ServeTxsOneByOne(),
                 producerChainProcessor,
                 producerEnv.WorldState,
                 getFromApi.BlockTree,
-                blockProductionTrigger ?? DefaultBlockProductionTrigger,
+                DefaultBlockProductionTrigger,
                 getFromApi.Timestamper,
                 getFromApi.SpecProvider,
                 getFromApi.Config<IBlocksConfig>(),

src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs

@@ -12,6 +12,8 @@
 using Nethermind.Logging;
 using Nethermind.State;
 using Nethermind.Trie.Pruning;
+using Nethermind.Verkle;
+using Nethermind.Verkle.Tree;
 
 // ReSharper disable MemberCanBePrivate.Global
 // ReSharper disable UnusedAutoPropertyAccessor.Global
@@ -36,6 +38,16 @@ public ReadOnlyTxProcessingEnv(
         {
         }
 
+        public ReadOnlyTxProcessingEnv(
+            IDbProvider? dbProvider,
+            ReadOnlyVerkleStateStore? trieStore,
+            IBlockTree? blockTree,
+            ISpecProvider? specProvider,
+            ILogManager? logManager)
+            : this(dbProvider?.AsReadOnly(false), trieStore, blockTree?.AsReadOnly(), specProvider, logManager)
+        {
+        }
+
         public ReadOnlyTxProcessingEnv(
             IReadOnlyDbProvider? readOnlyDbProvider,
             IReadOnlyTrieStore? readOnlyTrieStore,
@@ -57,6 +69,27 @@ public ReadOnlyTxProcessingEnv(
             TransactionProcessor = new TransactionProcessor(specProvider, WorldState, Machine, logManager);
         }
 
+        public ReadOnlyTxProcessingEnv(
+            IReadOnlyDbProvider? readOnlyDbProvider,
+            ReadOnlyVerkleStateStore? readOnlyTrieStore,
+            IReadOnlyBlockTree? readOnlyBlockTree,
+            ISpecProvider? specProvider,
+            ILogManager? logManager)
+        {
+            if (specProvider is null) throw new ArgumentNullException(nameof(specProvider));
+
+            ReadOnlyDb codeDb = readOnlyDbProvider.CodeDb.AsReadOnly(true);
+
+            StateReader = new VerkleStateReader(new VerkleStateTree(readOnlyTrieStore), codeDb, logManager);
+            WorldState = new VerkleWorldState(new VerkleStateTree(readOnlyTrieStore), codeDb, logManager);
+
+            BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree));
+            BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
+
+            Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager);
+            TransactionProcessor = new TransactionProcessor(specProvider, WorldState, Machine, logManager);
+        }
+
         public IReadOnlyTransactionProcessor Build(Keccak stateRoot) => new ReadOnlyTransactionProcessor(TransactionProcessor, WorldState, stateRoot);
     }
 }

src/Nethermind/Nethermind.Consensus/Producers/BlockProducerBase.cs

@@ -233,7 +233,7 @@ protected bool TrySetState(Keccak? parentStateRoot)
         {
             bool HasState(Keccak stateRoot)
             {
-                RootCheckVisitor visitor = new();
+                RootCheckVisitor visitor = new RootCheckVisitor();
                 StateProvider.Accept(visitor, stateRoot);
                 return visitor.HasRoot;
             }

src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+using System;
 using Nethermind.Blockchain;
 using Nethermind.Blockchain.Receipts;
 using Nethermind.Config;
@@ -16,6 +17,8 @@
 using Nethermind.State;
 using Nethermind.Trie.Pruning;
 using Nethermind.TxPool;
+using Nethermind.Verkle;
+using Nethermind.Verkle.Tree;
 
 namespace Nethermind.Consensus.Producers
 {
@@ -24,6 +27,7 @@ public class BlockProducerEnvFactory : IBlockProducerEnvFactory
         protected readonly IDbProvider _dbProvider;
         protected readonly IBlockTree _blockTree;
         protected readonly IReadOnlyTrieStore _readOnlyTrieStore;
+        protected readonly ReadOnlyVerkleStateStore _readOnlyVerkleTrieStore;
         protected readonly ISpecProvider _specProvider;
         protected readonly IBlockValidator _blockValidator;
         protected readonly IRewardCalculatorSource _rewardCalculatorSource;
@@ -33,6 +37,7 @@ public class BlockProducerEnvFactory : IBlockProducerEnvFactory
         protected readonly ITransactionComparerProvider _transactionComparerProvider;
         protected readonly IBlocksConfig _blocksConfig;
         protected readonly ILogManager _logManager;
+        protected readonly TreeType _treeType;
 
         public IBlockTransactionsExecutorFactory TransactionsExecutorFactory { get; set; }
 
@@ -62,6 +67,38 @@ public BlockProducerEnvFactory(
             _transactionComparerProvider = transactionComparerProvider;
             _blocksConfig = blocksConfig;
             _logManager = logManager;
+            _treeType = TreeType.MerkleTree;
+
+            TransactionsExecutorFactory = new BlockProducerTransactionsExecutorFactory(specProvider, logManager);
+        }
+
+        public BlockProducerEnvFactory(
+            IDbProvider dbProvider,
+            IBlockTree blockTree,
+            ReadOnlyVerkleStateStore readOnlyTrieStore,
+            ISpecProvider specProvider,
+            IBlockValidator blockValidator,
+            IRewardCalculatorSource rewardCalculatorSource,
+            IReceiptStorage receiptStorage,
+            IBlockPreprocessorStep blockPreprocessorStep,
+            ITxPool txPool,
+            ITransactionComparerProvider transactionComparerProvider,
+            IBlocksConfig blocksConfig,
+            ILogManager logManager)
+        {
+            _dbProvider = dbProvider;
+            _blockTree = blockTree;
+            _readOnlyVerkleTrieStore = readOnlyTrieStore;
+            _specProvider = specProvider;
+            _blockValidator = blockValidator;
+            _rewardCalculatorSource = rewardCalculatorSource;
+            _receiptStorage = receiptStorage;
+            _blockPreprocessorStep = blockPreprocessorStep;
+            _txPool = txPool;
+            _transactionComparerProvider = transactionComparerProvider;
+            _blocksConfig = blocksConfig;
+            _logManager = logManager;
+            _treeType = TreeType.VerkleTree;
 
             TransactionsExecutorFactory = new BlockProducerTransactionsExecutorFactory(specProvider, logManager);
         }
@@ -106,8 +143,16 @@ public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null)
             };
         }
 
-        protected virtual IReadOnlyTxProcessorSource CreateReadonlyTxProcessingEnv(ReadOnlyDbProvider readOnlyDbProvider, ReadOnlyBlockTree readOnlyBlockTree) =>
-            new ReadOnlyTxProcessingEnv(readOnlyDbProvider, _readOnlyTrieStore, readOnlyBlockTree, _specProvider, _logManager);
+        protected virtual IReadOnlyTxProcessorSource CreateReadonlyTxProcessingEnv(ReadOnlyDbProvider readOnlyDbProvider, ReadOnlyBlockTree readOnlyBlockTree)
+        {
+            return _treeType switch
+            {
+                TreeType.MerkleTree => new ReadOnlyTxProcessingEnv(readOnlyDbProvider, _readOnlyTrieStore, readOnlyBlockTree, _specProvider, _logManager),
+                TreeType.VerkleTree => new ReadOnlyTxProcessingEnv(readOnlyDbProvider, _readOnlyVerkleTrieStore, readOnlyBlockTree, _specProvider, _logManager),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+        }
+
 
         protected virtual ITxSource CreateTxSourceForProducer(
             ITxSource? additionalTxSource,