text: // Copyright (c) 2013-2016 The Bitcoin Core developers
  // Copyright (c) 2017-2019 The Raven Core developers
  // Copyright (c) 2020-2021 The redecoin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "consensus/tx_verify.h"
  #include "consensus/validation.h"
  #include "data/sighash.json.h"
  #include "hash.h"
  #include "script/interpreter.h"
  #include "script/script.h"
  #include "serialize.h"
  #include "streams.h"
  #include "test/test_redecoin.h"
  #include "util.h"
  #include "utilstrencodings.h"
  #include "version.h"
  
  #include <iostream>
  
  #include <boost/test/unit_test.hpp>
  
  #include <univalue.h>
  
  extern UniValue read_json(const std::string &jsondata);
  
  // Old script.cpp signature_hash function
  uint256 static SignatureHashOld(CScript scriptCode, const CTransaction &txTo, unsigned int nIn, int nHashType)
  {
      static const uint256 one(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
      if (nIn >= txTo.vin.size())
      {
          return one;
      }
      CMutableTransaction txTmp(txTo);
  
      // In case concatenating two scripts ends up with two codeseparators,
      // or an extra one at the end, this prevents all those possible incompatibilities.
      scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
  
      // Blank out other inputs' signatures
      for (unsigned int i = 0; i < txTmp.vin.size(); i++)
          txTmp.vin[i].scriptSig = CScript();
      txTmp.vin[nIn].scriptSig = scriptCode;
  
      // Blank out some of the outputs
      if ((nHashType & 0x1f) == SIGHASH_NONE)
      {
          // Wildcard payee
          txTmp.vout.clear();
  
          // Let the others update at will
          for (unsigned int i = 0; i < txTmp.vin.size(); i++)
              if (i != nIn)
                  txTmp.vin[i].nSequence = 0;
      } else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
      {
          // Only lock-in the txout payee at same index as txin
          unsigned int nOut = nIn;
          if (nOut >= txTmp.vout.size())
          {
              return one;
          }
          txTmp.vout.resize(nOut + 1);
          for (unsigned int i = 0; i < nOut; i++)
              txTmp.vout[i].SetNull();
  
          // Let the others update at will
          for (unsigned int i = 0; i < txTmp.vin.size(); i++)
              if (i != nIn)
                  txTmp.vin[i].nSequence = 0;
      }
  
      // Blank out other inputs completely, not recommended for open transactions
      if (nHashType & SIGHASH_ANYONECANPAY)
      {
          txTmp.vin[0] = txTmp.vin[nIn];
          txTmp.vin.resize(1);
      }
  
      // Serialize and hash
      CHashWriter ss(SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
      ss << txTmp << nHashType;
      return ss.GetHash();
  }
  
  void static RandomScript(CScript &script)
  {
      static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
      script = CScript();
      int ops = (InsecureRandRange(10));
      for (int i = 0; i < ops; i++)
          script << oplist[InsecureRandRange(sizeof(oplist) / sizeof(oplist[0]))];
  }
  
  void static RandomTransaction(CMutableTransaction &tx, bool fSingle)
  {
      tx.nVersion = InsecureRand32();
      tx.vin.clear();
      tx.vout.clear();
      tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;
      int ins = (InsecureRandBits(2)) + 1;
      int outs = fSingle ? ins : (InsecureRandBits(2)) + 1;
      for (int in = 0; in < ins; in++)
      {
          tx.vin.push_back(CTxIn());
          CTxIn &txin = tx.vin.back();
          txin.prevout.hash = InsecureRand256();
          txin.prevout.n = InsecureRandBits(2);
          RandomScript(txin.scriptSig);
          txin.nSequence = (InsecureRandBool()) ? InsecureRand32() : (unsigned int) -1;
      }
      for (int out = 0; out < outs; out++)
      {
          tx.vout.push_back(CTxOut());
          CTxOut &txout = tx.vout.back();
          txout.nValue = InsecureRandRange(100000000);
          RandomScript(txout.scriptPubKey);
      }
  }
  
  BOOST_FIXTURE_TEST_SUITE(sighash_tests, BasicTestingSetup)
  
      BOOST_AUTO_TEST_CASE(sighash_test)
      {
          BOOST_TEST_MESSAGE("Running SigHash Test");
  
          SeedInsecureRand(false);
  
      #if defined(PRINT_SIGHASH_JSON)
          std::cout << "[\n";
          std::cout << "\t[\"raw_transaction, script, input_index, hashType, signature_hash (result)\"],\n";
          int nRandomTests = 500;
      #else
          int nRandomTests = 50000;
      #endif
          for (int i = 0; i < nRandomTests; i++)
          {
              int nHashType = InsecureRand32();
              CMutableTransaction txTo;
              RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
              CScript scriptCode;
              RandomScript(scriptCode);
              int nIn = InsecureRandRange(txTo.vin.size());
  
              uint256 sh, sho;
              sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
              sh = SignatureHash(scriptCode, txTo, nIn, nHashType, 0, SIGVERSION_BASE);
      #if defined(PRINT_SIGHASH_JSON)
              CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
              ss << txTo;
  
              std::cout << "\t[\"" ;
              std::cout << HexStr(ss.begin(), ss.end()) << "\", \"";
              std::cout << HexStr(scriptCode) << "\", ";
              std::cout << nIn << ", ";
              std::cout << nHashType << ", \"";
              std::cout << sho.GetHex() << "\"]";
              if (i+1 != nRandomTests) {
                std::cout << ",";
              }
              std::cout << "\n";
      #endif
              BOOST_CHECK(sh == sho);
          }
      #if defined(PRINT_SIGHASH_JSON)
          std::cout << "]\n";
      #endif
      }
  
      // Goal: check that signature_hash generates correct hash
      BOOST_AUTO_TEST_CASE(sighash_from_data_test)
      {
          BOOST_TEST_MESSAGE("Running SigHas From Data Test");
  
          UniValue tests = read_json(std::string(json_tests::sighash, json_tests::sighash + sizeof(json_tests::sighash)));
  
          for (unsigned int idx = 0; idx < tests.size(); idx++)
          {
              UniValue test = tests[idx];
              std::string strTest = test.write();
              if (test.size() < 1) // Allow for extra stuff (useful for comments)
              {
                  BOOST_ERROR("Bad test: " << strTest);
                  continue;
              }
              if (test.size() == 1) continue; // comment
  
              std::string raw_tx, raw_script, sigHashHex;
              int nIn, nHashType;
              uint256 sh;
              CTransactionRef tx;
              CScript scriptCode = CScript();
  
              try
              {
                  // deserialize test data
                  raw_tx = test[0].get_str();
                  raw_script = test[1].get_str();
                  nIn = test[2].get_int();
                  nHashType = test[3].get_int();
                  sigHashHex = test[4].get_str();
  
                  CDataStream stream(ParseHex(raw_tx), SER_NETWORK, PROTOCOL_VERSION);
                  stream >> tx;
  
                  CValidationState state;
                  BOOST_CHECK_MESSAGE(CheckTransaction(*tx, state), strTest);
                  BOOST_CHECK(state.IsValid());
  
                  std::vector<unsigned char> raw = ParseHex(raw_script);
                  scriptCode.insert(scriptCode.end(), raw.begin(), raw.end());
              } catch (...)
              {
                  BOOST_ERROR("Bad test, couldn't deserialize data: " << strTest);
                  continue;
              }
  
              sh = SignatureHash(scriptCode, *tx, nIn, nHashType, 0, SIGVERSION_BASE);
              BOOST_CHECK_MESSAGE(sh.GetHex() == sigHashHex, strTest);
          }
      }
  
  BOOST_AUTO_TEST_SUITE_END()
  