Shrink Trienodes (#7915)

benaadams · web-flow · commit 72529432dbbb · 2024-12-18T09:51:33.000Z
diff --git a/src/Nethermind/Nethermind.Core/Crypto/Hash256.cs b/src/Nethermind/Nethermind.Core/Crypto/Hash256.cs
@@ -144,8 +144,7 @@ public sealed class Hash256 : IEquatable<Hash256>, IComparable<Hash256>
         public static readonly Hash256 Zero = new("0x0000000000000000000000000000000000000000000000000000000000000000");
 
         public const int MemorySize =
-            MemorySizes.SmallObjectOverhead -
-            MemorySizes.RefSize +
+            MemorySizes.ObjectHeaderMethodTable +
             Size;
 
         private readonly ValueHash256 _hash256;
diff --git a/src/Nethermind/Nethermind.Core/MemorySizes.cs b/src/Nethermind/Nethermind.Core/MemorySizes.cs
@@ -20,6 +20,7 @@ public static long Align(long unalignedSize)
 
         public const int RefSize = 8;
 
+        public const int ObjectHeaderMethodTable = 16;
         public const int SmallObjectOverhead = 24;
 
         public const int SmallObjectFreeDataSize = 8;
diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/RlpFactory.cs b/src/Nethermind/Nethermind.Serialization.Rlp/RlpFactory.cs
@@ -8,9 +8,9 @@ namespace Nethermind.Serialization.Rlp
 {
     public class RlpFactory
     {
-        public long MemorySize => MemorySizes.SmallObjectOverhead
+        public long MemorySize => MemorySizes.ObjectHeaderMethodTable
                                     + MemorySizes.Align(MemorySizes.ArrayOverhead + _data.Length)
-                                    + MemorySizes.Align(sizeof(int));
+                                    + MemorySizes.Align(MemorySizes.RefSize + sizeof(int));
 
         private readonly CappedArray<byte> _data;
 
diff --git a/src/Nethermind/Nethermind.Serialization.Rlp/RlpStream.cs b/src/Nethermind/Nethermind.Serialization.Rlp/RlpStream.cs
@@ -1479,6 +1479,6 @@ public byte[][] DecodeByteArrays()
         }
 
         internal static ReadOnlySpan<byte> SingleBytes => new byte[128] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127 };
-        internal static byte[][] SingleByteArrays = new byte[128][] { [0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28], [29], [30], [31], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44], [45], [46], [47], [48], [49], [50], [51], [52], [53], [54], [55], [56], [57], [58], [59], [60], [61], [62], [63], [64], [65], [66], [67], [68], [69], [70], [71], [72], [73], [74], [75], [76], [77], [78], [79], [80], [81], [82], [83], [84], [85], [86], [87], [88], [89], [90], [91], [92], [93], [94], [95], [96], [97], [98], [99], [100], [101], [102], [103], [104], [105], [106], [107], [108], [109], [110], [111], [112], [113], [114], [115], [116], [117], [118], [119], [120], [121], [122], [123], [124], [125], [126], [127] };
+        internal static readonly byte[][] SingleByteArrays = new byte[128][] { [0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28], [29], [30], [31], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44], [45], [46], [47], [48], [49], [50], [51], [52], [53], [54], [55], [56], [57], [58], [59], [60], [61], [62], [63], [64], [65], [66], [67], [68], [69], [70], [71], [72], [73], [74], [75], [76], [77], [78], [79], [80], [81], [82], [83], [84], [85], [86], [87], [88], [89], [90], [91], [92], [93], [94], [95], [96], [97], [98], [99], [100], [101], [102], [103], [104], [105], [106], [107], [108], [109], [110], [111], [112], [113], [114], [115], [116], [117], [118], [119], [120], [121], [122], [123], [124], [125], [126], [127] };
     }
 }
