StorageValue

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

@@ -362,24 +362,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,106 @@
+// 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 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();
+
+        _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] = 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.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);

src/Nethermind/Nethermind.Core.Test/RlpTests.cs

@@ -38,7 +38,8 @@ public void Serializing_sequence_with_one_int_regression()
         }
 
         [Test]
-        [Explicit("That was a regression test but now it is failing again and cannot find the reason we needed this behaviour in the first place. Sync works all fine. Leaving it here as it may resurface - make sure to add more explanation to it in such case.")]
+        [Explicit(
+            "That was a regression test but now it is failing again and cannot find the reason we needed this behaviour in the first place. Sync works all fine. Leaving it here as it may resurface - make sure to add more explanation to it in such case.")]
         public void Serializing_object_int_regression()
         {
             Rlp output = Rlp.Encode(new[] { Rlp.Encode(1) });
@@ -99,11 +100,9 @@ public void Long_negative()
         public void Empty_byte_array()
         {
             byte[] bytes = [];
-            Rlp rlp = Rlp.Encode(bytes);
-            Rlp rlpSpan = Rlp.Encode(bytes.AsSpan());
             Rlp expectedResult = new(new byte[] { 128 });
-            Assert.That(rlp, Is.EqualTo(expectedResult), "byte array");
-            Assert.That(rlpSpan, Is.EqualTo(expectedResult), "span");
+
+            AssertAllEncodings(expectedResult, bytes);
         }
 
         [TestCase(0)]
@@ -112,23 +111,19 @@ public void Empty_byte_array()
         public void Byte_array_of_length_1_and_first_byte_value_less_than_128(byte value)
         {
             byte[] bytes = { value };
-            Rlp rlp = Rlp.Encode(bytes);
-            Rlp rlpSpan = Rlp.Encode(bytes.AsSpan());
             Rlp expectedResult = new(new[] { value });
-            Assert.That(rlp, Is.EqualTo(expectedResult), "byte array");
-            Assert.That(rlpSpan, Is.EqualTo(expectedResult), "span");
+
+            AssertAllEncodings(expectedResult, bytes);
         }
 
         [TestCase(128)]
         [TestCase(255)]
         public void Byte_array_of_length_1_and_first_byte_value_equal_or_more_than_128(byte value)
         {
             byte[] bytes = { value };
-            Rlp rlp = Rlp.Encode(bytes);
-            Rlp rlpSpan = Rlp.Encode(bytes.AsSpan());
             Rlp expectedResult = new(new[] { (byte)129, value });
-            Assert.That(rlp, Is.EqualTo(expectedResult), "byte array");
-            Assert.That(rlpSpan, Is.EqualTo(expectedResult), "span");
+
+            AssertAllEncodings(expectedResult, bytes);
         }
 
         [Test]
@@ -147,8 +142,7 @@ public void Byte_array_of_length_55()
 
             Rlp expectedResult = new(expectedResultBytes);
 
-            Assert.That(Rlp.Encode(input), Is.EqualTo(expectedResult), "byte array");
-            Assert.That(Rlp.Encode(input.AsSpan()), Is.EqualTo(expectedResult), "span");
+            AssertAllEncodings(expectedResult, input);
         }
 
         [Test]
@@ -168,8 +162,7 @@ public void Byte_array_of_length_56()
 
             Rlp expectedResult = new(expectedResultBytes);
 
-            Assert.That(Rlp.Encode(input), Is.EqualTo(expectedResult), "byte array");
-            Assert.That(Rlp.Encode(input.AsSpan()), Is.EqualTo(expectedResult), "span");
+            AssertAllEncodings(expectedResult, input);
         }
 
         [Test]
@@ -190,22 +183,22 @@ public void Long_byte_array()
 
             Rlp expectedResult = new(expectedResultBytes);
 
-            Assert.That(Rlp.Encode(input), Is.EqualTo(expectedResult), "byte array");
-            Assert.That(Rlp.Encode(input.AsSpan()), Is.EqualTo(expectedResult), "span");
+            AssertAllEncodings(expectedResult, input);
         }
 
         [TestCase(new byte[] { 127, 1, 2, 2 }, false)]
         [TestCase(new byte[] { 130, 1, 0 }, true)]
         [TestCase(new byte[] { 130, 0, 2, 2 }, false)]
         [TestCase(new byte[] { 130, 0, 2, 2 }, false)]
         [TestCase(new byte[]
-        {184, 56,
-            1,0,0,0,0,0,0,0,
-            1,0,0,0,0,0,0,0,
-            1,0,0,0,0,0,0,0,
-            1,0,0,0,0,0,0,0,
-            1,0,0,0,0,0,0,0,
-            1,0,0,0,0,0,0,0
+        {
+            184, 56,
+            1, 0, 0, 0, 0, 0, 0, 0,
+            1, 0, 0, 0, 0, 0, 0, 0,
+            1, 0, 0, 0, 0, 0, 0, 0,
+            1, 0, 0, 0, 0, 0, 0, 0,
+            1, 0, 0, 0, 0, 0, 0, 0,
+            1, 0, 0, 0, 0, 0, 0, 0
         }, true)]
         public void Strange_bool(byte[] rlp, bool expectedBool)
         {
@@ -272,5 +265,12 @@ public void RlpContextWithSliceMemory_shouldNotCopyUnderlyingData(bool sliceValu
                 isACopy.Should().NotBe(sliceValue);
             }
         }
+
+        private static void AssertAllEncodings(Rlp expected, byte[] bytes)
+        {
+            Assert.That(Rlp.Encode(bytes), Is.EqualTo(expected), "byte array");
+            Assert.That(Rlp.Encode(bytes.AsSpan()), Is.EqualTo(expected), "span");
+            Rlp.EncodeToArray(bytes).Should().BeEquivalentTo(expected.Bytes, "to array");
+        }
     }
 }