switched from bytes to HashDirection array;

refactored parse-proof-helpers

Author: aritkulova

contracts/SPVContract.sol

@@ -155,7 +155,7 @@ contract SPVContract is ISPVContract, Initializable {
         bytes32 blockHash_,
         bytes32 txid_,
         bytes32[] calldata merkleProof_,
-        bytes calldata directions_
+        TxMerkleProof.HashDirection[] calldata directions_
     ) external view returns (bool) {
         bytes32 blockMerkleRoot_ = getBlockMerkleRoot(blockHash_);
 

contracts/interfaces/ISPVContract.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.28;
 
 import {BlockHeaderData} from "../libs/BlockHeader.sol";
+import {TxMerkleProof} from "../libs/TxMerkleProof.sol";
 
 /**
  * @notice Interface for an SPV (Simplified Payment Verification) contract.
@@ -125,13 +126,13 @@ interface ISPVContract {
      * @param blockHash_ The hash of the block in which to verify the transaction
      * @param txid_ The transaction id to verify
      * @param merkleProof_ The array of hashes used to build the Merkle root
-     * @param directions_ The string indicating the hashing directions for the Merkle proof
+     * @param directions_ The array indicating the hashing directions for the Merkle proof
      */
     function verifyTx(
         bytes32 blockHash_,
         bytes32 txid_,
         bytes32[] memory merkleProof_,
-        bytes calldata directions_
+        TxMerkleProof.HashDirection[] calldata directions_
     ) external view returns (bool);
 
     /**

contracts/libs/TxMerkleProof.sol

@@ -6,6 +6,18 @@ pragma solidity ^0.8.28;
  * Provides functions for processing and verifying Merkle tree proofs
  */
 library TxMerkleProof {
+    /**
+     * @notice Possible directions for hashing:
+     * - Left: computed hash is on the left, sibling hash is on the right.
+     * - Right: computed hash is on the right, sibling hash is on the left.
+     * - Self: node has no sibling and is hashed with itself.
+     * */
+    enum HashDirection {
+        Left,
+        Right,
+        Self
+    }
+
     /**
      * @notice Emitted when the proof and directions array are of different length.
      * This error ensures that only correctly sized proofs are processed
@@ -15,13 +27,13 @@ library TxMerkleProof {
     /**
      * @notice Returns true if `leaf_` can be proven to be part of a Merkle tree
      * defined by `root_`. Requires a `proof_` containing the sibling hashes along
-     * the path from the leaf to the root. Each byte of `directions_` indicates
+     * the path from the leaf to the root. Each element of `directions_` indicates
      * the hashing order for each pair.
      * Uses double SHA-256 hashing.
      */
     function verify(
-        bytes32[] memory proof_,
-        bytes calldata directions_,
+        bytes32[] calldata proof_,
+        HashDirection[] calldata directions_,
         bytes32 root_,
         bytes32 leaf_
     ) internal pure returns (bool) {
@@ -34,31 +46,31 @@ library TxMerkleProof {
      * @notice Returns the rebuilt hash obtained by traversing the Merkle tree
      * from `leaf_` using `proof_`. A `proof_` is valid if and only if the rebuilt
      * hash matches the given tree root. The pre-images are hashed in the order
-     * specified by the `directions_` bytes.
+     * specified by the `directions_` elements.
      * Uses double SHA-256 hashing.
      */
     function processProof(
-        bytes32[] memory proof_,
-        bytes calldata directions_,
+        bytes32[] calldata proof_,
+        HashDirection[] calldata directions_,
         bytes32 leaf_
     ) internal pure returns (bytes32) {
         bytes32 computedHash_ = leaf_;
         uint256 proofLength_ = proof_.length;
 
         for (uint256 i = 0; i < proofLength_; ++i) {
-            if (directions_[i] == hex"00") {
-                computedHash_ = _sha256(computedHash_, proof_[i]);
-            } else if (directions_[i] == hex"01") {
-                computedHash_ = _sha256(proof_[i], computedHash_);
+            if (directions_[i] == HashDirection.Left) {
+                computedHash_ = _doubleSHA256(computedHash_, proof_[i]);
+            } else if (directions_[i] == HashDirection.Right) {
+                computedHash_ = _doubleSHA256(proof_[i], computedHash_);
             } else {
-                computedHash_ = _sha256(computedHash_, computedHash_);
+                computedHash_ = _doubleSHA256(computedHash_, computedHash_);
             }
         }
 
         return computedHash_;
     }
 
-    function _sha256(bytes32 left_, bytes32 right_) private pure returns (bytes32) {
+    function _doubleSHA256(bytes32 left_, bytes32 right_) private pure returns (bytes32) {
         return sha256(abi.encodePacked(sha256(abi.encodePacked(left_, right_))));
     }
 }