Merge pull request #6 from distributed-lab/feat/add-tx-verify

Feat/add tx verify

Author: Hrom131

contracts/SPVContract.sol

@@ -4,9 +4,11 @@ pragma solidity ^0.8.28;
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 import {LibSort} from "solady/src/utils/LibSort.sol";
+import {LibBit} from "solady/src/utils/LibBit.sol";
 
 import {BlockHeader, BlockHeaderData} from "./libs/BlockHeader.sol";
 import {TargetsHelper} from "./libs/TargetsHelper.sol";
+import {TxMerkleProof} from "./libs/TxMerkleProof.sol";
 
 import {ISPVContract} from "./interfaces/ISPVContract.sol";
 
@@ -149,8 +151,17 @@ contract SPVContract is ISPVContract, Initializable {
     }
 
     /// @inheritdoc ISPVContract
-    function getBlockMerkleRoot(bytes32 blockHash_) external view returns (bytes32) {
-        return _getBlockHeader(blockHash_).merkleRoot;
+    function verifyTx(
+        bytes32 blockHash_,
+        bytes32 txid_,
+        bytes32[] calldata merkleProof_,
+        TxMerkleProof.HashDirection[] calldata directions_
+    ) external view returns (bool) {
+        bytes32 blockMerkleRoot_ = getBlockMerkleRoot(blockHash_);
+
+        bytes32 reversedRoot_ = bytes32(LibBit.reverseBytes(uint256(blockMerkleRoot_)));
+
+        return TxMerkleProof.verify(merkleProof_, directions_, reversedRoot_, txid_);
     }
 
     /// @inheritdoc ISPVContract
@@ -173,6 +184,11 @@ contract SPVContract is ISPVContract, Initializable {
         return _getSPVContractStorage().lastEpochCumulativeWork;
     }
 
+    /// @inheritdoc ISPVContract
+    function getBlockMerkleRoot(bytes32 blockHash_) public view returns (bytes32) {
+        return _getBlockHeader(blockHash_).merkleRoot;
+    }
+
     /// @inheritdoc ISPVContract
     function getMainchainHead() public view returns (bytes32) {
         return _getSPVContractStorage().mainchainHead;

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.
@@ -120,6 +121,20 @@ interface ISPVContract {
      */
     function validateBlockHash(bytes32 blockHash_) external view returns (bool, uint256);
 
+    /**
+     * @notice Verifies that given txid is included in the specified block
+     * @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 array indicating the hashing directions for the Merkle proof
+     */
+    function verifyTx(
+        bytes32 blockHash_,
+        bytes32 txid_,
+        bytes32[] memory merkleProof_,
+        TxMerkleProof.HashDirection[] calldata directions_
+    ) external view returns (bool);
+
     /**
      * @notice Returns the cumulative work of the last epoch.
      * This represents the total difficulty accumulated up to the last epoch boundary

contracts/libs/TxMerkleProof.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+/**
+ * @notice A library for verifying transaction inclusion in Bitcoin block.
+ * 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
+     */
+    error InvalidLengths();
+
+    /**
+     * @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 element of `directions_` indicates
+     * the hashing order for each pair. Uses double SHA-256 hashing
+     */
+    function verify(
+        bytes32[] calldata proof_,
+        HashDirection[] calldata directions_,
+        bytes32 root_,
+        bytes32 leaf_
+    ) internal pure returns (bool) {
+        require(directions_.length == proof_.length, InvalidLengths());
+
+        return processProof(proof_, directions_, leaf_) == root_;
+    }
+
+    /**
+     * @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_` elements. Uses double SHA-256 hashing
+     */
+    function processProof(
+        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] == HashDirection.Left) {
+                computedHash_ = _doubleSHA256(computedHash_, proof_[i]);
+            } else if (directions_[i] == HashDirection.Right) {
+                computedHash_ = _doubleSHA256(proof_[i], computedHash_);
+            } else {
+                computedHash_ = _doubleSHA256(computedHash_, computedHash_);
+            }
+        }
+
+        return computedHash_;
+    }
+
+    function _doubleSHA256(bytes32 left_, bytes32 right_) private pure returns (bytes32) {
+        return sha256(abi.encodePacked(sha256(abi.encodePacked(left_, right_))));
+    }
+}