No OneTemporary
Actions

Size

30 KB

Subscribers

None

View Options

	diff --git a/src/Makefile.test.include b/src/Makefile.test.include
	index f9384a09a..828919895 100644
	--- a/src/Makefile.test.include
	+++ b/src/Makefile.test.include
	@@ -1,134 +1,136 @@
	TESTS += test/test_bitcoin
	bin_PROGRAMS += test/test_bitcoin
	TEST_SRCDIR = test
	TEST_BINARY=test/test_bitcoin$(EXEEXT)


	EXTRA_DIST += \
	test/bctest.py \
	test/bitcoin-util-test.py \
	test/data/bitcoin-util-test.json \
	test/data/blanktx.hex \
	test/data/tt-delin1-out.hex \
	test/data/tt-delout1-out.hex \
	test/data/tt-locktime317000-out.hex \
	test/data/tx394b54bb.hex \
	test/data/txcreate1.hex \
	test/data/txcreate2.hex \
	+ test/data/txcreatedata1.hex \
	+ test/data/txcreatedata2.hex \
	test/data/txcreatesign.hex

	JSON_TEST_FILES = \
	test/data/script_valid.json \
	test/data/base58_keys_valid.json \
	test/data/base58_encode_decode.json \
	test/data/base58_keys_invalid.json \
	test/data/script_invalid.json \
	test/data/tx_invalid.json \
	test/data/tx_valid.json \
	test/data/sighash.json

	RAW_TEST_FILES = test/data/alertTests.raw

	GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)

	BITCOIN_TESTS =\
	test/arith_uint256_tests.cpp \
	test/bignum.h \
	test/alert_tests.cpp \
	test/allocator_tests.cpp \
	test/base32_tests.cpp \
	test/base58_tests.cpp \
	test/base64_tests.cpp \
	test/bip32_tests.cpp \
	test/bloom_tests.cpp \
	test/checkblock_tests.cpp \
	test/Checkpoints_tests.cpp \
	test/coins_tests.cpp \
	test/compress_tests.cpp \
	test/crypto_tests.cpp \
	test/DoS_tests.cpp \
	test/getarg_tests.cpp \
	test/hash_tests.cpp \
	test/key_tests.cpp \
	test/main_tests.cpp \
	test/mempool_tests.cpp \
	test/miner_tests.cpp \
	test/mruset_tests.cpp \
	test/multisig_tests.cpp \
	test/netbase_tests.cpp \
	test/pmt_tests.cpp \
	test/policyestimator_tests.cpp \
	test/pow_tests.cpp \
	test/rpc_tests.cpp \
	test/sanity_tests.cpp \
	test/scheduler_tests.cpp \
	test/script_P2SH_tests.cpp \
	test/script_tests.cpp \
	test/scriptnum_tests.cpp \
	test/serialize_tests.cpp \
	test/sighash_tests.cpp \
	test/sigopcount_tests.cpp \
	test/skiplist_tests.cpp \
	test/test_bitcoin.cpp \
	test/test_bitcoin.h \
	test/timedata_tests.cpp \
	test/transaction_tests.cpp \
	test/txvalidationcache_tests.cpp \
	test/uint256_tests.cpp \
	test/univalue_tests.cpp \
	test/util_tests.cpp

	if ENABLE_WALLET
	BITCOIN_TESTS += \
	test/accounting_tests.cpp \
	wallet/test/wallet_tests.cpp \
	test/rpc_wallet_tests.cpp
	endif

	test_test_bitcoin_SOURCES = $(BITCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES)
	test_test_bitcoin_CPPFLAGS = $(BITCOIN_INCLUDES) -I$(builddir)/test/ $(TESTDEFS)
	test_test_bitcoin_LDADD = $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CRYPTO) $(LIBBITCOIN_UNIVALUE) $(LIBLEVELDB) $(LIBMEMENV) \
	$(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1)
	if ENABLE_WALLET
	test_test_bitcoin_LDADD += $(LIBBITCOIN_WALLET)
	endif

	test_test_bitcoin_LDADD += $(LIBBITCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS)
	test_test_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static

	nodist_test_test_bitcoin_SOURCES = $(GENERATED_TEST_FILES)

	$(BITCOIN_TESTS): $(GENERATED_TEST_FILES)

	CLEAN_BITCOIN_TEST = test/.gcda test/.gcno $(GENERATED_TEST_FILES)

	CLEANFILES += $(CLEAN_BITCOIN_TEST)

	bitcoin_test: $(TEST_BINARY)

	bitcoin_test_check: $(TEST_BINARY) FORCE
	$(MAKE) check-TESTS TESTS=$^

	bitcoin_test_clean : FORCE
	rm -f $(CLEAN_BITCOIN_TEST) $(test_test_bitcoin_OBJECTS) $(TEST_BINARY)

	check-local:
	@echo "Running test/bitcoin-util-test.py..."
	$(AM_V_at)srcdir=$(srcdir) PYTHONPATH=$(builddir)/test $(srcdir)/test/bitcoin-util-test.py
	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check

	%.json.h: %.json
	@$(MKDIR_P) $(@D)
	@echo "namespace json_tests{" > $@
	@echo "static unsigned const char $(*F)[] = {" >> $@
	@$(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< \| $(SED) -e 's/0x ,//g' >> $@
	@echo "};};" >> $@
	@echo "Generated $@"

	%.raw.h: %.raw
	@$(MKDIR_P) $(@D)
	@echo "namespace alert_tests{" > $@
	@echo "static unsigned const char $(*F)[] = {" >> $@
	@$(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< \| $(SED) -e 's/0x ,//g' >> $@
	@echo "};};" >> $@
	@echo "Generated $@"
	diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
	index e389d51a7..97a073174 100644
	--- a/src/bitcoin-tx.cpp
	+++ b/src/bitcoin-tx.cpp
	@@ -1,639 +1,671 @@
	// Copyright (c) 2009-2014 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 "base58.h"
	#include "clientversion.h"
	#include "coins.h"
	#include "consensus/consensus.h"
	#include "core_io.h"
	#include "keystore.h"
	#include "policy/policy.h"
	#include "primitives/transaction.h"
	#include "script/script.h"
	#include "script/sign.h"
	#include "univalue/univalue.h"
	#include "util.h"
	#include "utilmoneystr.h"
	#include "utilstrencodings.h"

	#include <stdio.h>

	#include <boost/algorithm/string.hpp>
	#include <boost/assign/list_of.hpp>

	using namespace std;

	static bool fCreateBlank;
	static map<string,UniValue> registers;

	static bool AppInitRawTx(int argc, char* argv[])
	{
	//
	// Parameters
	//
	ParseParameters(argc, argv);

	// Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
	if (!SelectParamsFromCommandLine()) {
	fprintf(stderr, "Error: Invalid combination of -regtest and -testnet.\n");
	return false;
	}

	fCreateBlank = GetBoolArg("-create", false);

	if (argc<2 \|\| mapArgs.count("-?") \|\| mapArgs.count("-help"))
	{
	// First part of help message is specific to this utility
	std::string strUsage = _("Bitcoin Core bitcoin-tx utility version") + " " + FormatFullVersion() + "\n\n" +
	_("Usage:") + "\n" +
	" bitcoin-tx [options] <hex-tx> [commands] " + _("Update hex-encoded bitcoin transaction") + "\n" +
	" bitcoin-tx [options] -create [commands] " + _("Create hex-encoded bitcoin transaction") + "\n" +
	"\n";

	fprintf(stdout, "%s", strUsage.c_str());

	strUsage = HelpMessageGroup(_("Options:"));
	strUsage += HelpMessageOpt("-?", _("This help message"));
	strUsage += HelpMessageOpt("-create", _("Create new, empty TX."));
	strUsage += HelpMessageOpt("-json", _("Select JSON output"));
	strUsage += HelpMessageOpt("-txid", _("Output only the hex-encoded transaction id of the resultant transaction."));
	strUsage += HelpMessageOpt("-regtest", _("Enter regression test mode, which uses a special chain in which blocks can be solved instantly."));
	strUsage += HelpMessageOpt("-testnet", _("Use the test network"));

	fprintf(stdout, "%s", strUsage.c_str());

	strUsage = HelpMessageGroup(_("Commands:"));
	strUsage += HelpMessageOpt("delin=N", _("Delete input N from TX"));
	strUsage += HelpMessageOpt("delout=N", _("Delete output N from TX"));
	strUsage += HelpMessageOpt("in=TXID:VOUT", _("Add input to TX"));
	strUsage += HelpMessageOpt("locktime=N", _("Set TX lock time to N"));
	strUsage += HelpMessageOpt("nversion=N", _("Set TX version to N"));
	strUsage += HelpMessageOpt("outaddr=VALUE:ADDRESS", _("Add address-based output to TX"));
	+ strUsage += HelpMessageOpt("outdata=[VALUE:]DATA", _("Add data-based output to TX"));
	strUsage += HelpMessageOpt("outscript=VALUE:SCRIPT", _("Add raw script output to TX"));
	strUsage += HelpMessageOpt("sign=SIGHASH-FLAGS", _("Add zero or more signatures to transaction") + ". " +
	_("This command requires JSON registers:") +
	_("prevtxs=JSON object") + ", " +
	_("privatekeys=JSON object") + ". " +
	_("See signrawtransaction docs for format of sighash flags, JSON objects."));
	fprintf(stdout, "%s", strUsage.c_str());

	strUsage = HelpMessageGroup(_("Register Commands:"));
	strUsage += HelpMessageOpt("load=NAME:FILENAME", _("Load JSON file FILENAME into register NAME"));
	strUsage += HelpMessageOpt("set=NAME:JSON-STRING", _("Set register NAME to given JSON-STRING"));
	fprintf(stdout, "%s", strUsage.c_str());

	return false;
	}
	return true;
	}

	static void RegisterSetJson(const string& key, const string& rawJson)
	{
	UniValue val;
	if (!val.read(rawJson)) {
	string strErr = "Cannot parse JSON for key " + key;
	throw runtime_error(strErr);
	}

	registers[key] = val;
	}

	static void RegisterSet(const string& strInput)
	{
	// separate NAME:VALUE in string
	size_t pos = strInput.find(':');
	if ((pos == string::npos) \|\|
	(pos == 0) \|\|
	(pos == (strInput.size() - 1)))
	throw runtime_error("Register input requires NAME:VALUE");

	string key = strInput.substr(0, pos);
	string valStr = strInput.substr(pos + 1, string::npos);

	RegisterSetJson(key, valStr);
	}

	static void RegisterLoad(const string& strInput)
	{
	// separate NAME:FILENAME in string
	size_t pos = strInput.find(':');
	if ((pos == string::npos) \|\|
	(pos == 0) \|\|
	(pos == (strInput.size() - 1)))
	throw runtime_error("Register load requires NAME:FILENAME");

	string key = strInput.substr(0, pos);
	string filename = strInput.substr(pos + 1, string::npos);

	FILE *f = fopen(filename.c_str(), "r");
	if (!f) {
	string strErr = "Cannot open file " + filename;
	throw runtime_error(strErr);
	}

	// load file chunks into one big buffer
	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) {
	string strErr = "Error reading file " + filename;
	throw runtime_error(strErr);
	}

	// evaluate as JSON buffer register
	RegisterSetJson(key, valStr);
	}

	static void MutateTxVersion(CMutableTransaction& tx, const string& cmdVal)
	{
	int64_t newVersion = atoi64(cmdVal);
	if (newVersion < 1 \|\| newVersion > CTransaction::CURRENT_VERSION)
	throw runtime_error("Invalid TX version requested");

	tx.nVersion = (int) newVersion;
	}

	static void MutateTxLocktime(CMutableTransaction& tx, const string& cmdVal)
	{
	int64_t newLocktime = atoi64(cmdVal);
	if (newLocktime < 0LL \|\| newLocktime > 0xffffffffLL)
	throw runtime_error("Invalid TX locktime requested");

	tx.nLockTime = (unsigned int) newLocktime;
	}

	static void MutateTxAddInput(CMutableTransaction& tx, const string& strInput)
	{
	// separate TXID:VOUT in string
	size_t pos = strInput.find(':');
	if ((pos == string::npos) \|\|
	(pos == 0) \|\|
	(pos == (strInput.size() - 1)))
	throw runtime_error("TX input missing separator");

	// extract and validate TXID
	string strTxid = strInput.substr(0, pos);
	if ((strTxid.size() != 64) \|\| !IsHex(strTxid))
	throw runtime_error("invalid TX input txid");
	uint256 txid(uint256S(strTxid));

	static const unsigned int minTxOutSz = 9;
	static const unsigned int maxVout = MAX_BLOCK_SIZE / minTxOutSz;

	// extract and validate vout
	string strVout = strInput.substr(pos + 1, string::npos);
	int vout = atoi(strVout);
	if ((vout < 0) \|\| (vout > (int)maxVout))
	throw runtime_error("invalid TX input vout");

	// append to transaction input list
	CTxIn txin(txid, vout);
	tx.vin.push_back(txin);
	}

	static void MutateTxAddOutAddr(CMutableTransaction& tx, const string& strInput)
	{
	// separate VALUE:ADDRESS in string
	size_t pos = strInput.find(':');
	if ((pos == string::npos) \|\|
	(pos == 0) \|\|
	(pos == (strInput.size() - 1)))
	throw runtime_error("TX output missing separator");

	// extract and validate VALUE
	string strValue = strInput.substr(0, pos);
	CAmount value;
	if (!ParseMoney(strValue, value))
	throw runtime_error("invalid TX output value");

	// extract and validate ADDRESS
	string strAddr = strInput.substr(pos + 1, string::npos);
	CBitcoinAddress addr(strAddr);
	if (!addr.IsValid())
	throw runtime_error("invalid TX output address");

	// build standard output script via GetScriptForDestination()
	CScript scriptPubKey = GetScriptForDestination(addr.Get());

	// construct TxOut, append to transaction output list
	CTxOut txout(value, scriptPubKey);
	tx.vout.push_back(txout);
	}

	+static void MutateTxAddOutData(CMutableTransaction& tx, const string& strInput)
	+{
	+ CAmount value = 0;
	+
	+ // separate [VALUE:]DATA in string
	+ size_t pos = strInput.find(':');
	+
	+ if (pos==0)
	+ throw runtime_error("TX output value not specified");
	+
	+ if (pos != string::npos) {
	+ // extract and validate VALUE
	+ string strValue = strInput.substr(0, pos);
	+ if (!ParseMoney(strValue, value))
	+ throw runtime_error("invalid TX output value");
	+ }
	+
	+ // extract and validate DATA
	+ string strData = strInput.substr(pos + 1, string::npos);
	+
	+ if (!IsHex(strData))
	+ throw runtime_error("invalid TX output data");
	+
	+ std::vector<unsigned char> data = ParseHex(strData);
	+
	+ CTxOut txout(value, CScript() << OP_RETURN << data);
	+ tx.vout.push_back(txout);
	+}
	+
	static void MutateTxAddOutScript(CMutableTransaction& tx, const string& strInput)
	{
	// separate VALUE:SCRIPT in string
	size_t pos = strInput.find(':');
	if ((pos == string::npos) \|\|
	(pos == 0))
	throw runtime_error("TX output missing separator");

	// extract and validate VALUE
	string strValue = strInput.substr(0, pos);
	CAmount value;
	if (!ParseMoney(strValue, value))
	throw runtime_error("invalid TX output value");

	// extract and validate script
	string strScript = strInput.substr(pos + 1, string::npos);
	CScript scriptPubKey = ParseScript(strScript); // throws on err

	// construct TxOut, append to transaction output list
	CTxOut txout(value, scriptPubKey);
	tx.vout.push_back(txout);
	}

	static void MutateTxDelInput(CMutableTransaction& tx, const string& strInIdx)
	{
	// parse requested deletion index
	int inIdx = atoi(strInIdx);
	if (inIdx < 0 \|\| inIdx >= (int)tx.vin.size()) {
	string strErr = "Invalid TX input index '" + strInIdx + "'";
	throw runtime_error(strErr.c_str());
	}

	// delete input from transaction
	tx.vin.erase(tx.vin.begin() + inIdx);
	}

	static void MutateTxDelOutput(CMutableTransaction& tx, const string& strOutIdx)
	{
	// parse requested deletion index
	int outIdx = atoi(strOutIdx);
	if (outIdx < 0 \|\| outIdx >= (int)tx.vout.size()) {
	string strErr = "Invalid TX output index '" + strOutIdx + "'";
	throw runtime_error(strErr.c_str());
	}

	// delete output from transaction
	tx.vout.erase(tx.vout.begin() + outIdx);
	}

	static const unsigned int N_SIGHASH_OPTS = 6;
	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},
	};

	static bool findSighashFlags(int& flags, const string& flagStr)
	{
	flags = 0;

	for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
	if (flagStr == sighashOptions[i].flagStr) {
	flags = sighashOptions[i].flags;
	return true;
	}
	}

	return false;
	}

	uint256 ParseHashUO(map<string,UniValue>& o, string strKey)
	{
	if (!o.count(strKey))
	return uint256();
	return ParseHashUV(o[strKey], strKey);
	}

	vector<unsigned char> ParseHexUO(map<string,UniValue>& o, string strKey)
	{
	if (!o.count(strKey)) {
	vector<unsigned char> emptyVec;
	return emptyVec;
	}
	return ParseHexUV(o[strKey], strKey);
	}

	static void MutateTxSign(CMutableTransaction& tx, const string& flagStr)
	{
	int nHashType = SIGHASH_ALL;

	if (flagStr.size() > 0)
	if (!findSighashFlags(nHashType, flagStr))
	throw runtime_error("unknown sighash flag/sign option");

	vector<CTransaction> txVariants;
	txVariants.push_back(tx);

	// mergedTx will end up with all the signatures; it
	// starts as a clone of the raw tx:
	CMutableTransaction mergedTx(txVariants[0]);
	bool fComplete = true;
	CCoinsView viewDummy;
	CCoinsViewCache view(&viewDummy);

	if (!registers.count("privatekeys"))
	throw runtime_error("privatekeys register variable must be set.");
	bool fGivenKeys = false;
	CBasicKeyStore tempKeystore;
	UniValue keysObj = registers["privatekeys"];
	fGivenKeys = true;

	for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {
	if (!keysObj[kidx].isStr())
	throw runtime_error("privatekey not a string");
	CBitcoinSecret vchSecret;
	bool fGood = vchSecret.SetString(keysObj[kidx].getValStr());
	if (!fGood)
	throw runtime_error("privatekey not valid");

	CKey key = vchSecret.GetKey();
	tempKeystore.AddKey(key);
	}

	// Add previous txouts given in the RPC call:
	if (!registers.count("prevtxs"))
	throw 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 runtime_error("expected prevtxs internal object");

	map<string,UniValue::VType> types = boost::assign::map_list_of("txid", UniValue::VSTR)("vout",UniValue::VNUM)("scriptPubKey",UniValue::VSTR);
	if (!prevOut.checkObject(types))
	throw runtime_error("prevtxs internal object typecheck fail");

	uint256 txid = ParseHashUV(prevOut["txid"], "txid");

	int nOut = atoi(prevOut["vout"].getValStr());
	if (nOut < 0)
	throw runtime_error("vout must be positive");

	vector<unsigned char> pkData(ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
	CScript scriptPubKey(pkData.begin(), pkData.end());

	{
	CCoinsModifier coins = view.ModifyCoins(txid);
	if (coins->IsAvailable(nOut) && coins->vout[nOut].scriptPubKey != scriptPubKey) {
	string err("Previous output scriptPubKey mismatch:\n");
	err = err + coins->vout[nOut].scriptPubKey.ToString() + "\nvs:\n"+
	scriptPubKey.ToString();
	throw runtime_error(err);
	}
	if ((unsigned int)nOut >= coins->vout.size())
	coins->vout.resize(nOut+1);
	coins->vout[nOut].scriptPubKey = scriptPubKey;
	coins->vout[nOut].nValue = 0; // we don't know the actual output value
	}

	// if redeemScript given and private keys given,
	// add redeemScript to the tempKeystore so it can be signed:
	if (fGivenKeys && scriptPubKey.IsPayToScriptHash() &&
	prevOut.exists("redeemScript")) {
	UniValue v = prevOut["redeemScript"];
	vector<unsigned char> rsData(ParseHexUV(v, "redeemScript"));
	CScript redeemScript(rsData.begin(), rsData.end());
	tempKeystore.AddCScript(redeemScript);
	}
	}
	}

	const CKeyStore& keystore = tempKeystore;

	bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);

	// Sign what we can:
	for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
	CTxIn& txin = mergedTx.vin[i];
	const CCoins* coins = view.AccessCoins(txin.prevout.hash);
	if (!coins \|\| !coins->IsAvailable(txin.prevout.n)) {
	fComplete = false;
	continue;
	}
	const CScript& prevPubKey = coins->vout[txin.prevout.n].scriptPubKey;

	txin.scriptSig.clear();
	// Only sign SIGHASH_SINGLE if there's a corresponding output:
	if (!fHashSingle \|\| (i < mergedTx.vout.size()))
	SignSignature(keystore, prevPubKey, mergedTx, i, nHashType);

	// ... and merge in other signatures:
	BOOST_FOREACH(const CTransaction& txv, txVariants) {
	txin.scriptSig = CombineSignatures(prevPubKey, mergedTx, i, txin.scriptSig, txv.vin[i].scriptSig);
	}
	if (!VerifyScript(txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker(&mergedTx, i)))
	fComplete = false;
	}

	if (fComplete) {
	// do nothing... for now
	// perhaps store this for later optional JSON output
	}

	tx = mergedTx;
	}

	class Secp256k1Init
	{
	public:
	Secp256k1Init() { ECC_Start(); }
	~Secp256k1Init() { ECC_Stop(); }
	};

	static void MutateTx(CMutableTransaction& tx, const string& command,
	const string& commandVal)
	{
	boost::scoped_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);
	+ else if (command == "outdata")
	+ MutateTxAddOutData(tx, commandVal);
	else if (command == "outscript")
	MutateTxAddOutScript(tx, commandVal);

	else if (command == "sign") {
	if (!ecc) { ecc.reset(new Secp256k1Init()); }
	MutateTxSign(tx, commandVal);
	}

	else if (command == "load")
	RegisterLoad(commandVal);

	else if (command == "set")
	RegisterSet(commandVal);

	else
	throw runtime_error("unknown command");
	}

	static void OutputTxJSON(const CTransaction& tx)
	{
	UniValue entry(UniValue::VOBJ);
	TxToUniv(tx, uint256(), entry);

	string jsonOutput = entry.write(4);
	fprintf(stdout, "%s\n", jsonOutput.c_str());
	}

	static void OutputTxHash(const CTransaction& tx)
	{
	string strHexHash = tx.GetHash().GetHex(); // the hex-encoded transaction hash (aka the transaction id)

	fprintf(stdout, "%s\n", strHexHash.c_str());
	}

	static void OutputTxHex(const CTransaction& tx)
	{
	string strHex = EncodeHexTx(tx);

	fprintf(stdout, "%s\n", strHex.c_str());
	}

	static void OutputTx(const CTransaction& tx)
	{
	if (GetBoolArg("-json", false))
	OutputTxJSON(tx);
	else if (GetBoolArg("-txid", false))
	OutputTxHash(tx);
	else
	OutputTxHex(tx);
	}

	static string readStdin()
	{
	char buf[4096];
	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 runtime_error("error reading stdin");

	boost::algorithm::trim_right(ret);

	return ret;
	}

	static int CommandLineRawTx(int argc, char* argv[])
	{
	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++;
	}

	CTransaction txDecodeTmp;
	int startArg;

	if (!fCreateBlank) {
	// require at least one param
	if (argc < 2)
	throw runtime_error("too few parameters");

	// param: hex-encoded bitcoin transaction
	string strHexTx(argv[1]);
	if (strHexTx == "-") // "-" implies standard input
	strHexTx = readStdin();

	if (!DecodeHexTx(txDecodeTmp, strHexTx))
	throw runtime_error("invalid transaction encoding");

	startArg = 2;
	} else
	startArg = 1;

	CMutableTransaction tx(txDecodeTmp);

	for (int i = startArg; i < argc; i++) {
	string arg = argv[i];
	string key, value;
	size_t eqpos = arg.find('=');
	if (eqpos == string::npos)
	key = arg;
	else {
	key = arg.substr(0, eqpos);
	value = arg.substr(eqpos + 1);
	}

	MutateTx(tx, key, value);
	}

	OutputTx(tx);
	}

	catch (const boost::thread_interrupted&) {
	throw;
	}
	catch (const std::exception& e) {
	strPrint = string("error: ") + e.what();
	nRet = EXIT_FAILURE;
	}
	catch (...) {
	PrintExceptionContinue(NULL, "CommandLineRawTx()");
	throw;
	}

	if (strPrint != "") {
	fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
	}
	return nRet;
	}

	int main(int argc, char* argv[])
	{
	SetupEnvironment();

	try {
	if(!AppInitRawTx(argc, argv))
	return EXIT_FAILURE;
	}
	catch (const std::exception& e) {
	PrintExceptionContinue(&e, "AppInitRawTx()");
	return EXIT_FAILURE;
	} catch (...) {
	PrintExceptionContinue(NULL, "AppInitRawTx()");
	return EXIT_FAILURE;
	}

	int ret = EXIT_FAILURE;
	try {
	ret = CommandLineRawTx(argc, argv);
	}
	catch (const std::exception& e) {
	PrintExceptionContinue(&e, "CommandLineRawTx()");
	} catch (...) {
	PrintExceptionContinue(NULL, "CommandLineRawTx()");
	}
	return ret;
	}
	diff --git a/src/test/data/bitcoin-util-test.json b/src/test/data/bitcoin-util-test.json
	index afd35af50..3bf80ca43 100644
	--- a/src/test/data/bitcoin-util-test.json
	+++ b/src/test/data/bitcoin-util-test.json
	@@ -1,60 +1,90 @@
	[
	{ "exec": "././bitcoin-tx",
	"args": ["-create"],
	"output_cmp": "blanktx.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-"],
	"input": "blanktx.hex",
	"output_cmp": "blanktx.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-", "delin=1"],
	"input": "tx394b54bb.hex",
	"output_cmp": "tt-delin1-out.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-", "delin=31"],
	"input": "tx394b54bb.hex",
	"return_code": 1
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-", "delout=1"],
	"input": "tx394b54bb.hex",
	"output_cmp": "tt-delout1-out.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-", "delout=2"],
	"input": "tx394b54bb.hex",
	"return_code": 1
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-", "locktime=317000"],
	"input": "tx394b54bb.hex",
	"output_cmp": "tt-locktime317000-out.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args":
	["-create",
	"in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
	"in=bf829c6bcf84579331337659d31f89dfd138f7f7785802d5501c92333145ca7c:18",
	"in=22a6f904655d53ae2ff70e701a0bbd90aa3975c0f40bfc6cc996a9049e31cdfc:1",
	"outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
	"outaddr=4:1P8yWvZW8jVihP1bzHeqfE4aoXNX8AVa46"],
	"output_cmp": "txcreate1.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args": ["-create", "outscript=0:"],
	"output_cmp": "txcreate2.hex"
	},
	{ "exec": "./bitcoin-tx",
	"args":
	["-create",
	"in=4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485:0",
	"set=privatekeys:[\"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf\"]",
	"set=prevtxs:[{\"txid\":\"4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485\",\"vout\":0,\"scriptPubKey\":\"76a91491b24bf9f5288532960ac687abb035127b1d28a588ac\"}]",
	"sign=ALL",
	"outaddr=0.001:193P6LtvS4nCnkDvM9uXn1gsSRqh4aDAz7"],
	"output_cmp": "txcreatesign.hex"
	+ },
	+ { "exec": "./bitcoin-tx",
	+ "args":
	+ ["-create",
	+ "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
	+ "outdata=4:badhexdata"],
	+ "return_code": 1
	+ },
	+ { "exec": "./bitcoin-tx",
	+ "args":
	+ ["-create",
	+ "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
	+ "outdata=badhexdata"],
	+ "return_code": 1
	+ },
	+ { "exec": "./bitcoin-tx",
	+ "args":
	+ ["-create",
	+ "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
	+ "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
	+ "outdata=4:54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e"],
	+ "output_cmp": "txcreatedata1.hex"
	+ },
	+ { "exec": "./bitcoin-tx",
	+ "args":
	+ ["-create",
	+ "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
	+ "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
	+ "outdata=54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e"],
	+ "output_cmp": "txcreatedata2.hex"
	}
	]
	diff --git a/src/test/data/txcreatedata1.hex b/src/test/data/txcreatedata1.hex
	new file mode 100644
	index 000000000..eccc7604e
	--- /dev/null
	+++ b/src/test/data/txcreatedata1.hex
	@@ -0,0 +1 @@
	+01000000011f5c38dfcf6f1a5f5a87c416076d392c87e6d41970d5ad5e477a02d66bde97580000000000ffffffff0280a81201000000001976a9141fc11f39be1729bf973a7ab6a615ca4729d6457488ac0084d71700000000526a4c4f54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e00000000
	diff --git a/src/test/data/txcreatedata2.hex b/src/test/data/txcreatedata2.hex
	new file mode 100644
	index 000000000..3c7644c29
	--- /dev/null
	+++ b/src/test/data/txcreatedata2.hex
	@@ -0,0 +1 @@
	+01000000011f5c38dfcf6f1a5f5a87c416076d392c87e6d41970d5ad5e477a02d66bde97580000000000ffffffff0280a81201000000001976a9141fc11f39be1729bf973a7ab6a615ca4729d6457488ac0000000000000000526a4c4f54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e00000000

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 21:34 (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5865978
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions