StorageValue

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -361,24 +361,24 @@ private List<string> RunAssertions(BlockchainTest test, Block headBlock, IWorldS
             differencesBefore = differences.Count;
 
             KeyValuePair<UInt256, byte[]>[] clearedStorages = new KeyValuePair<UInt256, byte[]>[0];
-            if (test.Pre.ContainsKey(acountAddress))
+            if (test.Pre.TryGetValue(acountAddress, out var v))
             {
-                clearedStorages = test.Pre[acountAddress].Storage.Where(s => !accountState.Storage.ContainsKey(s.Key)).ToArray();
+                clearedStorages = v.Storage.Where(s => !accountState.Storage.ContainsKey(s.Key)).ToArray();
             }
 
             foreach (KeyValuePair<UInt256, byte[]> clearedStorage in clearedStorages)
             {
-                ReadOnlySpan<byte> value = !stateProvider.AccountExists(acountAddress) ? Bytes.Empty : stateProvider.Get(new StorageCell(acountAddress, clearedStorage.Key));
-                if (!value.IsZero())
+                StorageValue value = !stateProvider.AccountExists(acountAddress) ? StorageValue.Zero : stateProvider.Get(new StorageCell(acountAddress, clearedStorage.Key));
+                if (!value.IsZero)
                 {
                     differences.Add($"{acountAddress} storage[{clearedStorage.Key}] exp: 0x00, actual: {value.ToHexString(true)}");
                 }
             }
 
             foreach (KeyValuePair<UInt256, byte[]> storageItem in accountState.Storage)
             {
-                ReadOnlySpan<byte> value = !stateProvider.AccountExists(acountAddress) ? Bytes.Empty : stateProvider.Get(new StorageCell(acountAddress, storageItem.Key));
-                if (!Bytes.AreEqual(storageItem.Value, value))
+                StorageValue value = !stateProvider.AccountExists(acountAddress) ? StorageValue.Zero : stateProvider.Get(new StorageCell(acountAddress, storageItem.Key));
+                if (!new StorageValue(storageItem.Value).Equals(value))
                 {
                     differences.Add($"{acountAddress} storage[{storageItem.Key}] exp: {storageItem.Value.ToHexString(true)}, actual: {value.ToHexString(true)}");
                 }

src/Nethermind/Nethermind.Benchmark/State/StorageAccessBenchmark.cs

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using BenchmarkDotNet.Attributes;
+using Nethermind.Core;
+using Nethermind.Core.Crypto;
+using Nethermind.Db;
+using Nethermind.Int256;
+using Nethermind.Logging;
+using Nethermind.Specs.Forks;
+using Nethermind.State;
+using Nethermind.Trie.Pruning;
+
+namespace Nethermind.Benchmarks.State;
+
+[DisassemblyDiagnoser]
+[MemoryDiagnoser]
+public class StorageAccessBenchmark
+{
+    private WorldState _preCached;
+    private WorldState _notCached;
+    private StorageValueMap _map;
+
+    private const uint MaxPrecalculatedIndex = 1024;
+
+    private static readonly Address Account = new(Keccak.Compute("test"));
+    private static readonly StorageCell A = new(Account, MaxPrecalculatedIndex / 2);
+    private static readonly StorageCell B = new(Account, MaxPrecalculatedIndex / 2 - 1);
+    private static readonly StorageCell C = new(Account, MaxPrecalculatedIndex / 2 - 2);
+    private static readonly StorageCell D = new(Account, MaxPrecalculatedIndex / 2 - 3);
+
+    private static readonly StorageValue ValueA = new(new UInt256(1));
+    private static readonly StorageValue ValueB = new(new UInt256(2));
+    private static readonly StorageValue ValueC = new(new UInt256(3));
+    private static readonly StorageValue ValueD = new(new UInt256(4));
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var preCache = new PreBlockCaches();
+        var code = new MemDb();
+        _map = new StorageValueMap();
+
+        _preCached = new WorldState(new TrieStore(new MemDb("storage"), NullLogManager.Instance), code,
+            LimboLogs.Instance, preCache, false);
+
+        _notCached = new WorldState(new TrieStore(new MemDb("storage"), NullLogManager.Instance), code,
+            LimboLogs.Instance, null, false);
+
+        _notCached.CreateAccount(Account, 100, 100);
+
+        for (uint i = 0; i < MaxPrecalculatedIndex; i++)
+        {
+            var cell = new StorageCell(Account, i);
+            var value = new StorageValue(i);
+
+            preCache.StorageCache[cell] = _map.Map(value);
+            _preCached.Set(cell, value);
+            _notCached.Set(cell, value);
+        }
+
+        _preCached.Commit(Prague.Instance);
+        _preCached.CommitTree(123);
+        _notCached.Commit(Prague.Instance);
+        _notCached.CommitTree(123);
+    }
+
+    [Benchmark]
+    public void Just_reset()
+    {
+        _notCached.Reset(true);
+    }
+
+    [Benchmark(OperationsPerInvoke = 4)]
+    public bool PreCached_small_indexes()
+    {
+        _preCached.Reset(true);
+
+        return
+            _preCached.Get(A).IsZero &&
+            _preCached.Get(B).IsZero &&
+            _preCached.Get(C).IsZero &&
+            _preCached.Get(D).IsZero;
+    }
+
+    [Benchmark(OperationsPerInvoke = 4)]
+    public bool NotCached_small_indexes()
+    {
+        _notCached.Reset(true);
+
+        return
+            _notCached.Get(A).IsZero &&
+            _notCached.Get(B).IsZero &&
+            _notCached.Get(C).IsZero &&
+            _notCached.Get(D).IsZero;
+    }
+
+    [Benchmark(OperationsPerInvoke = 4)]
+    public void Set()
+    {
+        _notCached.Reset(true);
+
+        _notCached.Set(A, ValueA);
+        _notCached.Set(B, ValueB);
+        _notCached.Set(C, ValueC);
+        _notCached.Set(D, ValueD);
+    }
+}

src/Nethermind/Nethermind.Benchmark/State/StorageCellBenchmark.cs

@@ -17,7 +17,6 @@ public class StorageCellBenchmark
 
         private const int OperationsPerInvoke = 1000;
 
-
         [GlobalSetup]
         public void Setup()
         {
@@ -46,11 +45,11 @@ private class StorageTracer : IStorageTracer
         {
             public bool IsTracingStorage => throw new NotImplementedException();
 
-            public void ReportStorageChange(in ReadOnlySpan<byte> key, in ReadOnlySpan<byte> value) =>
+            public void ReportStorageChange(in ReadOnlySpan<byte> key, in StorageValue value) =>
                 throw new NotImplementedException();
 
             [MethodImpl(MethodImplOptions.NoInlining)]
-            public void ReportStorageChange(in StorageCell storageCell, byte[] before, byte[] after) { }
+            public void ReportStorageChange(in StorageCell storageCell, in StorageValue before, in StorageValue after) { }
 
             [MethodImpl(MethodImplOptions.NoInlining)]
             public void ReportStorageRead(in StorageCell storageCell) { }

src/Nethermind/Nethermind.Benchmark/State/StorageValueBenchmark.cs

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using BenchmarkDotNet.Attributes;
+using Nethermind.Core;
+
+namespace Nethermind.Benchmarks.State;
+
+public class StorageValueBenchmark
+{
+    [Benchmark(OperationsPerInvoke = 8)]
+    [Arguments(0)]
+    [Arguments(1)]
+    [Arguments(8)]
+    [Arguments(9)]
+    [Arguments(17)]
+    [Arguments(18)]
+    [Arguments(23)]
+    [Arguments(24)]
+    [Arguments(31)]
+    public int LeadingZeros(int nonZero)
+    {
+        Span<byte> span = stackalloc byte[32];
+        span[nonZero] = 1;
+
+        var v = new StorageValue(span);
+
+        return
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length +
+
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length +
+            v.BytesWithNoLeadingZeroes.Length;
+    }
+}

src/Nethermind/Nethermind.Benchmark/State/StorageValueMapBenchmark.cs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using BenchmarkDotNet.Attributes;
+using Nethermind.Core;
+using Nethermind.Int256;
+using Nethermind.State;
+
+namespace Nethermind.Benchmarks.State;
+
+[DisassemblyDiagnoser]
+public class StorageValueMapBenchmark
+{
+    private StorageValueMap _map;
+
+    private static readonly StorageValue Value = new(new UInt256(1));
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _map = new StorageValueMap(1024);
+    }
+
+    [Benchmark]
+    public void Map()
+    {
+        _map.Map(Value);
+    }
+}

src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs

@@ -17,8 +17,6 @@ namespace Nethermind.Blockchain.Blocks;
 public class BlockhashStore(ISpecProvider specProvider, IWorldState worldState)
     : IBlockhashStore
 {
-    private static readonly byte[] EmptyBytes = [0];
-
     public void ApplyBlockhashStateChanges(BlockHeader blockHeader)
     {
         IReleaseSpec spec = specProvider.GetSpec(blockHeader);
@@ -30,7 +28,7 @@ public void ApplyBlockhashStateChanges(BlockHeader blockHeader)
         Hash256 parentBlockHash = blockHeader.ParentHash;
         var parentBlockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize));
         StorageCell blockHashStoreCell = new(eip2935Account, parentBlockIndex);
-        worldState.Set(blockHashStoreCell, parentBlockHash!.Bytes.WithoutLeadingZeros().ToArray());
+        worldState.Set(blockHashStoreCell, new StorageValue(parentBlockHash!.Bytes));
     }
 
     public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber)
