added function to verify that tx is included in the block;

added lib for merkle proof verification

Author: aritkulova

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_,
+        bytes 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

@@ -120,6 +120,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 string indicating the hashing directions for the Merkle proof
+     */
+    function verifyTx(
+        bytes32 blockHash_,
+        bytes32 txid_,
+        bytes32[] memory merkleProof_,
+        bytes 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,46 @@
+// 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 {
+    error InvalidLengths();
+
+    function verify(
+        bytes32[] memory proof_,
+        bytes calldata directions_,
+        bytes32 root_,
+        bytes32 leaf_
+    ) internal pure returns (bool) {
+        require(directions_.length == proof_.length, InvalidLengths());
+
+        return processProof(proof_, directions_, leaf_) == root_;
+    }
+
+    function processProof(
+        bytes32[] memory proof_,
+        bytes 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_);
+            } else {
+                computedHash_ = _sha256(computedHash_, computedHash_);
+            }
+        }
+
+        return computedHash_;
+    }
+
+    function _sha256(bytes32 left_, bytes32 right_) private pure returns (bytes32) {
+        return sha256(abi.encodePacked(sha256(abi.encodePacked(left_, right_))));
+    }
+}