diff --git a/lib/trie/trie.go b/lib/trie/trie.go
index a5b8d4cf22..8dfc1e66ca 100644
--- a/lib/trie/trie.go
+++ b/lib/trie/trie.go
@@ -678,7 +678,7 @@ func (t *Trie) ClearPrefixLimit(prefixLE []byte, limit uint32) (deleted uint32,
 	prefix := codec.KeyLEToNibbles(prefixLE)
 	prefix = bytes.TrimSuffix(prefix, []byte{0})
 
-	t.root, deleted, _, allDeleted = t.clearPrefixLimit(t.root, prefix, limit)
+	t.root, deleted, allDeleted = t.clearPrefixLimit(t.root, prefix, limit)
 	return deleted, allDeleted
 }
 
@@ -686,9 +686,9 @@ func (t *Trie) ClearPrefixLimit(prefixLE []byte, limit uint32) (deleted uint32,
 // It returns the updated node newParent, the number of deleted values valuesDeleted and the
 // allDeleted boolean indicating if there is no key left with the prefix.
 func (t *Trie) clearPrefixLimit(parent Node, prefix []byte, limit uint32) (
-	newParent Node, valuesDeleted, nodesRemoved uint32, allDeleted bool) {
+	newParent Node, valuesDeleted uint32, allDeleted bool) {
 	if parent == nil {
-		return nil, 0, 0, true
+		return nil, 0, true
 	}
 
 	if parent.Type() == node.LeafType {
@@ -697,10 +697,10 @@ func (t *Trie) clearPrefixLimit(parent Node, prefix []byte, limit uint32) (
 		// TODO check this is the same behaviour as in substrate
 		const allDeleted = true
 		if bytes.HasPrefix(leaf.Key, prefix) {
-			valuesDeleted, nodesRemoved = 1, 1
-			return nil, valuesDeleted, nodesRemoved, allDeleted
+			valuesDeleted = 1
+			return nil, valuesDeleted, allDeleted
 		}
-		return parent, 0, 0, allDeleted
+		return parent, 0, allDeleted
 	}
 
 	branch := parent.(*node.Branch)
@@ -708,14 +708,14 @@ func (t *Trie) clearPrefixLimit(parent Node, prefix []byte, limit uint32) (
 }
 
 func (t *Trie) clearPrefixLimitBranch(branch *node.Branch, prefix []byte, limit uint32) (
-	newParent Node, valuesDeleted uint32, nodesRemoved uint32, allDeleted bool) {
+	newParent Node, valuesDeleted uint32, allDeleted bool) {
 	newParent = branch
 
 	if bytes.HasPrefix(branch.Key, prefix) {
 		nilPrefix := ([]byte)(nil)
-		newParent, valuesDeleted, nodesRemoved = t.deleteNodesLimit(branch, nilPrefix, limit)
+		newParent, valuesDeleted = t.deleteNodesLimit(branch, nilPrefix, limit)
 		allDeleted = newParent == nil
-		return newParent, valuesDeleted, nodesRemoved, allDeleted
+		return newParent, valuesDeleted, allDeleted
 	}
 
 	if len(prefix) == len(branch.Key)+1 &&
@@ -727,79 +727,71 @@ func (t *Trie) clearPrefixLimitBranch(branch *node.Branch, prefix []byte, limit
 	noPrefixForNode := len(prefix) <= len(branch.Key) ||
 		lenCommonPrefix(branch.Key, prefix) < len(branch.Key)
 	if noPrefixForNode {
-		valuesDeleted, nodesRemoved = 0, 0
+		valuesDeleted = 0
 		allDeleted = true
-		return newParent, valuesDeleted, nodesRemoved, allDeleted
+		return newParent, valuesDeleted, allDeleted
 	}
 
 	childIndex := prefix[len(branch.Key)]
 	childPrefix := prefix[len(branch.Key)+1:]
 	child := branch.Children[childIndex]
 
-	child, valuesDeleted, nodesRemoved, allDeleted = t.clearPrefixLimit(child, childPrefix, limit)
+	child, valuesDeleted, allDeleted = t.clearPrefixLimit(child, childPrefix, limit)
 	if valuesDeleted == 0 {
-		return branch, valuesDeleted, nodesRemoved, allDeleted
+		return branch, valuesDeleted, allDeleted
 	}
 
 	branch = t.prepBranchForMutation(branch)
 	branch.Children[childIndex] = child
-	newParent, branchChildMerged := handleDeletion(branch, prefix)
-	if branchChildMerged {
-		nodesRemoved++
-	}
-
-	return newParent, valuesDeleted, nodesRemoved, allDeleted
+	newParent = handleDeletion(branch, prefix)
+	return newParent, valuesDeleted, allDeleted
 }
 
 func (t *Trie) clearPrefixLimitChild(branch *node.Branch, prefix []byte, limit uint32) (
-	newParent Node, valuesDeleted, nodesRemoved uint32, allDeleted bool) {
+	newParent Node, valuesDeleted uint32, allDeleted bool) {
 	newParent = branch
 
-	childIndex := prefix[len(branch.Key)]
+	childIndex := int(prefix[len(branch.Key)])
 	child := branch.Children[childIndex]
 
 	if child == nil {
-		const valuesDeleted, nodesRemoved = 0, 0
+		const valuesDeleted = 0
 		// TODO ensure this is the same behaviour as in substrate
 		allDeleted = true
-		return newParent, valuesDeleted, nodesRemoved, allDeleted
+		return newParent, valuesDeleted, allDeleted
 	}
 
 	nilPrefix := ([]byte)(nil)
-	child, valuesDeleted, nodesRemoved = t.deleteNodesLimit(child, nilPrefix, limit)
+	child, valuesDeleted = t.deleteNodesLimit(child, nilPrefix, limit)
 	if valuesDeleted == 0 {
 		allDeleted = branch.Children[childIndex] == nil
-		return branch, valuesDeleted, nodesRemoved, allDeleted
+		return branch, valuesDeleted, allDeleted
 	}
 
 	branch = t.prepBranchForMutation(branch)
-	branch.Children[childIndex] = child
-	branch.SubDescendants(nodesRemoved)
+	branch.AssignChild(childIndex, child)
 
-	newParent, branchChildMerged := handleDeletion(branch, prefix)
-	if branchChildMerged {
-		nodesRemoved++
-	}
+	newParent = handleDeletion(branch, prefix)
 
 	allDeleted = branch.Children[childIndex] == nil
-	return newParent, valuesDeleted, nodesRemoved, allDeleted
+	return newParent, valuesDeleted, allDeleted
 }
 
 func (t *Trie) deleteNodesLimit(parent Node, prefix []byte, limit uint32) (
-	newParent Node, valuesDeleted, nodesRemoved uint32) {
+	newParent Node, valuesDeleted uint32) {
 	if limit == 0 {
-		valuesDeleted, nodesRemoved = 0, 0
-		return parent, valuesDeleted, nodesRemoved
+		valuesDeleted = 0
+		return parent, valuesDeleted
 	}
 
 	if parent == nil {
-		valuesDeleted, nodesRemoved = 0, 0
-		return nil, valuesDeleted, nodesRemoved
+		valuesDeleted = 0
+		return nil, valuesDeleted
 	}
 
 	if parent.Type() == node.LeafType {
-		valuesDeleted, nodesRemoved = 1, 1
-		return nil, valuesDeleted, nodesRemoved
+		valuesDeleted = 1
+		return nil, valuesDeleted
 	}
 
 	branch := parent.(*node.Branch)
@@ -808,46 +800,38 @@ func (t *Trie) deleteNodesLimit(parent Node, prefix []byte, limit uint32) (
 
 	nilChildren := node.ChildrenCapacity - branch.NumChildren()
 
-	var newDeleted, newNodesRemoved uint32
-	var branchChildMerged bool
+	var newDeleted uint32
 	for i, child := range branch.Children {
 		if child == nil {
 			continue
 		}
 
 		branch = t.prepBranchForMutation(branch)
-		branch.Children[i], newDeleted, newNodesRemoved = t.deleteNodesLimit(child, fullKey, limit)
-		if branch.Children[i] == nil {
+		child, newDeleted = t.deleteNodesLimit(child, fullKey, limit)
+		if child == nil {
 			nilChildren++
 		}
 		limit -= newDeleted
 		valuesDeleted += newDeleted
-		nodesRemoved += newNodesRemoved
-		branch.SubDescendants(newNodesRemoved)
+		branch.AssignChild(i, child)
 
-		branch.SetDirty(true)
-
-		newParent, branchChildMerged = handleDeletion(branch, fullKey)
-		if branchChildMerged {
-			nodesRemoved++
-		}
+		newParent = handleDeletion(branch, fullKey)
 
 		if nilChildren == node.ChildrenCapacity &&
 			branch.Value == nil {
-			return nil, valuesDeleted, nodesRemoved
+			return nil, valuesDeleted
 		}
 
 		if limit == 0 {
-			return newParent, valuesDeleted, nodesRemoved
+			return newParent, valuesDeleted
 		}
 	}
 
-	nodesRemoved++
 	if branch.Value != nil {
 		valuesDeleted++
 	}
 
-	return nil, valuesDeleted, nodesRemoved
+	return nil, valuesDeleted
 }
 
 // ClearPrefix deletes all nodes in the trie for which the key contains the
@@ -865,23 +849,17 @@ func (t *Trie) ClearPrefix(prefixLE []byte) {
 }
 
 func (t *Trie) clearPrefix(parent Node, prefix []byte) (
-	newParent Node, nodesRemoved uint32) {
+	newParent Node, oneDeleted bool) {
 	if parent == nil {
-		const nodesRemoved = 0
-		return nil, nodesRemoved
+		return nil, false
 	}
 
 	if bytes.HasPrefix(parent.GetKey(), prefix) {
-		nodesRemoved = 1
-		if parent.Type() != node.LeafType { // branch
-			nodesRemoved += parent.(*node.Branch).GetDescendants()
-		}
-		return nil, nodesRemoved
+		return nil, true
 	}
 
 	if parent.Type() == node.LeafType {
-		const nodesRemoved = 0
-		return parent, nodesRemoved
+		return parent, false
 	}
 
 	branch := parent.(*node.Branch)
@@ -893,46 +871,34 @@ func (t *Trie) clearPrefix(parent Node, prefix []byte) (
 		child := branch.Children[childIndex]
 
 		if child == nil {
-			const nodesRemoved = 0
-			return parent, nodesRemoved
+			return parent, false
 		}
 
-		nodesRemoved = 1
 		branch = t.prepBranchForMutation(branch)
 		branch.Children[childIndex] = nil
-		var branchChildMerged bool
-		newParent, branchChildMerged = handleDeletion(branch, prefix)
-		if branchChildMerged {
-			nodesRemoved++
-		}
-		return newParent, nodesRemoved
+		newParent = handleDeletion(branch, prefix)
+		return newParent, true
 	}
 
 	noPrefixForNode := len(prefix) <= len(branch.Key) ||
 		lenCommonPrefix(branch.Key, prefix) < len(branch.Key)
 	if noPrefixForNode {
-		const nodesRemoved = 0
-		return parent, nodesRemoved
+		return parent, false
 	}
 
-	childIndex := prefix[len(branch.Key)]
+	childIndex := int(prefix[len(branch.Key)])
 	childPrefix := prefix[len(branch.Key)+1:]
 	child := branch.Children[childIndex]
 
-	child, nodesRemoved = t.clearPrefix(child, childPrefix)
-	if nodesRemoved == 0 {
-		return parent, nodesRemoved
+	child, oneDeleted = t.clearPrefix(child, childPrefix)
+	if !oneDeleted {
+		return parent, false
 	}
 
 	branch = t.prepBranchForMutation(branch)
-	branch.SubDescendants(nodesRemoved)
-	branch.Children[childIndex] = child
-	newParent, branchChildMerged := handleDeletion(branch, prefix)
-	if branchChildMerged {
-		nodesRemoved++
-	}
-
-	return newParent, nodesRemoved
+	branch.AssignChild(childIndex, child)
+	newParent = handleDeletion(branch, prefix)
+	return newParent, true
 }
 
 // Delete removes the node of the trie with the key
@@ -940,23 +906,20 @@ func (t *Trie) clearPrefix(parent Node, prefix []byte) (
 // If no node is found at this key, nothing is deleted.
 func (t *Trie) Delete(keyLE []byte) {
 	key := codec.KeyLEToNibbles(keyLE)
-	t.root, _, _ = t.delete(t.root, key)
+	t.root, _ = t.delete(t.root, key)
 }
 
 func (t *Trie) delete(parent Node, key []byte) (
-	newParent Node, deleted bool, nodesRemoved uint32) {
+	newParent Node, deleted bool) {
 	if parent == nil {
-		const nodesRemoved = 0
-		return nil, false, nodesRemoved
+		return nil, false
 	}
 
 	if parent.Type() == node.LeafType {
 		if deleteLeaf(parent, key) == nil {
-			const nodesRemoved = 1
-			return nil, true, nodesRemoved
+			return nil, true
 		}
-		const nodesRemoved = 0
-		return parent, false, nodesRemoved
+		return parent, false
 	}
 
 	branch := parent.(*node.Branch)
@@ -971,49 +934,38 @@ func deleteLeaf(parent Node, key []byte) (newParent Node) {
 }
 
 func (t *Trie) deleteBranch(branch *node.Branch, key []byte) (
-	newParent Node, deleted bool, nodesRemoved uint32) {
+	newParent Node, deleted bool) {
 	if len(key) == 0 || bytes.Equal(branch.Key, key) {
 		branch = t.prepBranchForMutation(branch)
 		branch.Value = nil
 		deleted = true
-		var branchChildMerged bool
-		newParent, branchChildMerged = handleDeletion(branch, key)
-		if branchChildMerged {
-			nodesRemoved = 1
-		}
-		return newParent, deleted, nodesRemoved
+		newParent = handleDeletion(branch, key)
+		return newParent, deleted
 	}
 
 	commonPrefixLength := lenCommonPrefix(branch.Key, key)
-	childIndex := key[commonPrefixLength]
+	childIndex := int(key[commonPrefixLength])
 	childKey := key[commonPrefixLength+1:]
 	child := branch.Children[childIndex]
 
-	newChild, deleted, nodesRemoved := t.delete(child, childKey)
+	newChild, deleted := t.delete(child, childKey)
 	if !deleted {
-		const nodesRemoved = 0
-		return branch, false, nodesRemoved
+		return branch, false
 	}
 
 	branch = t.prepBranchForMutation(branch)
-	branch.SubDescendants(nodesRemoved)
+	branch.AssignChild(childIndex, newChild)
 	branch.Children[childIndex] = newChild
 
-	newParent, branchChildMerged := handleDeletion(branch, key)
-	if branchChildMerged {
-		nodesRemoved++
-	}
-
-	return newParent, true, nodesRemoved
+	newParent = handleDeletion(branch, key)
+	return newParent, true
 }
 
 // handleDeletion is called when a value is deleted from a branch to handle
 // the eventual mutation of the branch depending on its children.
 // If the branch has no value and a single child, it will be combined with this child.
-// In this first case, branchChildMerged is returned as true to keep track of the removal
-// of one node in callers.
 // If the branch has a value and no child, it will be changed into a leaf.
-func handleDeletion(branch *node.Branch, key []byte) (newNode Node, branchChildMerged bool) {
+func handleDeletion(branch *node.Branch, key []byte) (newNode Node) {
 	childrenCount := 0
 	firstChildIndex := -1
 	for i, child := range branch.Children {
@@ -1028,19 +980,16 @@ func handleDeletion(branch *node.Branch, key []byte) (newNode Node, branchChildM
 
 	switch {
 	default:
-		const branchChildMerged = false
-		return branch, branchChildMerged
+		return branch
 	case childrenCount == 0 && branch.Value != nil:
-		const branchChildMerged = false
 		commonPrefixLength := lenCommonPrefix(branch.Key, key)
 		return &node.Leaf{
 			Key:        key[:commonPrefixLength],
 			Value:      branch.Value,
 			Dirty:      true,
 			Generation: branch.Generation,
-		}, branchChildMerged
+		}
 	case childrenCount == 1 && branch.Value == nil:
-		const branchChildMerged = true
 		childIndex := firstChildIndex
 		child := branch.Children[firstChildIndex]
 
@@ -1052,7 +1001,7 @@ func handleDeletion(branch *node.Branch, key []byte) (newNode Node, branchChildM
 				Value:      child.GetValue(),
 				Dirty:      true,
 				Generation: branch.Generation,
-			}, branchChildMerged
+			}
 		}
 
 		childBranch := child.(*node.Branch)
@@ -1075,7 +1024,7 @@ func handleDeletion(branch *node.Branch, key []byte) (newNode Node, branchChildM
 			}
 		}
 
-		return newBranch, branchChildMerged
+		return newBranch
 	}
 }
 
diff --git a/lib/trie/trie_test.go b/lib/trie/trie_test.go
index ffa59f7bce..66c45e359d 100644
--- a/lib/trie/trie_test.go
+++ b/lib/trie/trie_test.go
@@ -2180,7 +2180,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 		limit         uint32
 		newParent     Node
 		valuesDeleted uint32
-		nodesRemoved  uint32
 		allDeleted    bool
 	}{
 		"limit is zero": {
@@ -2197,7 +2196,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1},
 			limit:         1,
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 			allDeleted:    true,
 		},
 		"leaf parent with key equal prefix": {
@@ -2207,7 +2205,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1},
 			limit:         1,
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 			allDeleted:    true,
 		},
 		"leaf parent with key no common prefix": {
@@ -2250,7 +2247,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1},
 			limit:         3,
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 			allDeleted:    true,
 		},
 		"branch without value with key equal prefix": {
@@ -2265,7 +2261,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1, 2},
 			limit:         3,
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 			allDeleted:    true,
 		},
 		"branch without value with no common prefix": {
@@ -2352,7 +2347,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1},
 			limit:         2,
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 			allDeleted:    true,
 		},
 		"branch with value with key equal prefix": {
@@ -2367,7 +2361,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1, 2},
 			limit:         2,
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 			allDeleted:    true,
 		},
 		"branch with value with no common prefix": {
@@ -2469,7 +2462,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				},
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 		},
 		"delete only child of branch": {
 			parent: &node.Branch{
@@ -2488,7 +2480,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				Dirty: true,
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 			allDeleted:    true,
 		},
 		"fully delete children of branch with value": {
@@ -2513,7 +2504,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				Generation: 1,
 			},
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 		},
 		"fully delete children of branch without value": {
 			parent: &node.Branch{
@@ -2527,7 +2517,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			prefix:        []byte{1},
 			limit:         2,
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 			allDeleted:    true,
 		},
 		"partially delete child of branch": {
@@ -2576,7 +2565,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				},
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 		},
 		"update child of branch": {
 			trie: Trie{
@@ -2606,7 +2594,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				Generation: 1,
 			},
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 			allDeleted:    true,
 		},
 		"delete one of two children of branch without value": {
@@ -2629,7 +2616,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				Generation: 1,
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  2,
 			allDeleted:    true,
 		},
 		"delete one of two children of branch": {
@@ -2652,7 +2638,6 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 				Generation: 1,
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  2,
 			allDeleted:    true,
 		},
 		"delete child of branch with limit reached": {
@@ -2685,12 +2670,11 @@ func Test_Trie_clearPrefixLimit(t *testing.T) {
 			trie := testCase.trie
 			expectedTrie := *trie.DeepCopy()
 
-			newParent, valuesDeleted, nodesRemoved, allDeleted :=
+			newParent, valuesDeleted, allDeleted :=
 				trie.clearPrefixLimit(testCase.parent, testCase.prefix, testCase.limit)
 
 			assert.Equal(t, testCase.newParent, newParent)
 			assert.Equal(t, testCase.valuesDeleted, valuesDeleted)
-			assert.Equal(t, testCase.nodesRemoved, nodesRemoved)
 			assert.Equal(t, testCase.allDeleted, allDeleted)
 			assert.Equal(t, expectedTrie, trie)
 		})
@@ -2727,7 +2711,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 			parent:        &node.Leaf{},
 			limit:         2,
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 		},
 		"delete branch without value": {
 			parent: &node.Branch{
@@ -2739,7 +2722,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 			},
 			limit:         3,
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 		},
 		"delete branch with value": {
 			parent: &node.Branch{
@@ -2752,7 +2734,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 			},
 			limit:         3,
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 		},
 		"delete branch and all children": {
 			parent: &node.Branch{
@@ -2765,7 +2746,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 			},
 			limit:         10,
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 		},
 		"delete branch one child only": {
 			trie: Trie{
@@ -2793,7 +2773,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 				},
 			},
 			valuesDeleted: 1,