@@ -44,7 +42,7 @@ public void ApplyBlockhashStateChanges(BlockHeader blockHeader)
         var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize));
         Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress;
         StorageCell blockHashStoreCell = new(eip2935Account, blockIndex);
-        ReadOnlySpan<byte> data = worldState.Get(blockHashStoreCell);
-        return data.SequenceEqual(EmptyBytes) ? null : Hash256.FromBytesWithPadding(data);
+        ref readonly StorageValue data = ref worldState.Get(blockHashStoreCell);
+        return data.IsZero ? null : Hash256.FromBytesWithPadding(data.Bytes);
     }
 }

src/Nethermind/Nethermind.Blockchain/GenesisLoader.cs

@@ -66,7 +66,7 @@ private void Preallocate(Block genesis)
                     foreach (KeyValuePair<UInt256, byte[]> storage in allocation.Storage)
                     {
                         _stateProvider.Set(new StorageCell(address, storage.Key),
-                            storage.Value.WithoutLeadingZeros().ToArray());
+                            new StorageValue(storage.Value));
                     }
                 }
 

src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs

@@ -197,7 +197,7 @@ protected virtual async Task<TestBlockchain> Build(Action<ContainerBuilder>? con
         byte[] code = Bytes.FromHexString("0xabcd");
         state.InsertCode(TestItem.AddressA, code, SpecProvider.GenesisSpec);
 
-        state.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
+        state.Set(new StorageCell(TestItem.AddressA, UInt256.One), new StorageValue(Bytes.FromHexString("0xabcdef")));
 
         state.Commit(SpecProvider.GenesisSpec);
         state.CommitTree(0);