diff --git a/src/Nethermind/Nethermind.Synchronization/SnapSync/SnapProviderHelper.cs b/src/Nethermind/Nethermind.Synchronization/SnapSync/SnapProviderHelper.cs
@@ -311,23 +311,26 @@ private static void StitchBoundaries(List<(TrieNode, TreePath)> sortedBoundaryLi
 
                 if (!node.IsPersisted)
                 {
-                    if (node.IsExtension)
+                    INodeData nodeData = node.NodeData;
+                    if (nodeData is ExtensionData extensionData)
                     {
-                        if (IsChildPersisted(node, ref path, ExtensionRlpChildIndex, store))
+                        if (IsChildPersisted(node, ref path, extensionData._value, ExtensionRlpChildIndex, store))
                         {
                             node.IsBoundaryProofNode = false;
                         }
                     }
-                    else if (node.IsBranch)
+                    else if (nodeData is BranchData branchData)
                     {
                         bool isBoundaryProofNode = false;
-                        for (int ci = 0; ci <= 15; ci++)
+                        int ci = 0;
+                        foreach (object? o in branchData.Branches)
                         {
-                            if (!IsChildPersisted(node, ref path, ci, store))
+                            if (!IsChildPersisted(node, ref path, o, ci, store))
                             {
                                 isBoundaryProofNode = true;
                                 break;
                             }
+                            ci++;
                         }
 
                         node.IsBoundaryProofNode = isBoundaryProofNode;
@@ -336,15 +339,19 @@ private static void StitchBoundaries(List<(TrieNode, TreePath)> sortedBoundaryLi
             }
         }
 
-        private static bool IsChildPersisted(TrieNode node, ref TreePath nodePath, int childIndex, IScopedTrieStore store)
+        private static bool IsChildPersisted(TrieNode node, ref TreePath nodePath, object? child, int childIndex, IScopedTrieStore store)
         {
-            TrieNode data = node.GetData(childIndex) as TrieNode;
-            if (data is not null)
+            if (child is TrieNode childNode)
             {
-                return data.IsBoundaryProofNode == false;
+                return childNode.IsBoundaryProofNode == false;
             }
 
-            if (!node.GetChildHashAsValueKeccak(childIndex, out ValueHash256 childKeccak))
+            ValueHash256 childKeccak;
+            if (child is Hash256 hash)
+            {
+                childKeccak = hash.ValueHash256;
+            }
+            else if (!node.GetChildHashAsValueKeccak(childIndex, out childKeccak))
             {
                 return true;
             }
diff --git a/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs b/src/Nethermind/Nethermind.Trie.Test/Pruning/TreeStoreTests.cs
@@ -198,7 +198,7 @@ public void FindCachedOrUnknown_CorrectlyCalculatedMemoryUsedByDirtyCache()
             long startSize = trieStore.MemoryUsedByDirtyCache;
             trieStore.FindCachedOrUnknown(null, TreePath.Empty, TestItem.KeccakA);
             TrieNode trieNode = new(NodeType.Leaf, Keccak.Zero);
-            long oneKeccakSize = trieNode.GetMemorySize(false) + ExpectedPerNodeKeyMemorySize;
+            long oneKeccakSize = trieNode.GetMemorySize(false) + ExpectedPerNodeKeyMemorySize - MemorySizes.SmallObjectOverhead;
             Assert.That(trieStore.MemoryUsedByDirtyCache, Is.EqualTo(startSize + oneKeccakSize));
             trieStore.FindCachedOrUnknown(null, TreePath.Empty, TestItem.KeccakB);
             Assert.That(trieStore.MemoryUsedByDirtyCache, Is.EqualTo(2 * oneKeccakSize + startSize));
@@ -253,7 +253,7 @@ public void Memory_with_concurrent_commits_is_correct()
                 tree.Commit();
             }
 
-            fullTrieStore.MemoryUsedByDirtyCache.Should().Be(_scheme == INodeStorage.KeyScheme.Hash ? 591672L : 661820L);
+            fullTrieStore.MemoryUsedByDirtyCache.Should().Be(_scheme == INodeStorage.KeyScheme.Hash ? 540560L : 610708L);
             fullTrieStore.CommittedNodesCount.Should().Be(1349);
         }
 
@@ -1017,7 +1017,7 @@ public async Task Will_Not_RemovePastKeys_OnSnapshot_DuringFullPruning()
 
             memDb.Count.Should().Be(61);
             fullTrieStore.Prune();
-            fullTrieStore.MemoryUsedByDirtyCache.Should().Be(_scheme == INodeStorage.KeyScheme.Hash ? 504 : 660);
+            fullTrieStore.MemoryUsedByDirtyCache.Should().Be(_scheme == INodeStorage.KeyScheme.Hash ? 552 : 708);
         }
 
         [Test]