-			nodesRemoved:  1,
 		},
 		"delete branch children only": {
 			trie: Trie{
@@ -2816,7 +2795,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 				Generation: 1,
 			},
 			valuesDeleted: 2,
-			nodesRemoved:  2,
 		},
 		"delete branch all children except one": {
 			trie: Trie{
@@ -2842,7 +2820,6 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 				Dirty:      true,
 			},
 			valuesDeleted: 2,
-			nodesRemoved:  3,
 		},
 	}
 
@@ -2854,12 +2831,11 @@ func Test_Trie_deleteNodesLimit(t *testing.T) {
 			trie := testCase.trie
 			expectedTrie := *trie.DeepCopy()
 
-			newNode, valuesDeleted, nodesRemoved :=
-				trie.deleteNodesLimit(testCase.parent, testCase.prefix, testCase.limit)
+			newNode, valuesDeleted := trie.deleteNodesLimit(
+				testCase.parent, testCase.prefix, testCase.limit)
 
 			assert.Equal(t, testCase.newNode, newNode)
 			assert.Equal(t, testCase.valuesDeleted, valuesDeleted)
-			assert.Equal(t, testCase.nodesRemoved, nodesRemoved)
 			assert.Equal(t, expectedTrie, trie)
 		})
 	}
@@ -2942,11 +2918,11 @@ func Test_Trie_clearPrefix(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		trie         Trie
-		parent       Node
-		prefix       []byte
-		newParent    Node
-		nodesRemoved uint32
+		trie       Trie
+		parent     Node
+		prefix     []byte
+		newParent  Node
+		oneDeleted bool
 	}{
 		"delete one of two children of branch": {
 			trie: Trie{
@@ -2966,22 +2942,22 @@ func Test_Trie_clearPrefix(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			nodesRemoved: 2,
+			oneDeleted: true,
 		},
 		"nil parent": {},
 		"leaf parent with common prefix": {
 			parent: &node.Leaf{
 				Key: []byte{1, 2},
 			},
-			prefix:       []byte{1},
-			nodesRemoved: 1,
+			prefix:     []byte{1},
+			oneDeleted: true,
 		},
 		"leaf parent with key equal prefix": {
 			parent: &node.Leaf{
 				Key: []byte{1},
 			},
-			prefix:       []byte{1},
-			nodesRemoved: 1,
+			prefix:     []byte{1},
+			oneDeleted: true,
 		},
 		"leaf parent with key no common prefix": {
 			trie: Trie{
@@ -3016,8 +2992,8 @@ func Test_Trie_clearPrefix(t *testing.T) {
 					&node.Leaf{},
 				},
 			},
-			prefix:       []byte{1},
-			nodesRemoved: 2,
+			prefix:     []byte{1},
+			oneDeleted: true,
 		},
 		"branch with key equal prefix": {
 			parent: &node.Branch{
@@ -3028,8 +3004,8 @@ func Test_Trie_clearPrefix(t *testing.T) {
 					&node.Leaf{},
 				},
 			},
-			prefix:       []byte{1, 2},
-			nodesRemoved: 2,
+			prefix:     []byte{1, 2},
+			oneDeleted: true,
 		},
 		"branch with no common prefix": {
 			trie: Trie{
@@ -3122,7 +3098,7 @@ func Test_Trie_clearPrefix(t *testing.T) {
 					&node.Leaf{Key: []byte{4}},
 				},
 			},
-			nodesRemoved: 1,
+			oneDeleted: true,
 		},
 		"fully delete child of branch": {
 			trie: Trie{
@@ -3143,7 +3119,7 @@ func Test_Trie_clearPrefix(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			nodesRemoved: 1,
+			oneDeleted: true,
 		},
 		"partially delete child of branch": {
 			trie: Trie{
@@ -3182,7 +3158,7 @@ func Test_Trie_clearPrefix(t *testing.T) {
 					},
 				},
 			},
-			nodesRemoved: 1,
+			oneDeleted: true,
 		},
 		"delete one of two children of branch without value": {
 			trie: Trie{
@@ -3202,7 +3178,7 @@ func Test_Trie_clearPrefix(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			nodesRemoved: 2,
+			oneDeleted: true,
 		},
 	}
 
@@ -3214,11 +3190,10 @@ func Test_Trie_clearPrefix(t *testing.T) {
 			trie := testCase.trie
 			expectedTrie := *trie.DeepCopy()
 
-			newParent, nodesRemoved :=
-				trie.clearPrefix(testCase.parent, testCase.prefix)
+			newParent, oneDeleted := trie.clearPrefix(testCase.parent, testCase.prefix)
 
 			assert.Equal(t, testCase.newParent, newParent)
-			assert.Equal(t, testCase.nodesRemoved, nodesRemoved)
+			assert.Equal(t, testCase.oneDeleted, oneDeleted)
 			assert.Equal(t, expectedTrie, trie)
 		})
 	}
@@ -3333,24 +3308,21 @@ func Test_Trie_delete(t *testing.T) {
 			parent: &node.Leaf{
 				Key: []byte{1},
 			},
-			updated:      true,
-			nodesRemoved: 1,
+			updated: true,
 		},
 		"leaf parent and empty key": {
 			parent: &node.Leaf{
 				Key: []byte{1},
 			},
-			key:          []byte{},
-			updated:      true,
-			nodesRemoved: 1,
+			key:     []byte{},
+			updated: true,
 		},
 		"leaf parent matches key": {
 			parent: &node.Leaf{
 				Key: []byte{1},
 			},
-			key:          []byte{1},
-			updated:      true,
-			nodesRemoved: 1,
+			key:     []byte{1},
+			updated: true,
 		},
 		"leaf parent mismatches key": {
 			trie: Trie{
@@ -3383,8 +3355,7 @@ func Test_Trie_delete(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			updated:      true,
-			nodesRemoved: 1,
+			updated: true,
 		},
 		"branch parent and empty key": {
 			trie: Trie{
@@ -3406,8 +3377,7 @@ func Test_Trie_delete(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			updated:      true,
-			nodesRemoved: 1,
+			updated: true,
 		},
 		"branch parent matches key": {
 			trie: Trie{
@@ -3429,8 +3399,7 @@ func Test_Trie_delete(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			updated:      true,
-			nodesRemoved: 1,
+			updated: true,
 		},
 		"branch parent child matches key": {
 			trie: Trie{
@@ -3453,8 +3422,7 @@ func Test_Trie_delete(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			updated:      true,
-			nodesRemoved: 1,
+			updated: true,
 		},
 		"branch parent mismatches key": {
 			trie: Trie{
@@ -3529,8 +3497,7 @@ func Test_Trie_delete(t *testing.T) {
 				Dirty:      true,
 				Generation: 1,
 			},
-			updated:      true,
-			nodesRemoved: 2,
+			updated: true,
 		},
 		"delete branch and keep two children": {
 			trie: Trie{
@@ -3573,11 +3540,10 @@ func Test_Trie_delete(t *testing.T) {
 			}
 			expectedTrie := *testCase.trie.DeepCopy()
 
-			newParent, updated, nodesRemoved := testCase.trie.delete(testCase.parent, testCase.key)
+			newParent, updated := testCase.trie.delete(testCase.parent, testCase.key)
 
 			assert.Equal(t, testCase.newParent, newParent)
 			assert.Equal(t, testCase.updated, updated)
-			assert.Equal(t, testCase.nodesRemoved, nodesRemoved)
 			assert.Equal(t, expectedTrie, testCase.trie)
 			assert.Equal(t, expectedKey, testCase.key)
 		})
@@ -3588,10 +3554,9 @@ func Test_handleDeletion(t *testing.T) {
 	t.Parallel()
 
 	testCases := map[string]struct {
-		branch            *node.Branch
-		deletedKey        []byte
-		newNode           Node
-		branchChildMerged bool
+		branch     *node.Branch
+		deletedKey []byte
+		newNode    Node
 	}{
 		"branch with value and without children": {
 			branch: &node.Branch{
@@ -3649,7 +3614,6 @@ func Test_handleDeletion(t *testing.T) {
 				Generation: 1,
 				Dirty:      true,
 			},
-			branchChildMerged: true,
 		},
 		"branch without value and a single branch child": {
 			branch: &node.Branch{
@@ -3679,7 +3643,6 @@ func Test_handleDeletion(t *testing.T) {
 					&node.Leaf{Key: []byte{8}},
 				},
 			},
-			branchChildMerged: true,
 		},
 	}
 
@@ -3695,10 +3658,9 @@ func Test_handleDeletion(t *testing.T) {
 				copy(expectedKey, testCase.deletedKey)
 			}
 
-			newNode, branchChildMerged := handleDeletion(testCase.branch, testCase.deletedKey)
+			newNode := handleDeletion(testCase.branch, testCase.deletedKey)
 
 			assert.Equal(t, testCase.newNode, newNode)
-			assert.Equal(t, testCase.branchChildMerged, branchChildMerged)
 			assert.Equal(t, expectedKey, testCase.deletedKey)
 		})
 	}