diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index a004d0be2..e070478c1 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -1,881 +1,881 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 
 #include <chainparams.h>
 #include <clientversion.h>
 #include <coins.h>
 #include <consensus/consensus.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <keystore.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #include <boost/algorithm/string.hpp>
 
 #include <univalue.h>
 
 #include <cstdio>
 
 static bool fCreateBlank;
 static std::map<std::string, UniValue> registers;
 static const int CONTINUE_EXECUTION = -1;
 
 const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
 
 static void SetupBitcoinTxArgs() {
     gArgs.AddArg("-?", _("This help message"), false, OptionsCategory::OPTIONS);
     gArgs.AddArg("-create", _("Create new, empty TX."), false,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-json", _("Select JSON output"), false,
                  OptionsCategory::OPTIONS);
     gArgs.AddArg("-txid",
                  _("Output only the hex-encoded transaction id of the "
                    "resultant transaction."),
                  false, OptionsCategory::OPTIONS);
     SetupChainParamsBaseOptions();
 
     gArgs.AddArg("delin=N", _("Delete input N from TX"), false,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("delout=N", _("Delete output N from TX"), false,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", _("Add input to TX"), false,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("locktime=N", _("Set TX lock time to N"), false,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("nversion=N", _("Set TX version to N"), false,
                  OptionsCategory::COMMANDS);
     gArgs.AddArg("outaddr=VALUE:ADDRESS", _("Add address-based output to TX"),
                  false, OptionsCategory::COMMANDS);
     gArgs.AddArg("outpubkey=VALUE:PUBKEY[:FLAGS]",
                  _("Add pay-to-pubkey output to TX") + ". " +
                      _("Optionally add the \"S\" flag to wrap the output in a "
                        "pay-to-script-hash."),
                  false, OptionsCategory::COMMANDS);
     gArgs.AddArg("outdata=[VALUE:]DATA", _("Add data-based output to TX"),
                  false, OptionsCategory::COMMANDS);
     gArgs.AddArg("outscript=VALUE:SCRIPT[:FLAGS]",
                  _("Add raw script output to TX") + ". " +
                      _("Optionally add the \"S\" flag to wrap the output in a "
                        "pay-to-script-hash."),
                  false, OptionsCategory::COMMANDS);
     gArgs.AddArg(
         "outmultisig=VALUE:REQUIRED:PUBKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]",
         _("Add Pay To n-of-m Multi-sig output to TX. n = REQUIRED, m = "
           "PUBKEYS") +
             ". " +
             _("Optionally add the \"S\" flag to wrap the output in a "
               "pay-to-script-hash."),
         false, OptionsCategory::COMMANDS);
     gArgs.AddArg("sign=SIGHASH-FLAGS",
                  _("Add zero or more signatures to transaction") + ". " +
                      _("This command requires JSON registers:") +
                      _("prevtxs=JSON object") + ", " +
                      _("privatekeys=JSON object") + ". " +
                      _("See signrawtransactionwithkey docs for format of "
                        "sighash flags, JSON objects."),
                  false, OptionsCategory::COMMANDS);
 
     gArgs.AddArg("load=NAME:FILENAME",
                  _("Load JSON file FILENAME into register NAME"), false,
                  OptionsCategory::REGISTER_COMMANDS);
     gArgs.AddArg("set=NAME:JSON-STRING",
                  _("Set register NAME to given JSON-STRING"), false,
                  OptionsCategory::REGISTER_COMMANDS);
 
     // Hidden
     gArgs.AddArg("-h", "", false, OptionsCategory::HIDDEN);
     gArgs.AddArg("-help", "", false, OptionsCategory::HIDDEN);
 }
 
 //
 // This function returns either one of EXIT_ codes when it's expected to stop
 // the process or CONTINUE_EXECUTION when it's expected to continue further.
 //
 static int AppInitRawTx(int argc, char *argv[]) {
     //
     // Parameters
     //
     SetupBitcoinTxArgs();
     std::string error;
     if (!gArgs.ParseParameters(argc, argv, error)) {
         fprintf(stderr, "Error parsing command line arguments: %s\n",
                 error.c_str());
         return EXIT_FAILURE;
     }
 
     // Check for -testnet or -regtest parameter (Params() calls are only valid
     // after this clause)
     try {
         SelectParams(gArgs.GetChainName());
     } catch (const std::exception &e) {
         fprintf(stderr, "Error: %s\n", e.what());
         return EXIT_FAILURE;
     }
 
     fCreateBlank = gArgs.GetBoolArg("-create", false);
 
     if (argc < 2 || HelpRequested(gArgs)) {
         // First part of help message is specific to this utility
         std::string strUsage =
             PACKAGE_NAME " bitcoin-tx utility version " + FormatFullVersion() +
             "\n\n" +
             "Usage:  bitcoin-tx [options] <hex-tx> [commands]  Update "
             "hex-encoded bitcoin transaction\n" +
             "or:     bitcoin-tx [options] -create [commands]   Create "
             "hex-encoded bitcoin transaction\n" +
             "\n";
 
         strUsage += gArgs.GetHelpMessage();
         fprintf(stdout, "%s", strUsage.c_str());
 
         if (argc < 2) {
             fprintf(stderr, "Error: too few parameters\n");
             return EXIT_FAILURE;
         }
 
         return EXIT_SUCCESS;
     }
 
     return CONTINUE_EXECUTION;
 }
 
 static void RegisterSetJson(const std::string &key,
                             const std::string &rawJson) {
     UniValue val;
     if (!val.read(rawJson)) {
         std::string strErr = "Cannot parse JSON for key " + key;
         throw std::runtime_error(strErr);
     }
 
     registers[key] = val;
 }
 
 static void RegisterSet(const std::string &strInput) {
     // separate NAME:VALUE in string
     size_t pos = strInput.find(':');
     if ((pos == std::string::npos) || (pos == 0) ||
         (pos == (strInput.size() - 1))) {
         throw std::runtime_error("Register input requires NAME:VALUE");
     }
 
     std::string key = strInput.substr(0, pos);
     std::string valStr = strInput.substr(pos + 1, std::string::npos);
 
     RegisterSetJson(key, valStr);
 }
 
 static void RegisterLoad(const std::string &strInput) {
     // separate NAME:FILENAME in string
     size_t pos = strInput.find(':');
     if ((pos == std::string::npos) || (pos == 0) ||
         (pos == (strInput.size() - 1))) {
         throw std::runtime_error("Register load requires NAME:FILENAME");
     }
 
     std::string key = strInput.substr(0, pos);
     std::string filename = strInput.substr(pos + 1, std::string::npos);
 
     FILE *f = fopen(filename.c_str(), "r");
     if (!f) {
         std::string strErr = "Cannot open file " + filename;
         throw std::runtime_error(strErr);
     }
 
     // load file chunks into one big buffer
     std::string valStr;
     while ((!feof(f)) && (!ferror(f))) {
         char buf[4096];
         int bread = fread(buf, 1, sizeof(buf), f);
         if (bread <= 0) {
             break;
         }
 
         valStr.insert(valStr.size(), buf, bread);
     }
 
     int error = ferror(f);
     fclose(f);
 
     if (error) {
         std::string strErr = "Error reading file " + filename;
         throw std::runtime_error(strErr);
     }
 
     // evaluate as JSON buffer register
     RegisterSetJson(key, valStr);
 }
 
 static Amount ExtractAndValidateValue(const std::string &strValue) {
     Amount value;
     if (!ParseMoney(strValue, value)) {
         throw std::runtime_error("invalid TX output value");
     }
 
     return value;
 }
 
 static void MutateTxVersion(CMutableTransaction &tx,
                             const std::string &cmdVal) {
     int64_t newVersion = atoi64(cmdVal);
     if (newVersion < 1 || newVersion > CTransaction::MAX_STANDARD_VERSION) {
         throw std::runtime_error("Invalid TX version requested");
     }
 
     tx.nVersion = int(newVersion);
 }
 
 static void MutateTxLocktime(CMutableTransaction &tx,
                              const std::string &cmdVal) {
     int64_t newLocktime = atoi64(cmdVal);
     if (newLocktime < 0LL || newLocktime > 0xffffffffLL) {
         throw std::runtime_error("Invalid TX locktime requested");
     }
 
     tx.nLockTime = (unsigned int)newLocktime;
 }
 
 static void MutateTxAddInput(CMutableTransaction &tx,
                              const std::string &strInput) {
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     // separate TXID:VOUT in string
     if (vStrInputParts.size() < 2) {
         throw std::runtime_error("TX input missing separator");
     }
 
     // extract and validate TXID
     std::string strTxid = vStrInputParts[0];
     if ((strTxid.size() != 64) || !IsHex(strTxid)) {
         throw std::runtime_error("invalid TX input txid");
     }
 
     TxId txid(uint256S(strTxid));
 
     static const unsigned int minTxOutSz = 9;
     static const unsigned int maxVout = MAX_TX_SIZE / minTxOutSz;
 
     // extract and validate vout
     std::string strVout = vStrInputParts[1];
     int vout = atoi(strVout);
     if ((vout < 0) || (vout > (int)maxVout)) {
         throw std::runtime_error("invalid TX input vout");
     }
 
     // extract the optional sequence number
     uint32_t nSequenceIn = std::numeric_limits<unsigned int>::max();
     if (vStrInputParts.size() > 2) {
         nSequenceIn = std::stoul(vStrInputParts[2]);
     }
 
     // append to transaction input list
     CTxIn txin(txid, vout, CScript(), nSequenceIn);
     tx.vin.push_back(txin);
 }
 
 static void MutateTxAddOutAddr(CMutableTransaction &tx,
                                const std::string &strInput,
                                const CChainParams &chainParams) {
     // Separate into VALUE:ADDRESS
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     if (vStrInputParts.size() != 2) {
         throw std::runtime_error("TX output missing or too many separators");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // extract and validate ADDRESS
     std::string strAddr = vStrInputParts[1];
     CTxDestination destination = DecodeDestination(strAddr, chainParams);
     if (!IsValidDestination(destination)) {
         throw std::runtime_error("invalid TX output address");
     }
     CScript scriptPubKey = GetScriptForDestination(destination);
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutPubKey(CMutableTransaction &tx,
                                  const std::string &strInput) {
     // Separate into VALUE:PUBKEY[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     if (vStrInputParts.size() < 2 || vStrInputParts.size() > 3) {
         throw std::runtime_error("TX output missing or too many separators");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // Extract and validate PUBKEY
     CPubKey pubkey(ParseHex(vStrInputParts[1]));
     if (!pubkey.IsFullyValid()) {
         throw std::runtime_error("invalid TX output pubkey");
     }
 
     CScript scriptPubKey = GetScriptForRawPubKey(pubkey);
 
     // Extract and validate FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == 3) {
         std::string flags = vStrInputParts[2];
         bScriptHash = (flags.find('S') != std::string::npos);
     }
 
     if (bScriptHash) {
         // Get the ID for the script, and then construct a P2SH destination for
         // it.
         scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutMultiSig(CMutableTransaction &tx,
                                    const std::string &strInput) {
     // Separate into VALUE:REQUIRED:NUMKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
     // Check that there are enough parameters
     if (vStrInputParts.size() < 3) {
         throw std::runtime_error("Not enough multisig parameters");
     }
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // Extract REQUIRED
     uint32_t required = stoul(vStrInputParts[1]);
 
     // Extract NUMKEYS
     uint32_t numkeys = stoul(vStrInputParts[2]);
 
     // Validate there are the correct number of pubkeys
     if (vStrInputParts.size() < numkeys + 3) {
         throw std::runtime_error("incorrect number of multisig pubkeys");
     }
 
     if (required < 1 || required > 20 || numkeys < 1 || numkeys > 20 ||
         numkeys < required) {
         throw std::runtime_error("multisig parameter mismatch. Required " +
                                  std::to_string(required) + " of " +
                                  std::to_string(numkeys) + "signatures.");
     }
 
     // extract and validate PUBKEYs
     std::vector<CPubKey> pubkeys;
     for (int pos = 1; pos <= int(numkeys); pos++) {
         CPubKey pubkey(ParseHex(vStrInputParts[pos + 2]));
         if (!pubkey.IsFullyValid()) {
             throw std::runtime_error("invalid TX output pubkey");
         }
 
         pubkeys.push_back(pubkey);
     }
 
     // Extract FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == numkeys + 4) {
         std::string flags = vStrInputParts.back();
         bScriptHash = (flags.find('S') != std::string::npos);
     } else if (vStrInputParts.size() > numkeys + 4) {
         // Validate that there were no more parameters passed
         throw std::runtime_error("Too many parameters");
     }
 
     CScript scriptPubKey = GetScriptForMultisig(required, pubkeys);
 
     if (bScriptHash) {
         // Get the ID for the script, and then construct a P2SH destination for
         // it.
         scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutData(CMutableTransaction &tx,
                                const std::string &strInput) {
     Amount value = Amount::zero();
 
     // separate [VALUE:]DATA in string
     size_t pos = strInput.find(':');
 
     if (pos == 0) {
         throw std::runtime_error("TX output value not specified");
     }
 
     if (pos != std::string::npos) {
         // Extract and validate VALUE
         value = ExtractAndValidateValue(strInput.substr(0, pos));
     }
 
     // extract and validate DATA
     std::string strData = strInput.substr(pos + 1, std::string::npos);
 
     if (!IsHex(strData)) {
         throw std::runtime_error("invalid TX output data");
     }
 
     std::vector<uint8_t> data = ParseHex(strData);
 
     CTxOut txout(value, CScript() << OP_RETURN << data);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxAddOutScript(CMutableTransaction &tx,
                                  const std::string &strInput) {
     // separate VALUE:SCRIPT[:FLAGS]
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
     if (vStrInputParts.size() < 2)
         throw std::runtime_error("TX output missing separator");
 
     // Extract and validate VALUE
     Amount value = ExtractAndValidateValue(vStrInputParts[0]);
 
     // extract and validate script
     std::string strScript = vStrInputParts[1];
     CScript scriptPubKey = ParseScript(strScript);
 
     // Extract FLAGS
     bool bScriptHash = false;
     if (vStrInputParts.size() == 3) {
         std::string flags = vStrInputParts.back();
         bScriptHash = (flags.find('S') != std::string::npos);
     }
 
     if (bScriptHash) {
         scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
     CTxOut txout(value, scriptPubKey);
     tx.vout.push_back(txout);
 }
 
 static void MutateTxDelInput(CMutableTransaction &tx,
                              const std::string &strInIdx) {
     // parse requested deletion index
     int inIdx = atoi(strInIdx);
     if (inIdx < 0 || inIdx >= (int)tx.vin.size()) {
         std::string strErr = "Invalid TX input index '" + strInIdx + "'";
         throw std::runtime_error(strErr.c_str());
     }
 
     // delete input from transaction
     tx.vin.erase(tx.vin.begin() + inIdx);
 }
 
 static void MutateTxDelOutput(CMutableTransaction &tx,
                               const std::string &strOutIdx) {
     // parse requested deletion index
     int outIdx = atoi(strOutIdx);
     if (outIdx < 0 || outIdx >= (int)tx.vout.size()) {
         std::string strErr = "Invalid TX output index '" + strOutIdx + "'";
         throw std::runtime_error(strErr.c_str());
     }
 
     // delete output from transaction
     tx.vout.erase(tx.vout.begin() + outIdx);
 }
 
 static const unsigned int N_SIGHASH_OPTS = 12;
 static const struct {
     const char *flagStr;
     int flags;
 } sigHashOptions[N_SIGHASH_OPTS] = {
     {"ALL", SIGHASH_ALL},
     {"NONE", SIGHASH_NONE},
     {"SINGLE", SIGHASH_SINGLE},
     {"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
     {"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
     {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
     {"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
     {"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
     {"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
     {"ALL|FORKID|ANYONECANPAY",
      SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
     {"NONE|FORKID|ANYONECANPAY",
      SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
     {"SINGLE|FORKID|ANYONECANPAY",
      SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
 };
 
 static bool findSigHashFlags(SigHashType &sigHashType,
                              const std::string &flagStr) {
     sigHashType = SigHashType();
 
     for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
         if (flagStr == sigHashOptions[i].flagStr) {
             sigHashType = SigHashType(sigHashOptions[i].flags);
             return true;
         }
     }
 
     return false;
 }
 
 static Amount AmountFromValue(const UniValue &value) {
     if (!value.isNum() && !value.isStr()) {
         throw std::runtime_error("Amount is not a number or string");
     }
 
     int64_t n;
     if (!ParseFixedPoint(value.getValStr(), 8, &n)) {
         throw std::runtime_error("Invalid amount");
     }
     Amount amount = n * SATOSHI;
 
     if (!MoneyRange(amount)) {
         throw std::runtime_error("Amount out of range");
     }
 
     return amount;
 }
 
 static void MutateTxSign(CMutableTransaction &tx, const std::string &flagStr) {
     SigHashType sigHashType = SigHashType().withForkId();
 
     if ((flagStr.size() > 0) && !findSigHashFlags(sigHashType, flagStr)) {
         throw std::runtime_error("unknown sighash flag/sign option");
     }
 
     // mergedTx will end up with all the signatures; it
     // starts as a clone of the raw tx:
     CMutableTransaction mergedTx{tx};
     const CMutableTransaction txv{tx};
 
     CCoinsView viewDummy;
     CCoinsViewCache view(&viewDummy);
 
     if (!registers.count("privatekeys")) {
         throw std::runtime_error("privatekeys register variable must be set.");
     }
 
     CBasicKeyStore tempKeystore;
     UniValue keysObj = registers["privatekeys"];
 
     for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {
         if (!keysObj[kidx].isStr()) {
             throw std::runtime_error("privatekey not a std::string");
         }
 
         CKey key = DecodeSecret(keysObj[kidx].getValStr());
         if (!key.IsValid()) {
             throw std::runtime_error("privatekey not valid");
         }
         tempKeystore.AddKey(key);
     }
 
     // Add previous txouts given in the RPC call:
     if (!registers.count("prevtxs")) {
         throw std::runtime_error("prevtxs register variable must be set.");
     }
 
     UniValue prevtxsObj = registers["prevtxs"];
 
     for (unsigned int previdx = 0; previdx < prevtxsObj.size(); previdx++) {
         UniValue prevOut = prevtxsObj[previdx];
         if (!prevOut.isObject()) {
             throw std::runtime_error("expected prevtxs internal object");
         }
 
         std::map<std::string, UniValue::VType> types = {
             {"txid", UniValue::VSTR},
             {"vout", UniValue::VNUM},
             {"scriptPubKey", UniValue::VSTR}};
         if (!prevOut.checkObject(types)) {
             throw std::runtime_error("prevtxs internal object typecheck fail");
         }
 
-        TxId txid(ParseHashUV(prevOut["txid"], "txid"));
+        TxId txid(ParseHashStr(prevOut["txid"].get_str(), "txid"));
 
         int nOut = atoi(prevOut["vout"].getValStr());
         if (nOut < 0) {
             throw std::runtime_error("vout must be positive");
         }
 
         COutPoint out(txid, nOut);
         std::vector<uint8_t> pkData(
             ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
         CScript scriptPubKey(pkData.begin(), pkData.end());
 
         {
             const Coin &coin = view.AccessCoin(out);
             if (!coin.IsSpent() &&
                 coin.GetTxOut().scriptPubKey != scriptPubKey) {
                 std::string err("Previous output scriptPubKey mismatch:\n");
                 err = err + ScriptToAsmStr(coin.GetTxOut().scriptPubKey) +
                       "\nvs:\n" + ScriptToAsmStr(scriptPubKey);
                 throw std::runtime_error(err);
             }
 
             CTxOut txout;
             txout.scriptPubKey = scriptPubKey;
             txout.nValue = Amount::zero();
             if (prevOut.exists("amount")) {
                 txout.nValue = AmountFromValue(prevOut["amount"]);
             }
 
             view.AddCoin(out, Coin(txout, 1, false), true);
         }
 
         // If redeemScript given and private keys given, add redeemScript to the
         // tempKeystore so it can be signed:
         if (scriptPubKey.IsPayToScriptHash() &&
             prevOut.exists("redeemScript")) {
             UniValue v = prevOut["redeemScript"];
             std::vector<uint8_t> rsData(ParseHexUV(v, "redeemScript"));
             CScript redeemScript(rsData.begin(), rsData.end());
             tempKeystore.AddCScript(redeemScript);
         }
     }
 
     const CKeyStore &keystore = tempKeystore;
 
     // Sign what we can:
     for (size_t i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn &txin = mergedTx.vin[i];
         const Coin &coin = view.AccessCoin(txin.prevout);
         if (coin.IsSpent()) {
             continue;
         }
 
         const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
         const Amount amount = coin.GetTxOut().nValue;
 
         SignatureData sigdata =
             DataFromTransaction(mergedTx, i, coin.GetTxOut());
         // Only sign SIGHASH_SINGLE if there's a corresponding output:
         if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) ||
             (i < mergedTx.vout.size())) {
             ProduceSignature(keystore,
                              MutableTransactionSignatureCreator(
                                  &mergedTx, i, amount, sigHashType),
                              prevPubKey, sigdata);
         }
 
         UpdateInput(txin, sigdata);
     }
 
     tx = mergedTx;
 }
 
 class Secp256k1Init {
     ECCVerifyHandle globalVerifyHandle;
 
 public:
     Secp256k1Init() { ECC_Start(); }
     ~Secp256k1Init() { ECC_Stop(); }
 };
 
 static void MutateTx(CMutableTransaction &tx, const std::string &command,
                      const std::string &commandVal,
                      const CChainParams &chainParams) {
     std::unique_ptr<Secp256k1Init> ecc;
 
     if (command == "nversion") {
         MutateTxVersion(tx, commandVal);
     } else if (command == "locktime") {
         MutateTxLocktime(tx, commandVal);
     } else if (command == "delin") {
         MutateTxDelInput(tx, commandVal);
     } else if (command == "in") {
         MutateTxAddInput(tx, commandVal);
     } else if (command == "delout") {
         MutateTxDelOutput(tx, commandVal);
     } else if (command == "outaddr") {
         MutateTxAddOutAddr(tx, commandVal, chainParams);
     } else if (command == "outpubkey") {
         ecc.reset(new Secp256k1Init());
         MutateTxAddOutPubKey(tx, commandVal);
     } else if (command == "outmultisig") {
         ecc.reset(new Secp256k1Init());
         MutateTxAddOutMultiSig(tx, commandVal);
     } else if (command == "outscript") {
         MutateTxAddOutScript(tx, commandVal);
     } else if (command == "outdata") {
         MutateTxAddOutData(tx, commandVal);
     } else if (command == "sign") {
         ecc.reset(new Secp256k1Init());
         MutateTxSign(tx, commandVal);
     } else if (command == "load") {
         RegisterLoad(commandVal);
     } else if (command == "set") {
         RegisterSet(commandVal);
     } else {
         throw std::runtime_error("unknown command");
     }
 }
 
 static void OutputTxJSON(const CTransaction &tx) {
     UniValue entry(UniValue::VOBJ);
     TxToUniv(tx, uint256(), entry);
 
     std::string jsonOutput = entry.write(4);
     fprintf(stdout, "%s\n", jsonOutput.c_str());
 }
 
 static void OutputTxHash(const CTransaction &tx) {
     // the hex-encoded transaction id.
     std::string strHexHash = tx.GetId().GetHex();
 
     fprintf(stdout, "%s\n", strHexHash.c_str());
 }
 
 static void OutputTxHex(const CTransaction &tx) {
     std::string strHex = EncodeHexTx(tx);
 
     fprintf(stdout, "%s\n", strHex.c_str());
 }
 
 static void OutputTx(const CTransaction &tx) {
     if (gArgs.GetBoolArg("-json", false)) {
         OutputTxJSON(tx);
     } else if (gArgs.GetBoolArg("-txid", false)) {
         OutputTxHash(tx);
     } else {
         OutputTxHex(tx);
     }
 }
 
 static std::string readStdin() {
     char buf[4096];
     std::string ret;
 
     while (!feof(stdin)) {
         size_t bread = fread(buf, 1, sizeof(buf), stdin);
         ret.append(buf, bread);
         if (bread < sizeof(buf)) {
             break;
         }
     }
 
     if (ferror(stdin)) {
         throw std::runtime_error("error reading stdin");
     }
 
     boost::algorithm::trim_right(ret);
 
     return ret;
 }
 
 static int CommandLineRawTx(int argc, char *argv[],
                             const CChainParams &chainParams) {
     std::string strPrint;
     int nRet = 0;
     try {
         // Skip switches; Permit common stdin convention "-"
         while (argc > 1 && IsSwitchChar(argv[1][0]) && (argv[1][1] != 0)) {
             argc--;
             argv++;
         }
 
         CMutableTransaction tx;
         int startArg;
 
         if (!fCreateBlank) {
             // require at least one param
             if (argc < 2) {
                 throw std::runtime_error("too few parameters");
             }
 
             // param: hex-encoded bitcoin transaction
             std::string strHexTx(argv[1]);
 
             // "-" implies standard input
             if (strHexTx == "-") {
                 strHexTx = readStdin();
             }
 
             if (!DecodeHexTx(tx, strHexTx)) {
                 throw std::runtime_error("invalid transaction encoding");
             }
 
             startArg = 2;
         } else {
             startArg = 1;
         }
 
         for (int i = startArg; i < argc; i++) {
             std::string arg = argv[i];
             std::string key, value;
             size_t eqpos = arg.find('=');
             if (eqpos == std::string::npos) {
                 key = arg;
             } else {
                 key = arg.substr(0, eqpos);
                 value = arg.substr(eqpos + 1);
             }
 
             MutateTx(tx, key, value, chainParams);
         }
 
         OutputTx(CTransaction(tx));
     }
 
     catch (const boost::thread_interrupted &) {
         throw;
     } catch (const std::exception &e) {
         strPrint = std::string("error: ") + e.what();
         nRet = EXIT_FAILURE;
     } catch (...) {
         PrintExceptionContinue(nullptr, "CommandLineRawTx()");
         throw;
     }
 
     if (strPrint != "") {
         fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
     }
 
     return nRet;
 }
 
 int main(int argc, char *argv[]) {
     SetupEnvironment();
 
     try {
         int ret = AppInitRawTx(argc, argv);
         if (ret != CONTINUE_EXECUTION) return ret;
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "AppInitRawTx()");
         return EXIT_FAILURE;
     } catch (...) {
         PrintExceptionContinue(nullptr, "AppInitRawTx()");
         return EXIT_FAILURE;
     }
 
     int ret = EXIT_FAILURE;
     try {
         ret = CommandLineRawTx(argc, argv, Params());
     } catch (const std::exception &e) {
         PrintExceptionContinue(&e, "CommandLineRawTx()");
     } catch (...) {
         PrintExceptionContinue(nullptr, "CommandLineRawTx()");
     }
 
     return ret;
 }
diff --git a/src/core_io.h b/src/core_io.h
index cd2977e17..365a3b9cc 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -1,40 +1,39 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_CORE_IO_H
 #define BITCOIN_CORE_IO_H
 
 #include <string>
 #include <vector>
 
 struct Amount;
 class CBlock;
 class CBlockHeader;
 class CMutableTransaction;
 class CScript;
 class CTransaction;
 class uint256;
 class UniValue;
 
 // core_read.cpp
 CScript ParseScript(const std::string &s);
 std::string ScriptToAsmStr(const CScript &script,
                            const bool fAttemptSighashDecode = false);
 bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx);
 bool DecodeHexBlk(CBlock &, const std::string &strHexBlk);
 bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header);
-uint256 ParseHashUV(const UniValue &v, const std::string &strName);
 uint256 ParseHashStr(const std::string &, const std::string &strName);
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName);
 
 // core_write.cpp
 UniValue ValueFromAmount(const Amount &amount);
 std::string FormatScript(const CScript &script);
 std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags = 0);
 void ScriptPubKeyToUniv(const CScript &scriptPubKey, UniValue &out,
                         bool fIncludeHex);
 void TxToUniv(const CTransaction &tx, const uint256 &hashBlock, UniValue &entry,
               bool include_hex = true, int serialize_flags = 0);
 
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/core_read.cpp b/src/core_read.cpp
index 52d8d5f9f..be443c26f 100644
--- a/src/core_read.cpp
+++ b/src/core_read.cpp
@@ -1,267 +1,257 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <core_io.h>
 
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <version.h>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
 
 #include <univalue.h>
 
 CScript ParseScript(const std::string &s) {
     CScript result;
 
     static std::map<std::string, opcodetype> mapOpNames;
 
     if (mapOpNames.empty()) {
         for (int op = 0; op < FIRST_UNDEFINED_OP_VALUE; op++) {
             if (op < OP_PUSHDATA1) {
                 continue;
             }
 
             const char *name = GetOpName(static_cast<opcodetype>(op));
             if (strcmp(name, "OP_UNKNOWN") == 0) {
                 continue;
             }
 
             std::string strName(name);
             mapOpNames[strName] = static_cast<opcodetype>(op);
             // Convenience: OP_ADD and just ADD are both recognized:
             boost::algorithm::replace_first(strName, "OP_", "");
             mapOpNames[strName] = static_cast<opcodetype>(op);
         }
     }
 
     std::vector<std::string> words;
     boost::algorithm::split(words, s, boost::algorithm::is_any_of(" \t\n"),
                             boost::algorithm::token_compress_on);
 
     size_t push_size = 0, next_push_size = 0;
     size_t script_size = 0;
     // Deal with PUSHDATA1 operation with some more hacks.
     size_t push_data_size = 0;
 
     for (const auto &w : words) {
         if (w.empty()) {
             // Empty string, ignore. (boost::split given '' will return one
             // word)
             continue;
         }
 
         // Update script size.
         script_size = result.size();
 
         // Make sure we keep track of the size of push operations.
         push_size = next_push_size;
         next_push_size = 0;
 
         // Decimal numbers
         if (all(w, boost::algorithm::is_digit()) ||
             (boost::algorithm::starts_with(w, "-") &&
              all(std::string(w.begin() + 1, w.end()),
                  boost::algorithm::is_digit()))) {
             // Number
             int64_t n = atoi64(w);
             result << n;
             goto next;
         }
 
         // Hex Data
         if (boost::algorithm::starts_with(w, "0x") &&
             (w.begin() + 2 != w.end())) {
             if (!IsHex(std::string(w.begin() + 2, w.end()))) {
                 // Should only arrive here for improperly formatted hex values
                 throw std::runtime_error("Hex numbers expected to be formatted "
                                          "in full-byte chunks (ex: 0x00 "
                                          "instead of 0x0)");
             }
 
             // Raw hex data, inserted NOT pushed onto stack:
             std::vector<uint8_t> raw =
                 ParseHex(std::string(w.begin() + 2, w.end()));
 
             result.insert(result.end(), raw.begin(), raw.end());
             goto next;
         }
 
         if (w.size() >= 2 && boost::algorithm::starts_with(w, "'") &&
             boost::algorithm::ends_with(w, "'")) {
             // Single-quoted string, pushed as data. NOTE: this is poor-man's
             // parsing, spaces/tabs/newlines in single-quoted strings won't
             // work.
             std::vector<uint8_t> value(w.begin() + 1, w.end() - 1);
             result << value;
             goto next;
         }
 
         if (mapOpNames.count(w)) {
             // opcode, e.g. OP_ADD or ADD:
             opcodetype op = mapOpNames[w];
 
             result << op;
             goto next;
         }
 
         throw std::runtime_error("Error parsing script: " + s);
 
     next:
         size_t size_change = result.size() - script_size;
 
         // If push_size is set, ensure have added the right amount of stuff.
         if (push_size != 0 && size_change != push_size) {
             throw std::runtime_error(
                 "Wrong number of bytes being pushed. Expected:" +
                 std::to_string(push_size) +
                 " Pushed:" + std::to_string(size_change));
         }
 
         // If push_size is set, and we have push_data_size set, then we have a
         // PUSHDATAX opcode.  We need to read it's push size as a LE value for
         // the next iteration of this loop.
         if (push_size != 0 && push_data_size != 0) {
             auto offset = &result[script_size];
 
             // Push data size is not a CScriptNum (Because it is
             // 2's-complement instead of 1's complement).  We need to use
             // ReadLE(N) instead of converting to a CScriptNum.
             if (push_data_size == 1) {
                 next_push_size = *offset;
             } else if (push_data_size == 2) {
                 next_push_size = ReadLE16(offset);
             } else if (push_data_size == 4) {
                 next_push_size = ReadLE32(offset);
             }
 
             push_data_size = 0;
         }
 
         // If push_size is unset, but size_change is 1, that means we have an
         // opcode in the form of `0x00` or <opcodename>.  We will check to see
         // if it is a push operation and set state accordingly
         if (push_size == 0 && size_change == 1) {
             opcodetype op = opcodetype(*result.rbegin());
 
             // If we have what looks like an immediate push, figure out its
             // size.
             if (op < OP_PUSHDATA1) {
                 next_push_size = op;
                 continue;
             }
 
             switch (op) {
                 case OP_PUSHDATA1:
                     push_data_size = next_push_size = 1;
                     break;
                 case OP_PUSHDATA2:
                     push_data_size = next_push_size = 2;
                     break;
                 case OP_PUSHDATA4:
                     push_data_size = next_push_size = 4;
                     break;
                 default:
                     break;
             }
         }
     }
 
     return result;
 }
 
 bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx) {
     if (!IsHex(strHexTx)) {
         return false;
     }
 
     std::vector<uint8_t> txData(ParseHex(strHexTx));
 
     CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ssData >> tx;
         if (!ssData.empty()) {
             return false;
         }
     } catch (const std::exception &) {
         return false;
     }
 
     return true;
 }
 
 bool DecodeHexBlockHeader(CBlockHeader &header, const std::string &hex_header) {
     if (!IsHex(hex_header)) {
         return false;
     }
 
     const std::vector<uint8_t> header_data{ParseHex(hex_header)};
     CDataStream ser_header(header_data, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ser_header >> header;
     } catch (const std::exception &) {
         return false;
     }
     return true;
 }
 
 bool DecodeHexBlk(CBlock &block, const std::string &strHexBlk) {
     if (!IsHex(strHexBlk)) {
         return false;
     }
 
     std::vector<uint8_t> blockData(ParseHex(strHexBlk));
     CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
     try {
         ssBlock >> block;
     } catch (const std::exception &) {
         return false;
     }
 
     return true;
 }
 
-uint256 ParseHashUV(const UniValue &v, const std::string &strName) {
-    std::string strHex;
-    if (v.isStr()) {
-        strHex = v.getValStr();
-    }
-
-    // Note: ParseHashStr("") throws a runtime_error
-    return ParseHashStr(strHex, strName);
-}
-
 uint256 ParseHashStr(const std::string &strHex, const std::string &strName) {
     if (!IsHex(strHex)) {
         // Note: IsHex("") is false
         throw std::runtime_error(
             strName + " must be hexadecimal string (not '" + strHex + "')");
     }
 
     uint256 result;
     result.SetHex(strHex);
     return result;
 }
 
 std::vector<uint8_t> ParseHexUV(const UniValue &v, const std::string &strName) {
     std::string strHex;
     if (v.isStr()) {
         strHex = v.getValStr();
     }
 
     if (!IsHex(strHex)) {
         throw std::runtime_error(
             strName + " must be hexadecimal string (not '" + strHex + "')");
     }
 
     return ParseHex(strHex);
 }