diff --git a/src/Nethermind/Nethermind.Trie.Test/TrieNodeTests.cs b/src/Nethermind/Nethermind.Trie.Test/TrieNodeTests.cs
@@ -548,29 +548,28 @@ public void Can_encode_branch_with_unresolved_children()
     public void Size_of_a_heavy_leaf_is_correct()
     {
         Context ctx = new();
-        Assert.That(ctx.HeavyLeaf.GetMemorySize(false), Is.EqualTo(248));
+        Assert.That(ctx.HeavyLeaf.GetMemorySize(false), Is.EqualTo(208));
     }
 
     [Test]
     public void Size_of_a_tiny_leaf_is_correct()
     {
         Context ctx = new();
-        Assert.That(ctx.TiniestLeaf.GetMemorySize(false), Is.EqualTo(168));
+        Assert.That(ctx.TiniestLeaf.GetMemorySize(false), Is.EqualTo(136));
     }
 
     [Test]
     public void Size_of_a_branch_is_correct()
     {
         Context ctx = new();
         TrieNode node = new(NodeType.Branch);
-        node.Key = new byte[] { 1 };
         for (int i = 0; i < 16; i++)
         {
             node.SetChild(i, ctx.AccountLeaf);
         }
 
-        Assert.That(node.GetMemorySize(true), Is.EqualTo(4048));
-        Assert.That(node.GetMemorySize(false), Is.EqualTo(208));
+        Assert.That(node.GetMemorySize(true), Is.EqualTo(3376));
+        Assert.That(node.GetMemorySize(false), Is.EqualTo(176));
     }
 
     [Test]
@@ -581,7 +580,7 @@ public void Size_of_an_extension_is_correct()
         trieNode.Key = new byte[] { 1 };
         trieNode.SetChild(0, ctx.TiniestLeaf);
 
-        Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(120));
+        Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(96));
     }
 
     [Test]
@@ -592,53 +591,53 @@ public void Size_of_unknown_node_is_correct()
         trieNode.Key = new byte[] { 1 };
         trieNode.SetChild(0, ctx.TiniestLeaf);
 
-        Assert.That(trieNode.GetMemorySize(true), Is.EqualTo(288));
-        Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(120));
+        Assert.That(trieNode.GetMemorySize(true), Is.EqualTo(232));
+        Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(96));
     }
 
     [Test]
     public void Size_of_an_unknown_empty_node_is_correct()
     {
         TrieNode trieNode = new(NodeType.Unknown);
-        trieNode.GetMemorySize(false).Should().Be(56);
+        trieNode.GetMemorySize(false).Should().Be(48);
     }
 
     [Test]
     public void Size_of_an_unknown_node_with_keccak_is_correct()
     {
         TrieNode trieNode = new(NodeType.Unknown, Keccak.Zero);
-        trieNode.GetMemorySize(false).Should().Be(104);
+        trieNode.GetMemorySize(false).Should().Be(96);
     }
 
     [Test]
     public void Size_of_extension_with_child()
     {
         TrieNode trieNode = new(NodeType.Extension);
         trieNode.SetChild(0, null);
-        trieNode.GetMemorySize(false).Should().Be(96);
+        trieNode.GetMemorySize(false).Should().Be(64);
     }
 
     [Test]
     public void Size_of_branch_with_data()
     {
         TrieNode trieNode = new(NodeType.Branch);
         trieNode.SetChild(0, null);
-        trieNode.GetMemorySize(false).Should().Be(208);
+        trieNode.GetMemorySize(false).Should().Be(176);
     }
 
     [Test]
     public void Size_of_leaf_with_value()
     {
         TrieNode trieNode = new(NodeType.Leaf);
         trieNode.Value = new byte[7];
-        trieNode.GetMemorySize(false).Should().Be(152);
+        trieNode.GetMemorySize(false).Should().Be(104);
     }
 
     [Test]
     public void Size_of_an_unknown_node_with_full_rlp_is_correct()
     {
         TrieNode trieNode = new(NodeType.Unknown, new byte[7]);
-        trieNode.GetMemorySize(false).Should().Be(120);
+        trieNode.GetMemorySize(false).Should().Be(112);
     }
 
     [Test]
