Reuse block signing code for signet and elements

Author: jtimon

src/pow.cpp

@@ -38,16 +38,38 @@ void ResetChallenge(CBlockHeader& block, const CBlockIndex& indexLast, const Con
     block.proof.challenge = indexLast.proof.challenge;
 }
 
-bool CheckBitcoinProof(uint256 hash, unsigned int nBits)
+static const unsigned int BLOCK_VERIFY_FLAGS = MANDATORY_SCRIPT_VERIFY_FLAGS |
+                                               SCRIPT_VERIFY_DERSIG |
+                                               SCRIPT_VERIFY_STRICTENC |
+                                               SCRIPT_VERIFY_MINIMALDATA |
+                                               SCRIPT_VERIFY_NULLDUMMY |
+                                               SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
+                                               SCRIPT_VERIFY_CLEANSTACK |
+                                               SCRIPT_VERIFY_MINIMALIF |
+                                               SCRIPT_VERIFY_NULLFAIL |
+                                               SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
+                                               SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
+                                               SCRIPT_VERIFY_LOW_S |
+                                               SCRIPT_VERIFY_WITNESS |
+                                               SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM |
+                                               SCRIPT_VERIFY_WITNESS_PUBKEYTYPE;
+
+bool CheckBitcoinProof(const uint256& hash, unsigned int nBits, const Consensus::Params& params)
 {
+    if (g_solution_blocks) {
+        const auto& payload = g_blockheader_payload_map.at(hash);
+        CScript solution = CScript(payload.begin(), payload.end());
+        return HashVerifyScript(solution, params.parent_chain_signblockscript, BLOCK_VERIFY_FLAGS, hash);
+    }
+    
     bool fNegative;
     bool fOverflow;
     arith_uint256 bnTarget;
 
     bnTarget.SetCompact(nBits, &fNegative, &fOverflow);
 
     // Check range
-    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(Params().GetConsensus().parentChainPowLimit))
+    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.parentChainPowLimit))
         return false;
 
     // Check proof of work matches claimed amount

src/pow.h

@@ -20,7 +20,7 @@ class CWallet;
 class uint256;
 
 /** Check whether a block hash satisfies the proof-of-work requirement specified by nBits */
-bool CheckBitcoinProof(uint256 hash, unsigned int nBits);
+bool CheckBitcoinProof(const uint256& hash, unsigned int nBits, const Consensus::Params& params);
 bool CheckProofSignedParent(const CBlockHeader& block, const Consensus::Params& params);
 bool CheckProof(const CBlockHeader& block, const Consensus::Params&);
 /** Scans nonces looking for a hash with at least some zero bits */

src/script/generic.hpp

@@ -49,6 +49,11 @@ bool GenericVerifyScript(const CScript& scriptSig, const CScript& scriptPubKey,
     return VerifyScript(scriptSig, scriptPubKey, NULL, flags, SimpleSignatureChecker(SerializeHash(data)));
 }
 
+bool HashVerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, unsigned int flags, const uint256& hash)
+{
+    return VerifyScript(scriptSig, scriptPubKey, NULL, flags, SimpleSignatureChecker(hash));
+}
+
 template<typename T>
 bool GenericSignScript(const CKeyStore& keystore, const T& data, const CScript& fromPubKey, SignatureData& scriptSig)
 {

src/validation.cpp

@@ -2539,7 +2539,7 @@ bool IsValidPeginWitness(const CScriptWitness& pegin_witness, const COutPoint& p
         if (!GetBlockAndTxFromMerkleBlock(block_hash, tx_hash, merkle_block_pow, stack[5])) {
             return false;
         }
-        if (!CheckBitcoinProof(block_hash, merkle_block_pow.header.nBits)) {
+        if (!CheckBitcoinProof(block_hash, merkle_block_pow.header.nBits, Params().GetConsensus())) {
             return false;
         }
 

src/wallet/rpcwallet.cpp

@@ -3721,7 +3721,7 @@ UniValue createrawpegin(const JSONRPCRequest& request)
         Sidechain::Bitcoin::CTransaction tx_aux;
         Sidechain::Bitcoin::CMerkleBlock merkleBlock;
         ret = createrawpegin(request, txBTCRef, tx_aux, merkleBlock);
-        if (!CheckBitcoinProof(merkleBlock.header.GetHash(), merkleBlock.header.nBits)) {
+        if (!CheckBitcoinProof(merkleBlock.header.GetHash(), merkleBlock.header.nBits, Params().GetConsensus())) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid tx out proof");
         }
     } else {