merkle: remove unused proot and pmutated args from MerkleComputation

l0rinc · l0rinc · commit 63d640fa6a70 · 2025-11-06T10:21:51.000+01:00
There's a single call to the methods from `ComputeMerklePath` where these were always set to `nullptr`.
diff --git a/src/consensus/merkle.cpp b/src/consensus/merkle.cpp
@@ -84,17 +84,14 @@ uint256 BlockWitnessMerkleRoot(const CBlock& block, bool* mutated)
     return ComputeMerkleRoot(std::move(leaves), mutated);
 }
 
-/* This implements a constant-space merkle root/path calculator, limited to 2^32 leaves. */
-static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot, bool* pmutated, uint32_t leaf_pos, std::vector<uint256>& path)
+/* This implements a constant-space merkle path calculator, limited to 2^32 leaves. */
+static void MerkleComputation(const std::vector<uint256>& leaves, uint32_t leaf_pos, std::vector<uint256>& path)
 {
     path.clear();
     Assume(leaves.size() <= UINT32_MAX);
     if (leaves.size() == 0) {
-        if (pmutated) *pmutated = false;
-        if (proot) *proot = uint256();
         return;
     }
-    bool mutated = false;
     // count is the number of leaves processed so far.
     uint32_t count = 0;
     // inner is an array of eagerly computed subtree hashes, indexed by tree
@@ -121,7 +118,6 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
                 path.push_back(h);
                 matchh = true;
             }
-            mutated |= (inner[level] == h);
             h = Hash(inner[level], h);
         }
         // Store the resulting hash at inner position level.
@@ -165,14 +161,11 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
             level++;
         }
     }
-    // Return result.
-    if (pmutated) *pmutated = mutated;
-    if (proot) *proot = h;
 }
 
 static std::vector<uint256> ComputeMerklePath(const std::vector<uint256>& leaves, uint32_t position) {
     std::vector<uint256> ret;
-    MerkleComputation(leaves, nullptr, nullptr, position, ret);
+    MerkleComputation(leaves, position, ret);
     return ret;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -84,17 +84,14 @@ uint256 BlockWitnessMerkleRoot(const CBlock& block, bool* mutated)`
`84`	`84`	`return ComputeMerkleRoot(std::move(leaves), mutated);`
`85`	`85`	`}`
`86`	`86`
`87`		`-/* This implements a constant-space merkle root/path calculator, limited to 2^32 leaves. */`
`88`		`-static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot, bool* pmutated, uint32_t leaf_pos, std::vector<uint256>& path)`
	`87`	`+/* This implements a constant-space merkle path calculator, limited to 2^32 leaves. */`
	`88`	`+static void MerkleComputation(const std::vector<uint256>& leaves, uint32_t leaf_pos, std::vector<uint256>& path)`
`89`	`89`	`{`
`90`	`90`	`path.clear();`
`91`	`91`	`Assume(leaves.size() <= UINT32_MAX);`
`92`	`92`	`if (leaves.size() == 0) {`
`93`		`- if (pmutated) *pmutated = false;`
`94`		`- if (proot) *proot = uint256();`
`95`	`93`	`return;`
`96`	`94`	`}`
`97`		`- bool mutated = false;`
`98`	`95`	`// count is the number of leaves processed so far.`
`99`	`96`	`uint32_t count = 0;`
`100`	`97`	`// inner is an array of eagerly computed subtree hashes, indexed by tree`
`@@ -121,7 +118,6 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot`
`121`	`118`	`path.push_back(h);`
`122`	`119`	`matchh = true;`
`123`	`120`	`}`
`124`		`- mutated \|= (inner[level] == h);`
`125`	`121`	`h = Hash(inner[level], h);`
`126`	`122`	`}`
`127`	`123`	`// Store the resulting hash at inner position level.`
`@@ -165,14 +161,11 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot`
`165`	`161`	`level++;`
`166`	`162`	`}`
`167`	`163`	`}`
`168`		`- // Return result.`
`169`		`- if (pmutated) *pmutated = mutated;`
`170`		`- if (proot) *proot = h;`
`171`	`164`	`}`
`172`	`165`
`173`	`166`	`static std::vector<uint256> ComputeMerklePath(const std::vector<uint256>& leaves, uint32_t position) {`
`174`	`167`	`std::vector<uint256> ret;`
`175`		`- MerkleComputation(leaves, nullptr, nullptr, position, ret);`
	`168`	`+ MerkleComputation(leaves, position, ret);`
`176`	`169`	`return ret;`
`177`	`170`	`}`
`178`	`171`