@@ -738,7 +737,7 @@ public void Extension_child_as_keccak_memory_size()
         trieNode.SetChild(0, child);
 
         trieNode.PrunePersistedRecursively(1);
-        trieNode.GetMemorySize(false).Should().Be(144);
+        trieNode.GetMemorySize(false).Should().Be(112);
     }
 
     [Test]
@@ -751,7 +750,7 @@ public void Extension_child_as_keccak_clone()
         trieNode.PrunePersistedRecursively(1);
         TrieNode cloned = trieNode.Clone();
 
-        cloned.GetMemorySize(false).Should().Be(144);
+        cloned.GetMemorySize(false).Should().Be(112);
     }
 
     [Test]
diff --git a/src/Nethermind/Nethermind.Trie/HexPrefix.cs b/src/Nethermind/Nethermind.Trie/HexPrefix.cs
@@ -16,7 +16,7 @@ public static void CopyToSpan(byte[] path, bool isLeaf, Span<byte> output)
         {
             if (output.Length != ByteLength(path)) throw new ArgumentOutOfRangeException(nameof(output));
 
-            output[0] = (byte)(isLeaf ? 0x20 : 0x000);
+            output[0] = (byte)(isLeaf ? 0x20 : 0x00);
             if (path.Length % 2 != 0)
             {
                 output[0] += (byte)(0x10 + path[0]);
diff --git a/src/Nethermind/Nethermind.Trie/NodeData.cs b/src/Nethermind/Nethermind.Trie/NodeData.cs
@@ -0,0 +1,137 @@
+// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+using System;
+using System.Runtime.CompilerServices;
+using Nethermind.Core.Buffers;
+using Nethermind.Core;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
+
+namespace Nethermind.Trie;
+
+public interface INodeData
+{
+    public NodeType NodeType { get; }
+    public INodeData Clone();
+    public int Length { get; }
+    public ref object this[int index] { get; }
+    public int MemorySize { get; }
+}
+
+interface INodeWithKey : INodeData
+{
+    public byte[] Key { get; set; }
+}
+
+public class BranchData : INodeData
+{
+    public NodeType NodeType => NodeType.Branch;
+    public int Length => TrieNode.BranchesCount;
+    public int MemorySize => MemorySizes.RefSize * TrieNode.BranchesCount;
+
+    private BranchArray _branches;
+
+    public BranchData() { }
+
+    private BranchData(in BranchArray branches) => _branches = branches;
+
+    public ref readonly BranchArray Branches => ref _branches;
+    public ref object this[int index] => ref _branches[index];
+
+    INodeData INodeData.Clone() => new BranchData(in _branches);
+
+    [InlineArray(Length)]
+    public struct BranchArray
+    {
+        public const int Length = TrieNode.BranchesCount;
+        private object? _element0;
+    }
+}
+
+public class ExtensionData : INodeWithKey
+{
+    public NodeType NodeType => NodeType.Extension;
+    public int MemorySize => MemorySizes.RefSize + MemorySizes.RefSize +
+        (_key is not null ? (int)MemorySizes.Align(_key.Length + MemorySizes.ArrayOverhead) : 0);
+    public int Length => 2;
+
+    public byte[]? _key;
+    public object? _value;
+    public byte[] Key { get => _key; set => _key = value; }
+    public object? Value { get => _value; set => _value = value; }
+    public ref object this[int index]
+    {
+        get
+        {
+            if ((uint)index >= (uint)Length)
+            {
+                ThrowArgumentOutOfRangeException(index);
+            }
+
+            return ref _value;
+
+            [DoesNotReturn]
+            [StackTraceHidden]
+            static void ThrowArgumentOutOfRangeException(int index)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), index, $"{index} is not 0 or 1");
+            }
+        }
+    }
+
+    public ExtensionData() { }
+
+    internal ExtensionData(byte[] key)
+    {
+        Key = key;
+    }
+
+    internal ExtensionData(byte[] key, TrieNode value)
+    {
+        Key = key;
+        Value = value;
+    }
+
+    private ExtensionData(byte[] key, object? value)
+    {
+        Key = key;
+        Value = value;
+    }
+
+    INodeData INodeData.Clone() => new ExtensionData(Key, Value);
+}
+
+public class LeafData : INodeWithKey
+{
+    public NodeType NodeType => NodeType.Leaf;
+    public int Length => 0;
+    public int MemorySize => MemorySizes.RefSize + MemorySizes.RefSize + MemorySizes.RefSize +
+         (Key is not null ? (int)MemorySizes.Align(Key.Length + MemorySizes.ArrayOverhead) : 0) +
+         (_value.IsNotNull ? (int)MemorySizes.Align(_value.Length + MemorySizes.ArrayOverhead) : 0);
+
+    private readonly CappedArray<byte> _value;
+
+    public byte[] Key { get; set; }
+    public ref readonly CappedArray<byte> Value => ref _value;
+    public TrieNode? StorageRoot { get; set; }
+
+    public LeafData() { }
+
+    internal LeafData(byte[] key, in CappedArray<byte> value)
+    {
+        Key = key;
+        _value = value;
+    }
+
+    private LeafData(byte[] key, in CappedArray<byte> value, TrieNode? storageRoot)
+    {
+        Key = key;
+        _value = value;
+        StorageRoot = storageRoot;
+    }
+    public ref object this[int index] => throw new IndexOutOfRangeException();
+
+    INodeData INodeData.Clone() => new LeafData(Key, in _value);
+    public LeafData CloneWithNewValue(in CappedArray<byte> value) => new LeafData(Key, in value, StorageRoot);
+}
diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.Decoder.cs b/src/Nethermind/Nethermind.Trie/TrieNode.Decoder.cs
diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.Visitor.cs b/src/Nethermind/Nethermind.Trie/TrieNode.Visitor.cs
diff --git a/src/Nethermind/Nethermind.Trie/TrieNode.cs b/src/Nethermind/Nethermind.Trie/TrieNode.cs
diff --git a/src/Nethermind/Nethermind.Trie/TrieNodeFactory.cs b/src/Nethermind/Nethermind.Trie/TrieNodeFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,9 @@ namespace Nethermind.Serialization.Rlp`
`8`	`8`	`{`
`9`	`9`	`public class RlpFactory`
`10`	`10`	`{`
`11`		`- public long MemorySize => MemorySizes.SmallObjectOverhead`
	`11`	`+ public long MemorySize => MemorySizes.ObjectHeaderMethodTable`
`12`	`12`	`+ MemorySizes.Align(MemorySizes.ArrayOverhead + _data.Length)`
`13`		`- + MemorySizes.Align(sizeof(int));`
	`13`	`+ + MemorySizes.Align(MemorySizes.RefSize + sizeof(int));`
`14`	`14`
`15`	`15`	`private readonly CappedArray<byte> _data;`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -1479,6 +1479,6 @@ public byte[][] DecodeByteArrays()`
`1479`	`1479`	`}`
`1480`	`1480`
`1481`	`1481`	internal static ReadOnlySpan<byte> SingleBytes => new byte[128] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127 };
`1482`		- internal static byte[][] SingleByteArrays = new byte[128][] { [0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28], [29], [30], [31], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44], [45], [46], [47], [48], [49], [50], [51], [52], [53], [54], [55], [56], [57], [58], [59], [60], [61], [62], [63], [64], [65], [66], [67], [68], [69], [70], [71], [72], [73], [74], [75], [76], [77], [78], [79], [80], [81], [82], [83], [84], [85], [86], [87], [88], [89], [90], [91], [92], [93], [94], [95], [96], [97], [98], [99], [100], [101], [102], [103], [104], [105], [106], [107], [108], [109], [110], [111], [112], [113], [114], [115], [116], [117], [118], [119], [120], [121], [122], [123], [124], [125], [126], [127] };
	`1482`	+ internal static readonly byte[][] SingleByteArrays = new byte[128][] { [0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28], [29], [30], [31], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44], [45], [46], [47], [48], [49], [50], [51], [52], [53], [54], [55], [56], [57], [58], [59], [60], [61], [62], [63], [64], [65], [66], [67], [68], [69], [70], [71], [72], [73], [74], [75], [76], [77], [78], [79], [80], [81], [82], [83], [84], [85], [86], [87], [88], [89], [90], [91], [92], [93], [94], [95], [96], [97], [98], [99], [100], [101], [102], [103], [104], [105], [106], [107], [108], [109], [110], [111], [112], [113], [114], [115], [116], [117], [118], [119], [120], [121], [122], [123], [124], [125], [126], [127] };
