src/bitcoin-tx.cpp

   1 // Copyright (c) 2009-2014 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "base58.h"
   6 #include "clientversion.h"
   7 #include "coins.h"
   8 #include "consensus/consensus.h"
   9 #include "core_io.h"
  10 #include "keystore.h"
  11 #include "primitives/transaction.h"
  12 #include "script/script.h"
  13 #include "script/sign.h"
  14 #include "univalue/univalue.h"
  15 #include "util.h"
  16 #include "utilmoneystr.h"
  17 #include "utilstrencodings.h"
  18
  19 #include <stdio.h>
  20
  21 #include <boost/algorithm/string.hpp>
  22 #include <boost/assign/list_of.hpp>
  23
  24 using namespace std;
  25
  26 static bool fCreateBlank;
  27 static map<string,UniValue> registers;
  28
  29 static bool AppInitRawTx(int argc, char* argv[])
  30 {
  31     //
  32     // Parameters
  33     //
  34     ParseParameters(argc, argv);
  35
  36     // Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
  37     if (!SelectParamsFromCommandLine()) {
  38         fprintf(stderr, "Error: Invalid combination of -regtest and -testnet.\n");
  39         return false;
  40     }
  41
  42     fCreateBlank = GetBoolArg("-create", false);
  43
  44     if (argc<2 || mapArgs.count("-?") || mapArgs.count("-help"))
  45     {
  46         // First part of help message is specific to this utility
  47         std::string strUsage = _("Bitcoin Core bitcoin-tx utility version") + " " + FormatFullVersion() + "\n\n" +
  48             _("Usage:") + "\n" +
  49               "  bitcoin-tx [options] <hex-tx> [commands]  " + _("Update hex-encoded bitcoin transaction") + "\n" +
  50               "  bitcoin-tx [options] -create [commands]   " + _("Create hex-encoded bitcoin transaction") + "\n" +
  51               "\n";
  52
  53         fprintf(stdout, "%s", strUsage.c_str());
  54
  55         strUsage = HelpMessageGroup(_("Options:"));
  56         strUsage += HelpMessageOpt("-?", _("This help message"));
  57         strUsage += HelpMessageOpt("-create", _("Create new, empty TX."));
  58         strUsage += HelpMessageOpt("-json", _("Select JSON output"));
  59         strUsage += HelpMessageOpt("-txid", _("Output only the hex-encoded transaction id of the resultant transaction."));
  60         strUsage += HelpMessageOpt("-regtest", _("Enter regression test mode, which uses a special chain in which blocks can be solved instantly."));
  61         strUsage += HelpMessageOpt("-testnet", _("Use the test network"));
  62
  63         fprintf(stdout, "%s", strUsage.c_str());
  64
  65         strUsage = HelpMessageGroup(_("Commands:"));
  66         strUsage += HelpMessageOpt("delin=N", _("Delete input N from TX"));
  67         strUsage += HelpMessageOpt("delout=N", _("Delete output N from TX"));
  68         strUsage += HelpMessageOpt("in=TXID:VOUT", _("Add input to TX"));
  69         strUsage += HelpMessageOpt("locktime=N", _("Set TX lock time to N"));
  70         strUsage += HelpMessageOpt("nversion=N", _("Set TX version to N"));
  71         strUsage += HelpMessageOpt("outaddr=VALUE:ADDRESS", _("Add address-based output to TX"));
  72         strUsage += HelpMessageOpt("outscript=VALUE:SCRIPT", _("Add raw script output to TX"));
  73         strUsage += HelpMessageOpt("sign=SIGHASH-FLAGS", _("Add zero or more signatures to transaction") + ". " +
  74             _("This command requires JSON registers:") +
  75             _("prevtxs=JSON object") + ", " +
  76             _("privatekeys=JSON object") + ". " +
  77             _("See signrawtransaction docs for format of sighash flags, JSON objects."));
  78         fprintf(stdout, "%s", strUsage.c_str());
  79
  80         strUsage = HelpMessageGroup(_("Register Commands:"));
  81         strUsage += HelpMessageOpt("load=NAME:FILENAME", _("Load JSON file FILENAME into register NAME"));
  82         strUsage += HelpMessageOpt("set=NAME:JSON-STRING", _("Set register NAME to given JSON-STRING"));
  83         fprintf(stdout, "%s", strUsage.c_str());
  84
  85         return false;
  86     }
  87     return true;
  88 }
  89
  90 static void RegisterSetJson(const string& key, const string& rawJson)
  91 {
  92     UniValue val;
  93     if (!val.read(rawJson)) {
  94         string strErr = "Cannot parse JSON for key " + key;
  95         throw runtime_error(strErr);
  96     }
  97
  98     registers[key] = val;
  99 }
 100
 101 static void RegisterSet(const string& strInput)
 102 {
 103     // separate NAME:VALUE in string
 104     size_t pos = strInput.find(':');
 105     if ((pos == string::npos) ||
 106         (pos == 0) ||
 107         (pos == (strInput.size() - 1)))
 108         throw runtime_error("Register input requires NAME:VALUE");
 109
 110     string key = strInput.substr(0, pos);
 111     string valStr = strInput.substr(pos + 1, string::npos);
 112
 113     RegisterSetJson(key, valStr);
 114 }
 115
 116 static void RegisterLoad(const string& strInput)
 117 {
 118     // separate NAME:FILENAME in string
 119     size_t pos = strInput.find(':');
 120     if ((pos == string::npos) ||
 121         (pos == 0) ||
 122         (pos == (strInput.size() - 1)))
 123         throw runtime_error("Register load requires NAME:FILENAME");
 124
 125     string key = strInput.substr(0, pos);
 126     string filename = strInput.substr(pos + 1, string::npos);
 127
 128     FILE *f = fopen(filename.c_str(), "r");
 129     if (!f) {
 130         string strErr = "Cannot open file " + filename;
 131         throw runtime_error(strErr);
 132     }
 133
 134     // load file chunks into one big buffer
 135     string valStr;
 136     while ((!feof(f)) && (!ferror(f))) {
 137         char buf[4096];
 138         int bread = fread(buf, 1, sizeof(buf), f);
 139         if (bread <= 0)
 140             break;
 141
 142         valStr.insert(valStr.size(), buf, bread);
 143     }
 144
 145     if (ferror(f)) {
 146         string strErr = "Error reading file " + filename;
 147         throw runtime_error(strErr);
 148     }
 149
 150     fclose(f);
 151
 152     // evaluate as JSON buffer register
 153     RegisterSetJson(key, valStr);
 154 }
 155
 156 static void MutateTxVersion(CMutableTransaction& tx, const string& cmdVal)
 157 {
 158     int64_t newVersion = atoi64(cmdVal);
 159     if (newVersion < 1 || newVersion > CTransaction::CURRENT_VERSION)
 160         throw runtime_error("Invalid TX version requested");
 161
 162     tx.nVersion = (int) newVersion;
 163 }
 164
 165 static void MutateTxLocktime(CMutableTransaction& tx, const string& cmdVal)
 166 {
 167     int64_t newLocktime = atoi64(cmdVal);
 168     if (newLocktime < 0LL || newLocktime > 0xffffffffLL)
 169         throw runtime_error("Invalid TX locktime requested");
 170
 171     tx.nLockTime = (unsigned int) newLocktime;
 172 }
 173
 174 static void MutateTxAddInput(CMutableTransaction& tx, const string& strInput)
 175 {
 176     // separate TXID:VOUT in string
 177     size_t pos = strInput.find(':');
 178     if ((pos == string::npos) ||
 179         (pos == 0) ||
 180         (pos == (strInput.size() - 1)))
 181         throw runtime_error("TX input missing separator");
 182
 183     // extract and validate TXID
 184     string strTxid = strInput.substr(0, pos);
 185     if ((strTxid.size() != 64) || !IsHex(strTxid))
 186         throw runtime_error("invalid TX input txid");
 187     uint256 txid(uint256S(strTxid));
 188
 189     static const unsigned int minTxOutSz = 9;
 190     static const unsigned int maxVout = MAX_BLOCK_SIZE / minTxOutSz;
 191
 192     // extract and validate vout
 193     string strVout = strInput.substr(pos + 1, string::npos);
 194     int vout = atoi(strVout);
 195     if ((vout < 0) || (vout > (int)maxVout))
 196         throw runtime_error("invalid TX input vout");
 197
 198     // append to transaction input list
 199     CTxIn txin(txid, vout);
 200     tx.vin.push_back(txin);
 201 }
 202
 203 static void MutateTxAddOutAddr(CMutableTransaction& tx, const string& strInput)
 204 {
 205     // separate VALUE:ADDRESS in string
 206     size_t pos = strInput.find(':');
 207     if ((pos == string::npos) ||
 208         (pos == 0) ||
 209         (pos == (strInput.size() - 1)))
 210         throw runtime_error("TX output missing separator");
 211
 212     // extract and validate VALUE
 213     string strValue = strInput.substr(0, pos);
 214     CAmount value;
 215     if (!ParseMoney(strValue, value))
 216         throw runtime_error("invalid TX output value");
 217
 218     // extract and validate ADDRESS
 219     string strAddr = strInput.substr(pos + 1, string::npos);
 220     CBitcoinAddress addr(strAddr);
 221     if (!addr.IsValid())
 222         throw runtime_error("invalid TX output address");
 223
 224     // build standard output script via GetScriptForDestination()
 225     CScript scriptPubKey = GetScriptForDestination(addr.Get());
 226
 227     // construct TxOut, append to transaction output list
 228     CTxOut txout(value, scriptPubKey);
 229     tx.vout.push_back(txout);
 230 }
 231
 232 static void MutateTxAddOutScript(CMutableTransaction& tx, const string& strInput)
 233 {
 234     // separate VALUE:SCRIPT in string
 235     size_t pos = strInput.find(':');
 236     if ((pos == string::npos) ||
 237         (pos == 0))
 238         throw runtime_error("TX output missing separator");
 239
 240     // extract and validate VALUE
 241     string strValue = strInput.substr(0, pos);
 242     CAmount value;
 243     if (!ParseMoney(strValue, value))
 244         throw runtime_error("invalid TX output value");
 245
 246     // extract and validate script
 247     string strScript = strInput.substr(pos + 1, string::npos);
 248     CScript scriptPubKey = ParseScript(strScript); // throws on err
 249
 250     // construct TxOut, append to transaction output list
 251     CTxOut txout(value, scriptPubKey);
 252     tx.vout.push_back(txout);
 253 }
 254
 255 static void MutateTxDelInput(CMutableTransaction& tx, const string& strInIdx)
 256 {
 257     // parse requested deletion index
 258     int inIdx = atoi(strInIdx);
 259     if (inIdx < 0 || inIdx >= (int)tx.vin.size()) {
 260         string strErr = "Invalid TX input index '" + strInIdx + "'";
 261         throw runtime_error(strErr.c_str());
 262     }
 263
 264     // delete input from transaction
 265     tx.vin.erase(tx.vin.begin() + inIdx);
 266 }
 267
 268 static void MutateTxDelOutput(CMutableTransaction& tx, const string& strOutIdx)
 269 {
 270     // parse requested deletion index
 271     int outIdx = atoi(strOutIdx);
 272     if (outIdx < 0 || outIdx >= (int)tx.vout.size()) {
 273         string strErr = "Invalid TX output index '" + strOutIdx + "'";
 274         throw runtime_error(strErr.c_str());
 275     }
 276
 277     // delete output from transaction
 278     tx.vout.erase(tx.vout.begin() + outIdx);
 279 }
 280
 281 static const unsigned int N_SIGHASH_OPTS = 6;
 282 static const struct {
 283     const char *flagStr;
 284     int flags;
 285 } sighashOptions[N_SIGHASH_OPTS] = {
 286     {"ALL", SIGHASH_ALL},
 287     {"NONE", SIGHASH_NONE},
 288     {"SINGLE", SIGHASH_SINGLE},
 289     {"ALL|ANYONECANPAY", SIGHASH_ALL|SIGHASH_ANYONECANPAY},
 290     {"NONE|ANYONECANPAY", SIGHASH_NONE|SIGHASH_ANYONECANPAY},
 291     {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE|SIGHASH_ANYONECANPAY},
 292 };
 293
 294 static bool findSighashFlags(int& flags, const string& flagStr)
 295 {
 296     flags = 0;
 297
 298     for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
 299         if (flagStr == sighashOptions[i].flagStr) {
 300             flags = sighashOptions[i].flags;
 301             return true;
 302         }
 303     }
 304
 305     return false;
 306 }
 307
 308 uint256 ParseHashUO(map<string,UniValue>& o, string strKey)
 309 {
 310     if (!o.count(strKey))
 311         return uint256();
 312     return ParseHashUV(o[strKey], strKey);
 313 }
 314
 315 vector<unsigned char> ParseHexUO(map<string,UniValue>& o, string strKey)
 316 {
 317     if (!o.count(strKey)) {
 318         vector<unsigned char> emptyVec;
 319         return emptyVec;
 320     }
 321     return ParseHexUV(o[strKey], strKey);
 322 }
 323
 324 static void MutateTxSign(CMutableTransaction& tx, const string& flagStr)
 325 {
 326     int nHashType = SIGHASH_ALL;
 327
 328     if (flagStr.size() > 0)
 329         if (!findSighashFlags(nHashType, flagStr))
 330             throw runtime_error("unknown sighash flag/sign option");
 331
 332     vector<CTransaction> txVariants;
 333     txVariants.push_back(tx);
 334
 335     // mergedTx will end up with all the signatures; it
 336     // starts as a clone of the raw tx:
 337     CMutableTransaction mergedTx(txVariants[0]);
 338     bool fComplete = true;
 339     CCoinsView viewDummy;
 340     CCoinsViewCache view(&viewDummy);
 341
 342     if (!registers.count("privatekeys"))
 343         throw runtime_error("privatekeys register variable must be set.");
 344     bool fGivenKeys = false;
 345     CBasicKeyStore tempKeystore;
 346     UniValue keysObj = registers["privatekeys"];
 347     fGivenKeys = true;
 348
 349     for (unsigned int kidx = 0; kidx < keysObj.count(); kidx++) {
 350         if (!keysObj[kidx].isStr())
 351             throw runtime_error("privatekey not a string");
 352         CBitcoinSecret vchSecret;
 353         bool fGood = vchSecret.SetString(keysObj[kidx].getValStr());
 354         if (!fGood)
 355             throw runtime_error("privatekey not valid");
 356
 357         CKey key = vchSecret.GetKey();
 358         tempKeystore.AddKey(key);
 359     }
 360
 361     // Add previous txouts given in the RPC call:
 362     if (!registers.count("prevtxs"))
 363         throw runtime_error("prevtxs register variable must be set.");
 364     UniValue prevtxsObj = registers["prevtxs"];
 365     {
 366         for (unsigned int previdx = 0; previdx < prevtxsObj.count(); previdx++) {
 367             UniValue prevOut = prevtxsObj[previdx];
 368             if (!prevOut.isObject())
 369                 throw runtime_error("expected prevtxs internal object");
 370
 371             map<string,UniValue::VType> types = boost::assign::map_list_of("txid", UniValue::VSTR)("vout",UniValue::VNUM)("scriptPubKey",UniValue::VSTR);
 372             if (!prevOut.checkObject(types))
 373                 throw runtime_error("prevtxs internal object typecheck fail");
 374
 375             uint256 txid = ParseHashUV(prevOut["txid"], "txid");
 376
 377             int nOut = atoi(prevOut["vout"].getValStr());
 378             if (nOut < 0)
 379                 throw runtime_error("vout must be positive");
 380
 381             vector<unsigned char> pkData(ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
 382             CScript scriptPubKey(pkData.begin(), pkData.end());
 383
 384             {
 385                 CCoinsModifier coins = view.ModifyCoins(txid);
 386                 if (coins->IsAvailable(nOut) && coins->vout[nOut].scriptPubKey != scriptPubKey) {
 387                     string err("Previous output scriptPubKey mismatch:\n");
 388                     err = err + coins->vout[nOut].scriptPubKey.ToString() + "\nvs:\n"+
 389                         scriptPubKey.ToString();
 390                     throw runtime_error(err);
 391                 }
 392                 if ((unsigned int)nOut >= coins->vout.size())
 393                     coins->vout.resize(nOut+1);
 394                 coins->vout[nOut].scriptPubKey = scriptPubKey;
 395                 coins->vout[nOut].nValue = 0; // we don't know the actual output value
 396             }
 397
 398             // if redeemScript given and private keys given,
 399             // add redeemScript to the tempKeystore so it can be signed:
 400             if (fGivenKeys && scriptPubKey.IsPayToScriptHash() &&
 401                 prevOut.exists("redeemScript")) {
 402                 UniValue v = prevOut["redeemScript"];
 403                 vector<unsigned char> rsData(ParseHexUV(v, "redeemScript"));
 404                 CScript redeemScript(rsData.begin(), rsData.end());
 405                 tempKeystore.AddCScript(redeemScript);
 406             }
 407         }
 408     }
 409
 410     const CKeyStore& keystore = tempKeystore;
 411
 412     bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);
 413
 414     // Sign what we can:
 415     for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
 416         CTxIn& txin = mergedTx.vin[i];
 417         const CCoins* coins = view.AccessCoins(txin.prevout.hash);
 418         if (!coins || !coins->IsAvailable(txin.prevout.n)) {
 419             fComplete = false;
 420             continue;
 421         }
 422         const CScript& prevPubKey = coins->vout[txin.prevout.n].scriptPubKey;
 423
 424         txin.scriptSig.clear();
 425         // Only sign SIGHASH_SINGLE if there's a corresponding output:
 426         if (!fHashSingle || (i < mergedTx.vout.size()))
 427             SignSignature(keystore, prevPubKey, mergedTx, i, nHashType);
 428
 429         // ... and merge in other signatures:
 430         BOOST_FOREACH(const CTransaction& txv, txVariants) {
 431             txin.scriptSig = CombineSignatures(prevPubKey, mergedTx, i, txin.scriptSig, txv.vin[i].scriptSig);
 432         }
 433         if (!VerifyScript(txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker(&mergedTx, i)))
 434             fComplete = false;
 435     }
 436
 437     if (fComplete) {
 438         // do nothing... for now
 439         // perhaps store this for later optional JSON output
 440     }
 441
 442     tx = mergedTx;
 443 }
 444
 445 static void MutateTx(CMutableTransaction& tx, const string& command,
 446                      const string& commandVal)
 447 {
 448     if (command == "nversion")
 449         MutateTxVersion(tx, commandVal);
 450     else if (command == "locktime")
 451         MutateTxLocktime(tx, commandVal);
 452
 453     else if (command == "delin")
 454         MutateTxDelInput(tx, commandVal);
 455     else if (command == "in")
 456         MutateTxAddInput(tx, commandVal);
 457
 458     else if (command == "delout")
 459         MutateTxDelOutput(tx, commandVal);
 460     else if (command == "outaddr")
 461         MutateTxAddOutAddr(tx, commandVal);
 462     else if (command == "outscript")
 463         MutateTxAddOutScript(tx, commandVal);
 464
 465     else if (command == "sign")
 466         MutateTxSign(tx, commandVal);
 467
 468     else if (command == "load")
 469         RegisterLoad(commandVal);
 470
 471     else if (command == "set")
 472         RegisterSet(commandVal);
 473
 474     else
 475         throw runtime_error("unknown command");
 476 }
 477
 478 static void OutputTxJSON(const CTransaction& tx)
 479 {
 480     UniValue entry(UniValue::VOBJ);
 481     TxToUniv(tx, uint256(), entry);
 482
 483     string jsonOutput = entry.write(4);
 484     fprintf(stdout, "%s\n", jsonOutput.c_str());
 485 }
 486
 487 static void OutputTxHash(const CTransaction& tx)
 488 {
 489     string strHexHash = tx.GetHash().GetHex(); // the hex-encoded transaction hash (aka the transaction id)
 490
 491     fprintf(stdout, "%s\n", strHexHash.c_str());
 492 }
 493
 494 static void OutputTxHex(const CTransaction& tx)
 495 {
 496     string strHex = EncodeHexTx(tx);
 497
 498     fprintf(stdout, "%s\n", strHex.c_str());
 499 }
 500
 501 static void OutputTx(const CTransaction& tx)
 502 {
 503     if (GetBoolArg("-json", false))
 504         OutputTxJSON(tx);
 505     else if (GetBoolArg("-txid", false))
 506         OutputTxHash(tx);
 507     else
 508         OutputTxHex(tx);
 509 }
 510
 511 static string readStdin()
 512 {
 513     char buf[4096];
 514     string ret;
 515
 516     while (!feof(stdin)) {
 517         size_t bread = fread(buf, 1, sizeof(buf), stdin);
 518         ret.append(buf, bread);
 519         if (bread < sizeof(buf))
 520             break;
 521     }
 522
 523     if (ferror(stdin))
 524         throw runtime_error("error reading stdin");
 525
 526     boost::algorithm::trim_right(ret);
 527
 528     return ret;
 529 }
 530
 531 static int CommandLineRawTx(int argc, char* argv[])
 532 {
 533     string strPrint;
 534     int nRet = 0;
 535     try {
 536         // Skip switches; Permit common stdin convention "-"
 537         while (argc > 1 && IsSwitchChar(argv[1][0]) &&
 538                (argv[1][1] != 0)) {
 539             argc--;
 540             argv++;
 541         }
 542
 543         CTransaction txDecodeTmp;
 544         int startArg;
 545
 546         if (!fCreateBlank) {
 547             // require at least one param
 548             if (argc < 2)
 549                 throw runtime_error("too few parameters");
 550
 551             // param: hex-encoded bitcoin transaction
 552             string strHexTx(argv[1]);
 553             if (strHexTx == "-")                 // "-" implies standard input
 554                 strHexTx = readStdin();
 555
 556             if (!DecodeHexTx(txDecodeTmp, strHexTx))
 557                 throw runtime_error("invalid transaction encoding");
 558
 559             startArg = 2;
 560         } else
 561             startArg = 1;
 562
 563         CMutableTransaction tx(txDecodeTmp);
 564
 565         for (int i = startArg; i < argc; i++) {
 566             string arg = argv[i];
 567             string key, value;
 568             size_t eqpos = arg.find('=');
 569             if (eqpos == string::npos)
 570                 key = arg;
 571             else {
 572                 key = arg.substr(0, eqpos);
 573                 value = arg.substr(eqpos + 1);
 574             }
 575
 576             MutateTx(tx, key, value);
 577         }
 578
 579         OutputTx(tx);
 580     }
 581
 582     catch (const boost::thread_interrupted&) {
 583         throw;
 584     }
 585     catch (const std::exception& e) {
 586         strPrint = string("error: ") + e.what();
 587         nRet = EXIT_FAILURE;
 588     }
 589     catch (...) {
 590         PrintExceptionContinue(NULL, "CommandLineRawTx()");
 591         throw;
 592     }
 593
 594     if (strPrint != "") {
 595         fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
 596     }
 597     return nRet;
 598 }
 599
 600 int main(int argc, char* argv[])
 601 {
 602     SetupEnvironment();
 603
 604     try {
 605         if(!AppInitRawTx(argc, argv))
 606             return EXIT_FAILURE;
 607     }
 608     catch (const std::exception& e) {
 609         PrintExceptionContinue(&e, "AppInitRawTx()");
 610         return EXIT_FAILURE;
 611     } catch (...) {
 612         PrintExceptionContinue(NULL, "AppInitRawTx()");
 613         return EXIT_FAILURE;
 614     }
 615
 616     int ret = EXIT_FAILURE;
 617     try {
 618         ret = CommandLineRawTx(argc, argv);
 619     }
 620     catch (const std::exception& e) {
 621         PrintExceptionContinue(&e, "CommandLineRawTx()");
 622     } catch (...) {
 623         PrintExceptionContinue(NULL, "CommandLineRawTx()");
 624     }
 625     return ret;
 626 }