Add storage optimizations

Author: Hrom131

contracts/SPVContract.sol

@@ -23,7 +23,7 @@ contract SPVContract is ISPVContract, Initializable {
 
     struct SPVContractStorage {
         mapping(bytes32 => BlockData) blocksData;
-        mapping(uint256 => bytes32) blocksHeightToBlockHash;
+        mapping(uint64 => bytes32) blocksHeightToBlockHash;
         bytes32 mainchainHead;
         uint256 lastEpochCumulativeWork;
     }
@@ -56,7 +56,7 @@ contract SPVContract is ISPVContract, Initializable {
 
     function __SPVContract_init(
         bytes calldata blockHeaderRaw_,
-        uint256 blockHeight_,
+        uint64 blockHeight_,
         uint256 cumulativeWork_
     ) external initializer {
         (BlockHeaderData memory blockHeader_, bytes32 blockHash_) = _parseBlockHeaderRaw(
@@ -91,11 +91,11 @@ contract SPVContract is ISPVContract, Initializable {
             bytes32[] memory blockHashes_
         ) = _parseBlockHeadersRaw(blockHeaderRawArray_);
 
-        uint256 firstBlockHeight_ = getBlockHeight(blockHeaders_[0].prevBlockHash) + 1;
+        uint64 firstBlockHeight_ = getBlockHeight(blockHeaders_[0].prevBlockHash) + 1;
         bytes32 currentTarget_ = getBlockTarget(blockHeaders_[0].prevBlockHash);
 
-        for (uint256 i = 0; i < blockHeaderRawArray_.length; ++i) {
-            uint256 currentBlockHeight_ = firstBlockHeight_ + i;
+        for (uint64 i = 0; i < blockHeaderRawArray_.length; ++i) {
+            uint64 currentBlockHeight_ = firstBlockHeight_ + i;
 
             currentTarget_ = _updateLastEpochCumulativeWork(currentTarget_, currentBlockHeight_);
 
@@ -126,7 +126,7 @@ contract SPVContract is ISPVContract, Initializable {
             PrevBlockDoesNotExist(blockHeader_.prevBlockHash)
         );
 
-        uint256 blockHeight_ = getBlockHeight(blockHeader_.prevBlockHash) + 1;
+        uint64 blockHeight_ = getBlockHeight(blockHeader_.prevBlockHash) + 1;
         bytes32 currentTarget_ = getBlockTarget(blockHeader_.prevBlockHash);
 
         currentTarget_ = _updateLastEpochCumulativeWork(currentTarget_, blockHeight_);
@@ -142,16 +142,7 @@ contract SPVContract is ISPVContract, Initializable {
     }
 
     /// @inheritdoc ISPVContract
-    function validateBlockHash(bytes32 blockHash_) external view returns (bool, uint256) {
-        if (!isInMainchain(blockHash_)) {
-            return (false, 0);
-        }
-
-        return (true, getMainchainBlockHeight() - getBlockHeight(blockHash_));
-    }
-
-    /// @inheritdoc ISPVContract
-    function verifyTx(
+    function checkTxInclusion(
         bytes32 blockHash_,
         bytes32 txid_,
         bytes32[] calldata merkleProof_,
@@ -164,6 +155,15 @@ contract SPVContract is ISPVContract, Initializable {
         return TxMerkleProof.verify(merkleProof_, directions_, reversedRoot_, txid_);
     }
 
+    /// @inheritdoc ISPVContract
+    function getBlockStatus(bytes32 blockHash_) external view returns (bool, uint256) {
+        if (!isInMainchain(blockHash_)) {
+            return (false, 0);
+        }
+
+        return (true, getMainchainHeight() - getBlockHeight(blockHash_));
+    }
+
     /// @inheritdoc ISPVContract
     function getBlockInfo(bytes32 blockHash_) external view returns (BlockInfo memory blockInfo_) {
         if (!blockExists(blockHash_)) {
@@ -186,7 +186,7 @@ contract SPVContract is ISPVContract, Initializable {
 
     /// @inheritdoc ISPVContract
     function getBlockMerkleRoot(bytes32 blockHash_) public view returns (bytes32) {
-        return _getBlockHeader(blockHash_).merkleRoot;
+        return _getSPVContractStorage().blocksData[blockHash_].merkleRoot;
     }
 
     /// @inheritdoc ISPVContract
@@ -200,27 +200,27 @@ contract SPVContract is ISPVContract, Initializable {
     }
 
     /// @inheritdoc ISPVContract
-    function getBlockHeight(bytes32 blockHash_) public view returns (uint256) {
+    function getBlockHeight(bytes32 blockHash_) public view returns (uint64) {
         return _getSPVContractStorage().blocksData[blockHash_].blockHeight;
     }
 
     /// @inheritdoc ISPVContract
-    function getBlockHash(uint256 blockHeight_) public view returns (bytes32) {
+    function getBlockHash(uint64 blockHeight_) public view returns (bytes32) {
         return _getSPVContractStorage().blocksHeightToBlockHash[blockHeight_];
     }
 
     /// @inheritdoc ISPVContract
     function getBlockTarget(bytes32 blockHash_) public view returns (bytes32) {
-        return TargetsHelper.bitsToTarget(_getBlockHeader(blockHash_).bits);
+        return TargetsHelper.bitsToTarget(_getSPVContractStorage().blocksData[blockHash_].bits);
     }
 
     /// @inheritdoc ISPVContract
     function blockExists(bytes32 blockHash_) public view returns (bool) {
-        return _getBlockHeader(blockHash_).time > 0;
+        return _getBlockHeaderTime(blockHash_) > 0;
     }
 
     /// @inheritdoc ISPVContract
-    function getMainchainBlockHeight() public view returns (uint256) {
+    function getMainchainHeight() public view returns (uint256) {
         return getBlockHeight(_getSPVContractStorage().mainchainHead);
     }
 
@@ -232,11 +232,19 @@ contract SPVContract is ISPVContract, Initializable {
     function _addBlock(
         BlockHeaderData memory blockHeader_,
         bytes32 blockHash_,
-        uint256 blockHeight_
+        uint64 blockHeight_
     ) internal {
         SPVContractStorage storage $ = _getSPVContractStorage();
 
-        $.blocksData[blockHash_] = BlockData({header: blockHeader_, blockHeight: blockHeight_});
+        $.blocksData[blockHash_] = BlockData({
+            prevBlockHash: blockHeader_.prevBlockHash,
+            merkleRoot: blockHeader_.merkleRoot,
+            version: blockHeader_.version,
+            time: blockHeader_.time,
+            nonce: blockHeader_.nonce,
+            bits: blockHeader_.bits,
+            blockHeight: blockHeight_
+        });
 
         _updateMainchainHead(blockHeader_, blockHash_, blockHeight_);
 
@@ -246,7 +254,7 @@ contract SPVContract is ISPVContract, Initializable {
     function _updateMainchainHead(
         BlockHeaderData memory blockHeader_,
         bytes32 blockHash_,
-        uint256 blockHeight_
+        uint64 blockHeight_
     ) internal {
         SPVContractStorage storage $ = _getSPVContractStorage();
 
@@ -270,31 +278,34 @@ contract SPVContract is ISPVContract, Initializable {
             $.blocksHeightToBlockHash[blockHeight_] = blockHash_;
 
             bytes32 prevBlockHash_ = blockHeader_.prevBlockHash;
-            uint256 prevBlockHeight_ = blockHeight_ - 1;
+            uint64 prevBlockHeight_ = blockHeight_ - 1;
 
             do {
                 $.blocksHeightToBlockHash[prevBlockHeight_] = prevBlockHash_;
 
-                prevBlockHash_ = _getBlockHeader(prevBlockHash_).prevBlockHash;
-                --prevBlockHeight_;
+                prevBlockHash_ = _getSPVContractStorage().blocksData[prevBlockHash_].prevBlockHash;
+
+                unchecked {
+                    --prevBlockHeight_;
+                }
             } while (getBlockHash(prevBlockHeight_) != prevBlockHash_ && prevBlockHash_ != 0);
         }
     }
 
     function _updateLastEpochCumulativeWork(
         bytes32 currentTarget_,
-        uint256 blockHeight_
+        uint64 blockHeight_
     ) internal returns (bytes32) {
         SPVContractStorage storage $ = _getSPVContractStorage();
 
         if (TargetsHelper.isTargetAdjustmentBlock(blockHeight_)) {
             $.lastEpochCumulativeWork += TargetsHelper.countEpochCumulativeWork(currentTarget_);
 
-            uint256 epochStartTime_ = _getBlockHeader(
+            uint32 epochStartTime_ = _getBlockHeaderTime(
                 getBlockHash(blockHeight_ - TargetsHelper.DIFFICULTY_ADJUSTMENT_INTERVAL)
-            ).time;
-            uint256 epochEndTime_ = _getBlockHeader(getBlockHash(blockHeight_ - 1)).time;
-            uint256 passedTime_ = epochEndTime_ - epochStartTime_;
+            );
+            uint32 epochEndTime_ = _getBlockHeaderTime(getBlockHash(blockHeight_ - 1));
+            uint32 passedTime_ = epochEndTime_ - epochStartTime_;
 
             currentTarget_ = TargetsHelper.countNewRoundedTarget(currentTarget_, passedTime_);
         }
@@ -350,17 +361,17 @@ contract SPVContract is ISPVContract, Initializable {
         bytes32 toBlockHash_ = blockHeader_.prevBlockHash;
 
         if (blockHeight_ - 1 < MEDIAN_PAST_BLOCKS) {
-            return _getBlockHeader(toBlockHash_).time;
+            return _getBlockHeaderTime(toBlockHash_);
         }
 
         uint256[] memory blocksTime_ = new uint256[](MEDIAN_PAST_BLOCKS);
         bool needsSort_;
 
         for (uint256 i = MEDIAN_PAST_BLOCKS; i > 0; --i) {
-            uint32 currentTime_ = _getBlockHeader(toBlockHash_).time;
+            uint32 currentTime_ = _getBlockHeaderTime(toBlockHash_);
 
             blocksTime_[i - 1] = currentTime_;
-            toBlockHash_ = _getBlockHeader(toBlockHash_).prevBlockHash;
+            toBlockHash_ = _getSPVContractStorage().blocksData[toBlockHash_].prevBlockHash;
 
             if (i < MEDIAN_PAST_BLOCKS && currentTime_ > blocksTime_[i]) {
                 needsSort_ = true;
@@ -395,7 +406,7 @@ contract SPVContract is ISPVContract, Initializable {
     }
 
     function _getBlockCumulativeWork(
-        uint256 blockHeight_,
+        uint64 blockHeight_,
         bytes32 blockHash_
     ) internal view returns (uint256) {
         uint256 currentEpochCumulativeWork_ = getBlockTarget(blockHash_).countCumulativeWork(
@@ -405,8 +416,8 @@ contract SPVContract is ISPVContract, Initializable {
         return _getSPVContractStorage().lastEpochCumulativeWork + currentEpochCumulativeWork_;
     }
 
-    function _getBlockHeader(bytes32 blockHash_) internal view returns (BlockHeaderData storage) {
-        return _getSPVContractStorage().blocksData[blockHash_].header;
+    function _getBlockHeaderTime(bytes32 blockHash_) internal view returns (uint32) {
+        return _getSPVContractStorage().blocksData[blockHash_].time;
     }
 
     function _onlyNonExistingBlock(bytes32 blockHash_) internal view {

contracts/interfaces/ISPVContract.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
-import {BlockHeaderData} from "../libs/BlockHeader.sol";
 import {TxMerkleProof} from "../libs/TxMerkleProof.sol";
 
 /**
@@ -79,12 +78,22 @@ interface ISPVContract {
 
     /**
      * @notice Represents the data of a block
-     * @param header The parsed block header data
+     * @param prevBlockHash The hash of the previous block
+     * @param merkleRoot The Merkle root of the transactions in the block
+     * @param version The block version number
+     * @param time The block's timestamp
+     * @param nonce The nonce used for mining
+     * @param bits The encoded difficulty target for the block
      * @param blockHeight The block height
      */
     struct BlockData {
-        BlockHeaderData header;
-        uint256 blockHeight;
+        bytes32 prevBlockHash;
+        bytes32 merkleRoot;
+        uint32 version;
+        uint32 time;
+        uint32 nonce;
+        bytes4 bits;
+        uint64 blockHeight;
     }
 
     /**
@@ -114,27 +123,28 @@ interface ISPVContract {
     function addBlockHeader(bytes calldata blockHeaderRaw_) external;
 
     /**
-     * @notice Validates a given block hash and returns its mainchain status and confirmation count
-     * @param blockHash_ The hash of the block to validate
-     * @return isInMainchain True if the block is in the mainchain, false otherwise
-     * @return confirmationsCount The number of blocks that have been mined on top of the validated block
-     */
-    function validateBlockHash(bytes32 blockHash_) external view returns (bool, uint256);
-
-    /**
-     * @notice Verifies that given txid is included in the specified block
+     * @notice Checks 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 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
+     * @return True if the txId is present in the block's Merkle tree, false otherwise
      */
-    function verifyTx(
+    function checkTxInclusion(
         bytes32 blockHash_,
-        bytes32 txid_,
+        bytes32 txId_,
         bytes32[] memory merkleProof_,
         TxMerkleProof.HashDirection[] calldata directions_
     ) external view returns (bool);
 
+    /**
+     * @notice Returns the current status of a given block
+     * @param blockHash_ The hash of the block to check
+     * @return isInMainchain True if the block is in the mainchain, false otherwise
+     * @return confirmationsCount The number of blocks that have been mined on top of the given block
+     */
+    function getBlockStatus(bytes32 blockHash_) external view returns (bool, uint256);
+
     /**
      * @notice Returns the cumulative work of the last epoch.
      * This represents the total difficulty accumulated up to the last epoch boundary
@@ -178,23 +188,23 @@ interface ISPVContract {
      * This represents the highest block number on the most accumulated work chain
      * @return The height of the mainchain head
      */
-    function getMainchainBlockHeight() external view returns (uint256);
+    function getMainchainHeight() external view returns (uint256);
 
     /**
      * @notice Returns the block height for a given block hash
      * This function retrieves the height at which the block exists in the chain
      * @param blockHash_ The hash of the block
      * @return The height of the block
      */
-    function getBlockHeight(bytes32 blockHash_) external view returns (uint256);
+    function getBlockHeight(bytes32 blockHash_) external view returns (uint64);
 
     /**
      * @notice Returns the block hash for a given block height.
      * This function retrieves the hash of the block from the mainchain at the specified height
      * @param blockHeight_ The height of the block
      * @return The hash of the block
      */
-    function getBlockHash(uint256 blockHeight_) external view returns (bytes32);
+    function getBlockHash(uint64 blockHeight_) external view returns (bytes32);
 
     /**
      * @notice Returns the target of a given block hash.

contracts/libs/TargetsHelper.sol

@@ -17,7 +17,7 @@ library TargetsHelper {
      * @notice The number of blocks after which the difficulty target is adjusted.
      * This is a fundamental constant in Bitcoin's difficulty adjustment algorithm
      */
-    uint256 public constant DIFFICULTY_ADJUSTMENT_INTERVAL = 2016;
+    uint64 public constant DIFFICULTY_ADJUSTMENT_INTERVAL = 2016;
 
     /**
      * @notice The initial difficulty target for the Bitcoin blockchain.
@@ -54,7 +54,7 @@ library TargetsHelper {
      * @param blockHeight_ The height of the block to check
      * @return True if it's an adjustment block, false otherwise
      */
-    function isTargetAdjustmentBlock(uint256 blockHeight_) internal pure returns (bool) {
+    function isTargetAdjustmentBlock(uint64 blockHeight_) internal pure returns (bool) {
         return getEpochBlockNumber(blockHeight_) == 0 && blockHeight_ > 0;
     }
 
@@ -64,7 +64,7 @@ library TargetsHelper {
      * @param blockHeight_ The height of the block
      * @return The block number within its current epoch
      */
-    function getEpochBlockNumber(uint256 blockHeight_) internal pure returns (uint256) {
+    function getEpochBlockNumber(uint64 blockHeight_) internal pure returns (uint64) {
         return blockHeight_ % DIFFICULTY_ADJUSTMENT_INTERVAL;
     }
 
@@ -77,7 +77,7 @@ library TargetsHelper {
      */
     function countNewRoundedTarget(
         bytes32 currentTarget_,
-        uint256 actualPassedTime_
+        uint32 actualPassedTime_
     ) internal pure returns (bytes32) {
         return roundTarget(countNewTarget(currentTarget_, actualPassedTime_));
     }
@@ -91,7 +91,7 @@ library TargetsHelper {
      */
     function countNewTarget(
         bytes32 currentTarget_,
-        uint256 actualPassedTime_
+        uint32 actualPassedTime_
     ) internal pure returns (bytes32) {
         uint256 currentRatio = (actualPassedTime_ * TARGET_FIXED_POINT_FACTOR) /
             EXPECTED_TARGET_BLOCKS_TIME;
@@ -124,7 +124,7 @@ library TargetsHelper {
      */
     function countCumulativeWork(
         bytes32 epochTarget_,
-        uint256 blocksCount_
+        uint64 blocksCount_
     ) internal pure returns (uint256) {
         return countBlockWork(epochTarget_) * blocksCount_;
     }