`1483`	`1483`	`}`
`1484`	`1484`	`}`
Original file line number	Diff line number	Diff line change
`@@ -311,23 +311,26 @@ private static void StitchBoundaries(List<(TrieNode, TreePath)> sortedBoundaryLi`
`311`	`311`
`312`	`312`	`if (!node.IsPersisted)`
`313`	`313`	`{`
`314`		`- if (node.IsExtension)`
	`314`	`+ INodeData nodeData = node.NodeData;`
	`315`	`+ if (nodeData is ExtensionData extensionData)`
`315`	`316`	`{`
`316`		`- if (IsChildPersisted(node, ref path, ExtensionRlpChildIndex, store))`
	`317`	`+ if (IsChildPersisted(node, ref path, extensionData._value, ExtensionRlpChildIndex, store))`
`317`	`318`	`{`
`318`	`319`	`node.IsBoundaryProofNode = false;`
`319`	`320`	`}`
`320`	`321`	`}`
`321`		`- else if (node.IsBranch)`
	`322`	`+ else if (nodeData is BranchData branchData)`
`322`	`323`	`{`
`323`	`324`	`bool isBoundaryProofNode = false;`
`324`		`- for (int ci = 0; ci <= 15; ci++)`
	`325`	`+ int ci = 0;`
	`326`	`+ foreach (object? o in branchData.Branches)`
`325`	`327`	`{`
`326`		`- if (!IsChildPersisted(node, ref path, ci, store))`
	`328`	`+ if (!IsChildPersisted(node, ref path, o, ci, store))`
`327`	`329`	`{`
`328`	`330`	`isBoundaryProofNode = true;`
`329`	`331`	`break;`
`330`	`332`	`}`
	`333`	`+ ci++;`
`331`	`334`	`}`
`332`	`335`
`333`	`336`	`node.IsBoundaryProofNode = isBoundaryProofNode;`
`@@ -336,15 +339,19 @@ private static void StitchBoundaries(List<(TrieNode, TreePath)> sortedBoundaryLi`
`336`	`339`	`}`
`337`	`340`	`}`
`338`	`341`
`339`		`- private static bool IsChildPersisted(TrieNode node, ref TreePath nodePath, int childIndex, IScopedTrieStore store)`
	`342`	`+ private static bool IsChildPersisted(TrieNode node, ref TreePath nodePath, object? child, int childIndex, IScopedTrieStore store)`
`340`	`343`	`{`
`341`		`- TrieNode data = node.GetData(childIndex) as TrieNode;`
`342`		`- if (data is not null)`
	`344`	`+ if (child is TrieNode childNode)`
`343`	`345`	`{`
`344`		`- return data.IsBoundaryProofNode == false;`
	`346`	`+ return childNode.IsBoundaryProofNode == false;`
`345`	`347`	`}`
`346`	`348`
`347`		`- if (!node.GetChildHashAsValueKeccak(childIndex, out ValueHash256 childKeccak))`
	`349`	`+ ValueHash256 childKeccak;`
	`350`	`+ if (child is Hash256 hash)`
	`351`	`+ {`
	`352`	`+ childKeccak = hash.ValueHash256;`
	`353`	`+ }`
	`354`	`+ else if (!node.GetChildHashAsValueKeccak(childIndex, out childKeccak))`
`348`	`355`	`{`
`349`	`356`	`return true;`
`350`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -548,29 +548,28 @@ public void Can_encode_branch_with_unresolved_children()`
`548`	`548`	`public void Size_of_a_heavy_leaf_is_correct()`
`549`	`549`	`{`
`550`	`550`	`Context ctx = new();`
`551`		`- Assert.That(ctx.HeavyLeaf.GetMemorySize(false), Is.EqualTo(248));`
	`551`	`+ Assert.That(ctx.HeavyLeaf.GetMemorySize(false), Is.EqualTo(208));`
`552`	`552`	`}`
`553`	`553`
`554`	`554`	`[Test]`
`555`	`555`	`public void Size_of_a_tiny_leaf_is_correct()`
`556`	`556`	`{`
`557`	`557`	`Context ctx = new();`
`558`		`- Assert.That(ctx.TiniestLeaf.GetMemorySize(false), Is.EqualTo(168));`
	`558`	`+ Assert.That(ctx.TiniestLeaf.GetMemorySize(false), Is.EqualTo(136));`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`[Test]`
`562`	`562`	`public void Size_of_a_branch_is_correct()`
`563`	`563`	`{`
`564`	`564`	`Context ctx = new();`
`565`	`565`	`TrieNode node = new(NodeType.Branch);`
`566`		`- node.Key = new byte[] { 1 };`
`567`	`566`	`for (int i = 0; i < 16; i++)`
`568`	`567`	`{`
`569`	`568`	`node.SetChild(i, ctx.AccountLeaf);`
`570`	`569`	`}`
`571`	`570`
`572`		`- Assert.That(node.GetMemorySize(true), Is.EqualTo(4048));`
`573`		`- Assert.That(node.GetMemorySize(false), Is.EqualTo(208));`
	`571`	`+ Assert.That(node.GetMemorySize(true), Is.EqualTo(3376));`
	`572`	`+ Assert.That(node.GetMemorySize(false), Is.EqualTo(176));`
`574`	`573`	`}`
`575`	`574`
`576`	`575`	`[Test]`
`@@ -581,7 +580,7 @@ public void Size_of_an_extension_is_correct()`
`581`	`580`	`trieNode.Key = new byte[] { 1 };`
`582`	`581`	`trieNode.SetChild(0, ctx.TiniestLeaf);`
`583`	`582`
`584`		`- Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(120));`
	`583`	`+ Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(96));`
`585`	`584`	`}`
`586`	`585`
`587`	`586`	`[Test]`
`@@ -592,53 +591,53 @@ public void Size_of_unknown_node_is_correct()`
`592`	`591`	`trieNode.Key = new byte[] { 1 };`
`593`	`592`	`trieNode.SetChild(0, ctx.TiniestLeaf);`
`594`	`593`
`595`		`- Assert.That(trieNode.GetMemorySize(true), Is.EqualTo(288));`
`596`		`- Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(120));`
	`594`	`+ Assert.That(trieNode.GetMemorySize(true), Is.EqualTo(232));`
	`595`	`+ Assert.That(trieNode.GetMemorySize(false), Is.EqualTo(96));`
`597`	`596`	`}`
`598`	`597`
`599`	`598`	`[Test]`
`600`	`599`	`public void Size_of_an_unknown_empty_node_is_correct()`
`601`	`600`	`{`
`602`	`601`	`TrieNode trieNode = new(NodeType.Unknown);`
`603`		`- trieNode.GetMemorySize(false).Should().Be(56);`
	`602`	`+ trieNode.GetMemorySize(false).Should().Be(48);`
`604`	`603`	`}`
`605`	`604`
`606`	`605`	`[Test]`
`607`	`606`	`public void Size_of_an_unknown_node_with_keccak_is_correct()`
`608`	`607`	`{`
`609`	`608`	`TrieNode trieNode = new(NodeType.Unknown, Keccak.Zero);`
`610`		`- trieNode.GetMemorySize(false).Should().Be(104);`
	`609`	`+ trieNode.GetMemorySize(false).Should().Be(96);`
`611`	`610`	`}`
`612`	`611`
`613`	`612`	`[Test]`
`614`	`613`	`public void Size_of_extension_with_child()`
`615`	`614`	`{`
`616`	`615`	`TrieNode trieNode = new(NodeType.Extension);`
`617`	`616`	`trieNode.SetChild(0, null);`
`618`		`- trieNode.GetMemorySize(false).Should().Be(96);`
	`617`	`+ trieNode.GetMemorySize(false).Should().Be(64);`
`619`	`618`	`}`
`620`	`619`
`621`	`620`	`[Test]`
`622`	`621`	`public void Size_of_branch_with_data()`
`623`	`622`	`{`
`624`	`623`	`TrieNode trieNode = new(NodeType.Branch);`
`625`	`624`	`trieNode.SetChild(0, null);`
`626`		`- trieNode.GetMemorySize(false).Should().Be(208);`
	`625`	`+ trieNode.GetMemorySize(false).Should().Be(176);`
`627`	`626`	`}`
`628`	`627`
`629`	`628`	`[Test]`
`630`	`629`	`public void Size_of_leaf_with_value()`
`631`	`630`	`{`
`632`	`631`	`TrieNode trieNode = new(NodeType.Leaf);`
`633`	`632`	`trieNode.Value = new byte[7];`
`634`		`- trieNode.GetMemorySize(false).Should().Be(152);`
	`633`	`+ trieNode.GetMemorySize(false).Should().Be(104);`
`635`	`634`	`}`
`636`	`635`
`637`	`636`	`[Test]`
`638`	`637`	`public void Size_of_an_unknown_node_with_full_rlp_is_correct()`
`639`	`638`	`{`
`640`	`639`	`TrieNode trieNode = new(NodeType.Unknown, new byte[7]);`
`641`		`- trieNode.GetMemorySize(false).Should().Be(120);`
	`640`	`+ trieNode.GetMemorySize(false).Should().Be(112);`
`642`	`641`	`}`
`643`	`642`
`644`	`643`	`[Test]`
`@@ -738,7 +737,7 @@ public void Extension_child_as_keccak_memory_size()`
`738`	`737`	`trieNode.SetChild(0, child);`
`739`	`738`
`740`	`739`	`trieNode.PrunePersistedRecursively(1);`
`741`		`- trieNode.GetMemorySize(false).Should().Be(144);`
	`740`	`+ trieNode.GetMemorySize(false).Should().Be(112);`
`742`	`741`	`}`
`743`	`742`
`744`	`743`	`[Test]`
`@@ -751,7 +750,7 @@ public void Extension_child_as_keccak_clone()`
`751`	`750`	`trieNode.PrunePersistedRecursively(1);`
`752`	`751`	`TrieNode cloned = trieNode.Clone();`
`753`	`752`
`754`		`- cloned.GetMemorySize(false).Should().Be(144);`
	`753`	`+ cloned.GetMemorySize(false).Should().Be(112);`
`755`	`754`	`}`
`756`	`755`
`757`	`756`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public static void CopyToSpan(byte[] path, bool isLeaf, Span<byte> output)`
`16`	`16`	`{`
`17`	`17`	`if (output.Length != ByteLength(path)) throw new ArgumentOutOfRangeException(nameof(output));`
`18`	`18`
`19`		`- output[0] = (byte)(isLeaf ? 0x20 : 0x000);`
	`19`	`+ output[0] = (byte)(isLeaf ? 0x20 : 0x00);`
`20`	`20`	`if (path.Length % 2 != 0)`
`21`	`21`	`{`
`22`	`22`	`output[0] += (byte)(0x10 + path[0]);`