Branch data Line data Source code
1 : : // Copyright (c) 2009-2022 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 : : #if defined(HAVE_CONFIG_H)
6 : : #include <config/bitcoin-config.h>
7 : : #endif
8 : :
9 : : #include <chainparamsbase.h>
10 : : #include <clientversion.h>
11 : : #include <coins.h>
12 : : #include <common/args.h>
13 : : #include <common/system.h>
14 : : #include <compat/compat.h>
15 : : #include <consensus/amount.h>
16 : : #include <consensus/consensus.h>
17 : : #include <core_io.h>
18 : : #include <key_io.h>
19 : : #include <policy/policy.h>
20 : : #include <primitives/transaction.h>
21 : : #include <script/script.h>
22 : : #include <script/sign.h>
23 : : #include <script/signingprovider.h>
24 : : #include <univalue.h>
25 : : #include <util/exception.h>
26 : : #include <util/fs.h>
27 : : #include <util/moneystr.h>
28 : : #include <util/rbf.h>
29 : : #include <util/strencodings.h>
30 : : #include <util/string.h>
31 : : #include <util/translation.h>
32 : :
33 : : #include <cstdio>
34 : : #include <functional>
35 : : #include <memory>
36 : :
37 : : static bool fCreateBlank;
38 : 0 : static std::map<std::string,UniValue> registers;
39 : : static const int CONTINUE_EXECUTION=-1;
40 : :
41 : 0 : const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
42 : :
43 : 0 : static void SetupBitcoinTxArgs(ArgsManager &argsman)
44 : : {
45 : 0 : SetupHelpOptions(argsman);
46 : :
47 : 0 : argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
48 : 0 : argsman.AddArg("-create", "Create new, empty TX.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
49 : 0 : argsman.AddArg("-json", "Select JSON output", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
50 : 0 : argsman.AddArg("-txid", "Output only the hex-encoded transaction id of the resultant transaction.", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
51 : 0 : SetupChainParamsBaseOptions(argsman);
52 : :
53 : 0 : argsman.AddArg("delin=N", "Delete input N from TX", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
54 : 0 : argsman.AddArg("delout=N", "Delete output N from TX", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
55 : 0 : argsman.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", "Add input to TX", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
56 : 0 : argsman.AddArg("locktime=N", "Set TX lock time to N", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
57 : 0 : argsman.AddArg("nversion=N", "Set TX version to N", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
58 : 0 : argsman.AddArg("outaddr=VALUE:ADDRESS", "Add address-based output to TX", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
59 : 0 : argsman.AddArg("outdata=[VALUE:]DATA", "Add data-based output to TX", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
60 : 0 : argsman.AddArg("outmultisig=VALUE:REQUIRED:PUBKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]", "Add Pay To n-of-m Multi-sig output to TX. n = REQUIRED, m = PUBKEYS. "
61 : : "Optionally add the \"W\" flag to produce a pay-to-witness-script-hash output. "
62 : 0 : "Optionally add the \"S\" flag to wrap the output in a pay-to-script-hash.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
63 : 0 : argsman.AddArg("outpubkey=VALUE:PUBKEY[:FLAGS]", "Add pay-to-pubkey output to TX. "
64 : : "Optionally add the \"W\" flag to produce a pay-to-witness-pubkey-hash output. "
65 : 0 : "Optionally add the \"S\" flag to wrap the output in a pay-to-script-hash.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
66 : 0 : argsman.AddArg("outscript=VALUE:SCRIPT[:FLAGS]", "Add raw script output to TX. "
67 : : "Optionally add the \"W\" flag to produce a pay-to-witness-script-hash output. "
68 : 0 : "Optionally add the \"S\" flag to wrap the output in a pay-to-script-hash.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
69 : 0 : argsman.AddArg("replaceable(=N)", "Set RBF opt-in sequence number for input N (if not provided, opt-in all available inputs)", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
70 : 0 : argsman.AddArg("sign=SIGHASH-FLAGS", "Add zero or more signatures to transaction. "
71 : : "This command requires JSON registers:"
72 : : "prevtxs=JSON object, "
73 : : "privatekeys=JSON object. "
74 : 0 : "See signrawtransactionwithkey docs for format of sighash flags, JSON objects.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMANDS);
75 : :
76 : 0 : argsman.AddArg("load=NAME:FILENAME", "Load JSON file FILENAME into register NAME", ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
77 : 0 : argsman.AddArg("set=NAME:JSON-STRING", "Set register NAME to given JSON-STRING", ArgsManager::ALLOW_ANY, OptionsCategory::REGISTER_COMMANDS);
78 : 0 : }
79 : :
80 : : //
81 : : // This function returns either one of EXIT_ codes when it's expected to stop the process or
82 : : // CONTINUE_EXECUTION when it's expected to continue further.
83 : : //
84 : 0 : static int AppInitRawTx(int argc, char* argv[])
85 : : {
86 : 0 : SetupBitcoinTxArgs(gArgs);
87 : 0 : std::string error;
88 : 0 : if (!gArgs.ParseParameters(argc, argv, error)) {
89 : 0 : tfm::format(std::cerr, "Error parsing command line arguments: %s\n", error);
90 : 0 : return EXIT_FAILURE;
91 : : }
92 : :
93 : : // Check for chain settings (Params() calls are only valid after this clause)
94 : : try {
95 : 0 : SelectParams(gArgs.GetChainType());
96 : 0 : } catch (const std::exception& e) {
97 : 0 : tfm::format(std::cerr, "Error: %s\n", e.what());
98 : 0 : return EXIT_FAILURE;
99 : 0 : }
100 : :
101 : 0 : fCreateBlank = gArgs.GetBoolArg("-create", false);
102 : :
103 : 0 : if (argc < 2 || HelpRequested(gArgs) || gArgs.IsArgSet("-version")) {
104 : : // First part of help message is specific to this utility
105 : 0 : std::string strUsage = PACKAGE_NAME " bitcoin-tx utility version " + FormatFullVersion() + "\n";
106 : :
107 : 0 : if (gArgs.IsArgSet("-version")) {
108 : 0 : strUsage += FormatParagraph(LicenseInfo());
109 : 0 : } else {
110 : 0 : strUsage += "\n"
111 : : "Usage: bitcoin-tx [options] <hex-tx> [commands] Update hex-encoded bitcoin transaction\n"
112 : : "or: bitcoin-tx [options] -create [commands] Create hex-encoded bitcoin transaction\n"
113 : : "\n";
114 : 0 : strUsage += gArgs.GetHelpMessage();
115 : : }
116 : :
117 : 0 : tfm::format(std::cout, "%s", strUsage);
118 : :
119 : 0 : if (argc < 2) {
120 : 0 : tfm::format(std::cerr, "Error: too few parameters\n");
121 : 0 : return EXIT_FAILURE;
122 : : }
123 : 0 : return EXIT_SUCCESS;
124 : 0 : }
125 : 0 : return CONTINUE_EXECUTION;
126 : 0 : }
127 : :
128 : 0 : static void RegisterSetJson(const std::string& key, const std::string& rawJson)
129 : : {
130 : 0 : UniValue val;
131 : 0 : if (!val.read(rawJson)) {
132 : 0 : std::string strErr = "Cannot parse JSON for key " + key;
133 : 0 : throw std::runtime_error(strErr);
134 : 0 : }
135 : :
136 : 0 : registers[key] = val;
137 : 0 : }
138 : :
139 : 0 : static void RegisterSet(const std::string& strInput)
140 : : {
141 : : // separate NAME:VALUE in string
142 : 0 : size_t pos = strInput.find(':');
143 : 0 : if ((pos == std::string::npos) ||
144 : 0 : (pos == 0) ||
145 : 0 : (pos == (strInput.size() - 1)))
146 : 0 : throw std::runtime_error("Register input requires NAME:VALUE");
147 : :
148 : 0 : std::string key = strInput.substr(0, pos);
149 : 0 : std::string valStr = strInput.substr(pos + 1, std::string::npos);
150 : :
151 : 0 : RegisterSetJson(key, valStr);
152 : 0 : }
153 : :
154 : 0 : static void RegisterLoad(const std::string& strInput)
155 : : {
156 : : // separate NAME:FILENAME in string
157 : 0 : size_t pos = strInput.find(':');
158 : 0 : if ((pos == std::string::npos) ||
159 : 0 : (pos == 0) ||
160 : 0 : (pos == (strInput.size() - 1)))
161 : 0 : throw std::runtime_error("Register load requires NAME:FILENAME");
162 : :
163 : 0 : std::string key = strInput.substr(0, pos);
164 : 0 : std::string filename = strInput.substr(pos + 1, std::string::npos);
165 : :
166 : 0 : FILE *f = fsbridge::fopen(filename.c_str(), "r");
167 : 0 : if (!f) {
168 : 0 : std::string strErr = "Cannot open file " + filename;
169 : 0 : throw std::runtime_error(strErr);
170 : 0 : }
171 : :
172 : : // load file chunks into one big buffer
173 : 0 : std::string valStr;
174 : 0 : while ((!feof(f)) && (!ferror(f))) {
175 : : char buf[4096];
176 : 0 : int bread = fread(buf, 1, sizeof(buf), f);
177 : 0 : if (bread <= 0)
178 : 0 : break;
179 : :
180 : 0 : valStr.insert(valStr.size(), buf, bread);
181 : : }
182 : :
183 : 0 : int error = ferror(f);
184 : 0 : fclose(f);
185 : :
186 : 0 : if (error) {
187 : 0 : std::string strErr = "Error reading file " + filename;
188 : 0 : throw std::runtime_error(strErr);
189 : 0 : }
190 : :
191 : : // evaluate as JSON buffer register
192 : 0 : RegisterSetJson(key, valStr);
193 : 0 : }
194 : :
195 : 0 : static CAmount ExtractAndValidateValue(const std::string& strValue)
196 : : {
197 : 0 : if (std::optional<CAmount> parsed = ParseMoney(strValue)) {
198 : 0 : return parsed.value();
199 : : } else {
200 : 0 : throw std::runtime_error("invalid TX output value");
201 : : }
202 : 0 : }
203 : :
204 : 0 : static void MutateTxVersion(CMutableTransaction& tx, const std::string& cmdVal)
205 : : {
206 : : int64_t newVersion;
207 : 0 : if (!ParseInt64(cmdVal, &newVersion) || newVersion < 1 || newVersion > TX_MAX_STANDARD_VERSION) {
208 : 0 : throw std::runtime_error("Invalid TX version requested: '" + cmdVal + "'");
209 : : }
210 : :
211 : 0 : tx.nVersion = (int) newVersion;
212 : 0 : }
213 : :
214 : 0 : static void MutateTxLocktime(CMutableTransaction& tx, const std::string& cmdVal)
215 : : {
216 : : int64_t newLocktime;
217 : 0 : if (!ParseInt64(cmdVal, &newLocktime) || newLocktime < 0LL || newLocktime > 0xffffffffLL)
218 : 0 : throw std::runtime_error("Invalid TX locktime requested: '" + cmdVal + "'");
219 : :
220 : 0 : tx.nLockTime = (unsigned int) newLocktime;
221 : 0 : }
222 : :
223 : 0 : static void MutateTxRBFOptIn(CMutableTransaction& tx, const std::string& strInIdx)
224 : : {
225 : : // parse requested index
226 : : int64_t inIdx;
227 : 0 : if (!ParseInt64(strInIdx, &inIdx) || inIdx < 0 || inIdx >= static_cast<int64_t>(tx.vin.size())) {
228 : 0 : throw std::runtime_error("Invalid TX input index '" + strInIdx + "'");
229 : : }
230 : :
231 : : // set the nSequence to MAX_INT - 2 (= RBF opt in flag)
232 : 0 : int cnt = 0;
233 : 0 : for (CTxIn& txin : tx.vin) {
234 : 0 : if (strInIdx == "" || cnt == inIdx) {
235 : 0 : if (txin.nSequence > MAX_BIP125_RBF_SEQUENCE) {
236 : 0 : txin.nSequence = MAX_BIP125_RBF_SEQUENCE;
237 : 0 : }
238 : 0 : }
239 : 0 : ++cnt;
240 : : }
241 : 0 : }
242 : :
243 : : template <typename T>
244 : 0 : static T TrimAndParse(const std::string& int_str, const std::string& err)
245 : : {
246 : 0 : const auto parsed{ToIntegral<T>(TrimStringView(int_str))};
247 : 0 : if (!parsed.has_value()) {
248 : 0 : throw std::runtime_error(err + " '" + int_str + "'");
249 : : }
250 : 0 : return parsed.value();
251 : 0 : }
252 : :
253 : 0 : static void MutateTxAddInput(CMutableTransaction& tx, const std::string& strInput)
254 : : {
255 : 0 : std::vector<std::string> vStrInputParts = SplitString(strInput, ':');
256 : :
257 : : // separate TXID:VOUT in string
258 : 0 : if (vStrInputParts.size()<2)
259 : 0 : throw std::runtime_error("TX input missing separator");
260 : :
261 : : // extract and validate TXID
262 : 0 : uint256 txid;
263 : 0 : if (!ParseHashStr(vStrInputParts[0], txid)) {
264 : 0 : throw std::runtime_error("invalid TX input txid");
265 : : }
266 : :
267 : : static const unsigned int minTxOutSz = 9;
268 : : static const unsigned int maxVout = MAX_BLOCK_WEIGHT / (WITNESS_SCALE_FACTOR * minTxOutSz);
269 : :
270 : : // extract and validate vout
271 : 0 : const std::string& strVout = vStrInputParts[1];
272 : : int64_t vout;
273 : 0 : if (!ParseInt64(strVout, &vout) || vout < 0 || vout > static_cast<int64_t>(maxVout))
274 : 0 : throw std::runtime_error("invalid TX input vout '" + strVout + "'");
275 : :
276 : : // extract the optional sequence number
277 : 0 : uint32_t nSequenceIn = CTxIn::SEQUENCE_FINAL;
278 : 0 : if (vStrInputParts.size() > 2) {
279 : 0 : nSequenceIn = TrimAndParse<uint32_t>(vStrInputParts.at(2), "invalid TX sequence id");
280 : 0 : }
281 : :
282 : : // append to transaction input list
283 : 0 : CTxIn txin(txid, vout, CScript(), nSequenceIn);
284 : 0 : tx.vin.push_back(txin);
285 : 0 : }
286 : :
287 : 0 : static void MutateTxAddOutAddr(CMutableTransaction& tx, const std::string& strInput)
288 : : {
289 : : // Separate into VALUE:ADDRESS
290 : 0 : std::vector<std::string> vStrInputParts = SplitString(strInput, ':');
291 : :
292 : 0 : if (vStrInputParts.size() != 2)
293 : 0 : throw std::runtime_error("TX output missing or too many separators");
294 : :
295 : : // Extract and validate VALUE
296 : 0 : CAmount value = ExtractAndValidateValue(vStrInputParts[0]);
297 : :
298 : : // extract and validate ADDRESS
299 : 0 : std::string strAddr = vStrInputParts[1];
300 : 0 : CTxDestination destination = DecodeDestination(strAddr);
301 : 0 : if (!IsValidDestination(destination)) {
302 : 0 : throw std::runtime_error("invalid TX output address");
303 : : }
304 : 0 : CScript scriptPubKey = GetScriptForDestination(destination);
305 : :
306 : : // construct TxOut, append to transaction output list
307 : 0 : CTxOut txout(value, scriptPubKey);
308 : 0 : tx.vout.push_back(txout);
309 : 0 : }
310 : :
311 : 0 : static void MutateTxAddOutPubKey(CMutableTransaction& tx, const std::string& strInput)
312 : : {
313 : : // Separate into VALUE:PUBKEY[:FLAGS]
314 : 0 : std::vector<std::string> vStrInputParts = SplitString(strInput, ':');
315 : :
316 : 0 : if (vStrInputParts.size() < 2 || vStrInputParts.size() > 3)
317 : 0 : throw std::runtime_error("TX output missing or too many separators");
318 : :
319 : : // Extract and validate VALUE
320 : 0 : CAmount value = ExtractAndValidateValue(vStrInputParts[0]);
321 : :
322 : : // Extract and validate PUBKEY
323 : 0 : CPubKey pubkey(ParseHex(vStrInputParts[1]));
324 : 0 : if (!pubkey.IsFullyValid())
325 : 0 : throw std::runtime_error("invalid TX output pubkey");
326 : 0 : CScript scriptPubKey = GetScriptForRawPubKey(pubkey);
327 : :
328 : : // Extract and validate FLAGS
329 : 0 : bool bSegWit = false;
330 : 0 : bool bScriptHash = false;
331 : 0 : if (vStrInputParts.size() == 3) {
332 : 0 : std::string flags = vStrInputParts[2];
333 : 0 : bSegWit = (flags.find('W') != std::string::npos);
334 : 0 : bScriptHash = (flags.find('S') != std::string::npos);
335 : 0 : }
336 : :
337 : 0 : if (bSegWit) {
338 : 0 : if (!pubkey.IsCompressed()) {
339 : 0 : throw std::runtime_error("Uncompressed pubkeys are not useable for SegWit outputs");
340 : : }
341 : : // Build a P2WPKH script
342 : 0 : scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(pubkey));
343 : 0 : }
344 : 0 : if (bScriptHash) {
345 : : // Get the ID for the script, and then construct a P2SH destination for it.
346 : 0 : scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
347 : 0 : }
348 : :
349 : : // construct TxOut, append to transaction output list
350 : 0 : CTxOut txout(value, scriptPubKey);
351 : 0 : tx.vout.push_back(txout);
352 : 0 : }
353 : :
354 : 0 : static void MutateTxAddOutMultiSig(CMutableTransaction& tx, const std::string& strInput)
355 : : {
356 : : // Separate into VALUE:REQUIRED:NUMKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]
357 : 0 : std::vector<std::string> vStrInputParts = SplitString(strInput, ':');
358 : :
359 : : // Check that there are enough parameters
360 : 0 : if (vStrInputParts.size()<3)
361 : 0 : throw std::runtime_error("Not enough multisig parameters");
362 : :
363 : : // Extract and validate VALUE
364 : 0 : CAmount value = ExtractAndValidateValue(vStrInputParts[0]);
365 : :
366 : : // Extract REQUIRED
367 : 0 : const uint32_t required{TrimAndParse<uint32_t>(vStrInputParts.at(1), "invalid multisig required number")};
368 : :
369 : : // Extract NUMKEYS
370 : 0 : const uint32_t numkeys{TrimAndParse<uint32_t>(vStrInputParts.at(2), "invalid multisig total number")};
371 : :
372 : : // Validate there are the correct number of pubkeys
373 : 0 : if (vStrInputParts.size() < numkeys + 3)
374 : 0 : throw std::runtime_error("incorrect number of multisig pubkeys");
375 : :
376 : 0 : if (required < 1 || required > MAX_PUBKEYS_PER_MULTISIG || numkeys < 1 || numkeys > MAX_PUBKEYS_PER_MULTISIG || numkeys < required)
377 : 0 : throw std::runtime_error("multisig parameter mismatch. Required " \
378 : 0 : + ToString(required) + " of " + ToString(numkeys) + "signatures.");
379 : :
380 : : // extract and validate PUBKEYs
381 : 0 : std::vector<CPubKey> pubkeys;
382 : 0 : for(int pos = 1; pos <= int(numkeys); pos++) {
383 : 0 : CPubKey pubkey(ParseHex(vStrInputParts[pos + 2]));
384 : 0 : if (!pubkey.IsFullyValid())
385 : 0 : throw std::runtime_error("invalid TX output pubkey");
386 : 0 : pubkeys.push_back(pubkey);
387 : 0 : }
388 : :
389 : : // Extract FLAGS
390 : 0 : bool bSegWit = false;
391 : 0 : bool bScriptHash = false;
392 : 0 : if (vStrInputParts.size() == numkeys + 4) {
393 : 0 : std::string flags = vStrInputParts.back();
394 : 0 : bSegWit = (flags.find('W') != std::string::npos);
395 : 0 : bScriptHash = (flags.find('S') != std::string::npos);
396 : 0 : }
397 : 0 : else if (vStrInputParts.size() > numkeys + 4) {
398 : : // Validate that there were no more parameters passed
399 : 0 : throw std::runtime_error("Too many parameters");
400 : : }
401 : :
402 : 0 : CScript scriptPubKey = GetScriptForMultisig(required, pubkeys);
403 : :
404 : 0 : if (bSegWit) {
405 : 0 : for (const CPubKey& pubkey : pubkeys) {
406 : 0 : if (!pubkey.IsCompressed()) {
407 : 0 : throw std::runtime_error("Uncompressed pubkeys are not useable for SegWit outputs");
408 : : }
409 : : }
410 : : // Build a P2WSH with the multisig script
411 : 0 : scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(scriptPubKey));
412 : 0 : }
413 : 0 : if (bScriptHash) {
414 : 0 : if (scriptPubKey.size() > MAX_SCRIPT_ELEMENT_SIZE) {
415 : 0 : throw std::runtime_error(strprintf(
416 : 0 : "redeemScript exceeds size limit: %d > %d", scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
417 : : }
418 : : // Get the ID for the script, and then construct a P2SH destination for it.
419 : 0 : scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
420 : 0 : }
421 : :
422 : : // construct TxOut, append to transaction output list
423 : 0 : CTxOut txout(value, scriptPubKey);
424 : 0 : tx.vout.push_back(txout);
425 : 0 : }
426 : :
427 : 0 : static void MutateTxAddOutData(CMutableTransaction& tx, const std::string& strInput)
428 : : {
429 : 0 : CAmount value = 0;
430 : :
431 : : // separate [VALUE:]DATA in string
432 : 0 : size_t pos = strInput.find(':');
433 : :
434 : 0 : if (pos==0)
435 : 0 : throw std::runtime_error("TX output value not specified");
436 : :
437 : 0 : if (pos == std::string::npos) {
438 : 0 : pos = 0;
439 : 0 : } else {
440 : : // Extract and validate VALUE
441 : 0 : value = ExtractAndValidateValue(strInput.substr(0, pos));
442 : 0 : ++pos;
443 : : }
444 : :
445 : : // extract and validate DATA
446 : 0 : const std::string strData{strInput.substr(pos, std::string::npos)};
447 : :
448 : 0 : if (!IsHex(strData))
449 : 0 : throw std::runtime_error("invalid TX output data");
450 : :
451 : 0 : std::vector<unsigned char> data = ParseHex(strData);
452 : :
453 : 0 : CTxOut txout(value, CScript() << OP_RETURN << data);
454 : 0 : tx.vout.push_back(txout);
455 : 0 : }
456 : :
457 : 0 : static void MutateTxAddOutScript(CMutableTransaction& tx, const std::string& strInput)
458 : : {
459 : : // separate VALUE:SCRIPT[:FLAGS]
460 : 0 : std::vector<std::string> vStrInputParts = SplitString(strInput, ':');
461 : 0 : if (vStrInputParts.size() < 2)
462 : 0 : throw std::runtime_error("TX output missing separator");
463 : :
464 : : // Extract and validate VALUE
465 : 0 : CAmount value = ExtractAndValidateValue(vStrInputParts[0]);
466 : :
467 : : // extract and validate script
468 : 0 : std::string strScript = vStrInputParts[1];
469 : 0 : CScript scriptPubKey = ParseScript(strScript);
470 : :
471 : : // Extract FLAGS
472 : 0 : bool bSegWit = false;
473 : 0 : bool bScriptHash = false;
474 : 0 : if (vStrInputParts.size() == 3) {
475 : 0 : std::string flags = vStrInputParts.back();
476 : 0 : bSegWit = (flags.find('W') != std::string::npos);
477 : 0 : bScriptHash = (flags.find('S') != std::string::npos);
478 : 0 : }
479 : :
480 : 0 : if (scriptPubKey.size() > MAX_SCRIPT_SIZE) {
481 : 0 : throw std::runtime_error(strprintf(
482 : 0 : "script exceeds size limit: %d > %d", scriptPubKey.size(), MAX_SCRIPT_SIZE));
483 : : }
484 : :
485 : 0 : if (bSegWit) {
486 : 0 : scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(scriptPubKey));
487 : 0 : }
488 : 0 : if (bScriptHash) {
489 : 0 : if (scriptPubKey.size() > MAX_SCRIPT_ELEMENT_SIZE) {
490 : 0 : throw std::runtime_error(strprintf(
491 : 0 : "redeemScript exceeds size limit: %d > %d", scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
492 : : }
493 : 0 : scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
494 : 0 : }
495 : :
496 : : // construct TxOut, append to transaction output list
497 : 0 : CTxOut txout(value, scriptPubKey);
498 : 0 : tx.vout.push_back(txout);
499 : 0 : }
500 : :
501 : 0 : static void MutateTxDelInput(CMutableTransaction& tx, const std::string& strInIdx)
502 : : {
503 : : // parse requested deletion index
504 : : int64_t inIdx;
505 : 0 : if (!ParseInt64(strInIdx, &inIdx) || inIdx < 0 || inIdx >= static_cast<int64_t>(tx.vin.size())) {
506 : 0 : throw std::runtime_error("Invalid TX input index '" + strInIdx + "'");
507 : : }
508 : :
509 : : // delete input from transaction
510 : 0 : tx.vin.erase(tx.vin.begin() + inIdx);
511 : 0 : }
512 : :
513 : 0 : static void MutateTxDelOutput(CMutableTransaction& tx, const std::string& strOutIdx)
514 : : {
515 : : // parse requested deletion index
516 : : int64_t outIdx;
517 : 0 : if (!ParseInt64(strOutIdx, &outIdx) || outIdx < 0 || outIdx >= static_cast<int64_t>(tx.vout.size())) {
518 : 0 : throw std::runtime_error("Invalid TX output index '" + strOutIdx + "'");
519 : : }
520 : :
521 : : // delete output from transaction
522 : 0 : tx.vout.erase(tx.vout.begin() + outIdx);
523 : 0 : }
524 : :
525 : : static const unsigned int N_SIGHASH_OPTS = 7;
526 : : static const struct {
527 : : const char *flagStr;
528 : : int flags;
529 : : } sighashOptions[N_SIGHASH_OPTS] = {
530 : : {"DEFAULT", SIGHASH_DEFAULT},
531 : : {"ALL", SIGHASH_ALL},
532 : : {"NONE", SIGHASH_NONE},
533 : : {"SINGLE", SIGHASH_SINGLE},
534 : : {"ALL|ANYONECANPAY", SIGHASH_ALL|SIGHASH_ANYONECANPAY},
535 : : {"NONE|ANYONECANPAY", SIGHASH_NONE|SIGHASH_ANYONECANPAY},
536 : : {"SINGLE|ANYONECANPAY", SIGHASH_SINGLE|SIGHASH_ANYONECANPAY},
537 : : };
538 : :
539 : 0 : static bool findSighashFlags(int& flags, const std::string& flagStr)
540 : : {
541 : 0 : flags = 0;
542 : :
543 : 0 : for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
544 : 0 : if (flagStr == sighashOptions[i].flagStr) {
545 : 0 : flags = sighashOptions[i].flags;
546 : 0 : return true;
547 : : }
548 : 0 : }
549 : :
550 : 0 : return false;
551 : 0 : }
552 : :
553 : 0 : static CAmount AmountFromValue(const UniValue& value)
554 : : {
555 : 0 : if (!value.isNum() && !value.isStr())
556 : 0 : throw std::runtime_error("Amount is not a number or string");
557 : : CAmount amount;
558 : 0 : if (!ParseFixedPoint(value.getValStr(), 8, &amount))
559 : 0 : throw std::runtime_error("Invalid amount");
560 : 0 : if (!MoneyRange(amount))
561 : 0 : throw std::runtime_error("Amount out of range");
562 : 0 : return amount;
563 : 0 : }
564 : :
565 : 0 : static std::vector<unsigned char> ParseHexUV(const UniValue& v, const std::string& strName)
566 : : {
567 : 0 : std::string strHex;
568 : 0 : if (v.isStr())
569 : 0 : strHex = v.getValStr();
570 : 0 : if (!IsHex(strHex))
571 : 0 : throw std::runtime_error(strName + " must be hexadecimal string (not '" + strHex + "')");
572 : 0 : return ParseHex(strHex);
573 : 0 : }
574 : :
575 : 0 : static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
576 : : {
577 : 0 : int nHashType = SIGHASH_ALL;
578 : :
579 : 0 : if (flagStr.size() > 0)
580 : 0 : if (!findSighashFlags(nHashType, flagStr))
581 : 0 : throw std::runtime_error("unknown sighash flag/sign option");
582 : :
583 : : // mergedTx will end up with all the signatures; it
584 : : // starts as a clone of the raw tx:
585 : 0 : CMutableTransaction mergedTx{tx};
586 : 0 : const CMutableTransaction txv{tx};
587 : 0 : CCoinsView viewDummy;
588 : 0 : CCoinsViewCache view(&viewDummy);
589 : :
590 : 0 : if (!registers.count("privatekeys"))
591 : 0 : throw std::runtime_error("privatekeys register variable must be set.");
592 : 0 : FillableSigningProvider tempKeystore;
593 : 0 : UniValue keysObj = registers["privatekeys"];
594 : :
595 : 0 : for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {
596 : 0 : if (!keysObj[kidx].isStr())
597 : 0 : throw std::runtime_error("privatekey not a std::string");
598 : 0 : CKey key = DecodeSecret(keysObj[kidx].getValStr());
599 : 0 : if (!key.IsValid()) {
600 : 0 : throw std::runtime_error("privatekey not valid");
601 : : }
602 : 0 : tempKeystore.AddKey(key);
603 : 0 : }
604 : :
605 : : // Add previous txouts given in the RPC call:
606 : 0 : if (!registers.count("prevtxs"))
607 : 0 : throw std::runtime_error("prevtxs register variable must be set.");
608 : 0 : UniValue prevtxsObj = registers["prevtxs"];
609 : : {
610 : 0 : for (unsigned int previdx = 0; previdx < prevtxsObj.size(); previdx++) {
611 : 0 : const UniValue& prevOut = prevtxsObj[previdx];
612 : 0 : if (!prevOut.isObject())
613 : 0 : throw std::runtime_error("expected prevtxs internal object");
614 : :
615 : 0 : std::map<std::string, UniValue::VType> types = {
616 : 0 : {"txid", UniValue::VSTR},
617 : 0 : {"vout", UniValue::VNUM},
618 : 0 : {"scriptPubKey", UniValue::VSTR},
619 : : };
620 : 0 : if (!prevOut.checkObject(types))
621 : 0 : throw std::runtime_error("prevtxs internal object typecheck fail");
622 : :
623 : 0 : uint256 txid;
624 : 0 : if (!ParseHashStr(prevOut["txid"].get_str(), txid)) {
625 : 0 : throw std::runtime_error("txid must be hexadecimal string (not '" + prevOut["txid"].get_str() + "')");
626 : : }
627 : :
628 : 0 : const int nOut = prevOut["vout"].getInt<int>();
629 : 0 : if (nOut < 0)
630 : 0 : throw std::runtime_error("vout cannot be negative");
631 : :
632 : 0 : COutPoint out(txid, nOut);
633 : 0 : std::vector<unsigned char> pkData(ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
634 : 0 : CScript scriptPubKey(pkData.begin(), pkData.end());
635 : :
636 : : {
637 : 0 : const Coin& coin = view.AccessCoin(out);
638 : 0 : if (!coin.IsSpent() && coin.out.scriptPubKey != scriptPubKey) {
639 : 0 : std::string err("Previous output scriptPubKey mismatch:\n");
640 : 0 : err = err + ScriptToAsmStr(coin.out.scriptPubKey) + "\nvs:\n"+
641 : 0 : ScriptToAsmStr(scriptPubKey);
642 : 0 : throw std::runtime_error(err);
643 : 0 : }
644 : 0 : Coin newcoin;
645 : 0 : newcoin.out.scriptPubKey = scriptPubKey;
646 : 0 : newcoin.out.nValue = MAX_MONEY;
647 : 0 : if (prevOut.exists("amount")) {
648 : 0 : newcoin.out.nValue = AmountFromValue(prevOut["amount"]);
649 : 0 : }
650 : 0 : newcoin.nHeight = 1;
651 : 0 : view.AddCoin(out, std::move(newcoin), true);
652 : 0 : }
653 : :
654 : : // if redeemScript given and private keys given,
655 : : // add redeemScript to the tempKeystore so it can be signed:
656 : 0 : if ((scriptPubKey.IsPayToScriptHash() || scriptPubKey.IsPayToWitnessScriptHash()) &&
657 : 0 : prevOut.exists("redeemScript")) {
658 : 0 : UniValue v = prevOut["redeemScript"];
659 : 0 : std::vector<unsigned char> rsData(ParseHexUV(v, "redeemScript"));
660 : 0 : CScript redeemScript(rsData.begin(), rsData.end());
661 : 0 : tempKeystore.AddCScript(redeemScript);
662 : 0 : }
663 : 0 : }
664 : : }
665 : :
666 : 0 : const FillableSigningProvider& keystore = tempKeystore;
667 : :
668 : 0 : bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);
669 : :
670 : : // Sign what we can:
671 : 0 : for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
672 : 0 : CTxIn& txin = mergedTx.vin[i];
673 : 0 : const Coin& coin = view.AccessCoin(txin.prevout);
674 : 0 : if (coin.IsSpent()) {
675 : 0 : continue;
676 : : }
677 : 0 : const CScript& prevPubKey = coin.out.scriptPubKey;
678 : 0 : const CAmount& amount = coin.out.nValue;
679 : :
680 : 0 : SignatureData sigdata = DataFromTransaction(mergedTx, i, coin.out);
681 : : // Only sign SIGHASH_SINGLE if there's a corresponding output:
682 : 0 : if (!fHashSingle || (i < mergedTx.vout.size()))
683 : 0 : ProduceSignature(keystore, MutableTransactionSignatureCreator(mergedTx, i, amount, nHashType), prevPubKey, sigdata);
684 : :
685 : 0 : if (amount == MAX_MONEY && !sigdata.scriptWitness.IsNull()) {
686 : 0 : throw std::runtime_error(strprintf("Missing amount for CTxOut with scriptPubKey=%s", HexStr(prevPubKey)));
687 : : }
688 : :
689 : 0 : UpdateInput(txin, sigdata);
690 : 0 : }
691 : :
692 : 0 : tx = mergedTx;
693 : 0 : }
694 : :
695 : : class Secp256k1Init
696 : : {
697 : : public:
698 : 0 : Secp256k1Init() {
699 : 0 : ECC_Start();
700 : 0 : }
701 : 0 : ~Secp256k1Init() {
702 : 0 : ECC_Stop();
703 : 0 : }
704 : : };
705 : :
706 : 0 : static void MutateTx(CMutableTransaction& tx, const std::string& command,
707 : : const std::string& commandVal)
708 : : {
709 : 0 : std::unique_ptr<Secp256k1Init> ecc;
710 : :
711 : 0 : if (command == "nversion")
712 : 0 : MutateTxVersion(tx, commandVal);
713 : 0 : else if (command == "locktime")
714 : 0 : MutateTxLocktime(tx, commandVal);
715 : 0 : else if (command == "replaceable") {
716 : 0 : MutateTxRBFOptIn(tx, commandVal);
717 : 0 : }
718 : :
719 : 0 : else if (command == "delin")
720 : 0 : MutateTxDelInput(tx, commandVal);
721 : 0 : else if (command == "in")
722 : 0 : MutateTxAddInput(tx, commandVal);
723 : :
724 : 0 : else if (command == "delout")
725 : 0 : MutateTxDelOutput(tx, commandVal);
726 : 0 : else if (command == "outaddr")
727 : 0 : MutateTxAddOutAddr(tx, commandVal);
728 : 0 : else if (command == "outpubkey") {
729 : 0 : ecc.reset(new Secp256k1Init());
730 : 0 : MutateTxAddOutPubKey(tx, commandVal);
731 : 0 : } else if (command == "outmultisig") {
732 : 0 : ecc.reset(new Secp256k1Init());
733 : 0 : MutateTxAddOutMultiSig(tx, commandVal);
734 : 0 : } else if (command == "outscript")
735 : 0 : MutateTxAddOutScript(tx, commandVal);
736 : 0 : else if (command == "outdata")
737 : 0 : MutateTxAddOutData(tx, commandVal);
738 : :
739 : 0 : else if (command == "sign") {
740 : 0 : ecc.reset(new Secp256k1Init());
741 : 0 : MutateTxSign(tx, commandVal);
742 : 0 : }
743 : :
744 : 0 : else if (command == "load")
745 : 0 : RegisterLoad(commandVal);
746 : :
747 : 0 : else if (command == "set")
748 : 0 : RegisterSet(commandVal);
749 : :
750 : : else
751 : 0 : throw std::runtime_error("unknown command");
752 : 0 : }
753 : :
754 : 0 : static void OutputTxJSON(const CTransaction& tx)
755 : : {
756 : 0 : UniValue entry(UniValue::VOBJ);
757 : 0 : TxToUniv(tx, /*block_hash=*/uint256(), entry);
758 : :
759 : 0 : std::string jsonOutput = entry.write(4);
760 : 0 : tfm::format(std::cout, "%s\n", jsonOutput);
761 : 0 : }
762 : :
763 : 0 : static void OutputTxHash(const CTransaction& tx)
764 : : {
765 : 0 : std::string strHexHash = tx.GetHash().GetHex(); // the hex-encoded transaction hash (aka the transaction id)
766 : :
767 : 0 : tfm::format(std::cout, "%s\n", strHexHash);
768 : 0 : }
769 : :
770 : 0 : static void OutputTxHex(const CTransaction& tx)
771 : : {
772 : 0 : std::string strHex = EncodeHexTx(tx);
773 : :
774 : 0 : tfm::format(std::cout, "%s\n", strHex);
775 : 0 : }
776 : :
777 : 0 : static void OutputTx(const CTransaction& tx)
778 : : {
779 : 0 : if (gArgs.GetBoolArg("-json", false))
780 : 0 : OutputTxJSON(tx);
781 : 0 : else if (gArgs.GetBoolArg("-txid", false))
782 : 0 : OutputTxHash(tx);
783 : : else
784 : 0 : OutputTxHex(tx);
785 : 0 : }
786 : :
787 : 0 : static std::string readStdin()
788 : : {
789 : : char buf[4096];
790 : 0 : std::string ret;
791 : :
792 : 0 : while (!feof(stdin)) {
793 : 0 : size_t bread = fread(buf, 1, sizeof(buf), stdin);
794 : 0 : ret.append(buf, bread);
795 : 0 : if (bread < sizeof(buf))
796 : 0 : break;
797 : : }
798 : :
799 : 0 : if (ferror(stdin))
800 : 0 : throw std::runtime_error("error reading stdin");
801 : :
802 : 0 : return TrimString(ret);
803 : 0 : }
804 : :
805 : 0 : static int CommandLineRawTx(int argc, char* argv[])
806 : : {
807 : 0 : std::string strPrint;
808 : 0 : int nRet = 0;
809 : : try {
810 : : // Skip switches; Permit common stdin convention "-"
811 : 0 : while (argc > 1 && IsSwitchChar(argv[1][0]) &&
812 : 0 : (argv[1][1] != 0)) {
813 : 0 : argc--;
814 : 0 : argv++;
815 : : }
816 : :
817 : 0 : CMutableTransaction tx;
818 : : int startArg;
819 : :
820 : 0 : if (!fCreateBlank) {
821 : : // require at least one param
822 : 0 : if (argc < 2)
823 : 0 : throw std::runtime_error("too few parameters");
824 : :
825 : : // param: hex-encoded bitcoin transaction
826 : 0 : std::string strHexTx(argv[1]);
827 : 0 : if (strHexTx == "-") // "-" implies standard input
828 : 0 : strHexTx = readStdin();
829 : :
830 : 0 : if (!DecodeHexTx(tx, strHexTx, true))
831 : 0 : throw std::runtime_error("invalid transaction encoding");
832 : :
833 : 0 : startArg = 2;
834 : 0 : } else
835 : 0 : startArg = 1;
836 : :
837 : 0 : for (int i = startArg; i < argc; i++) {
838 : 0 : std::string arg = argv[i];
839 : 0 : std::string key, value;
840 : 0 : size_t eqpos = arg.find('=');
841 : 0 : if (eqpos == std::string::npos)
842 : 0 : key = arg;
843 : : else {
844 : 0 : key = arg.substr(0, eqpos);
845 : 0 : value = arg.substr(eqpos + 1);
846 : : }
847 : :
848 : 0 : MutateTx(tx, key, value);
849 : 0 : }
850 : :
851 : 0 : OutputTx(CTransaction(tx));
852 : 0 : }
853 : : catch (const std::exception& e) {
854 : 0 : strPrint = std::string("error: ") + e.what();
855 : 0 : nRet = EXIT_FAILURE;
856 : 0 : }
857 : : catch (...) {
858 : 0 : PrintExceptionContinue(nullptr, "CommandLineRawTx()");
859 : 0 : throw;
860 : 0 : }
861 : :
862 : 0 : if (strPrint != "") {
863 : 0 : tfm::format(nRet == 0 ? std::cout : std::cerr, "%s\n", strPrint);
864 : 0 : }
865 : 0 : return nRet;
866 : 0 : }
867 : :
868 : 0 : MAIN_FUNCTION
869 : : {
870 : 0 : SetupEnvironment();
871 : :
872 : : try {
873 : 0 : int ret = AppInitRawTx(argc, argv);
874 : 0 : if (ret != CONTINUE_EXECUTION)
875 : 0 : return ret;
876 : 0 : }
877 : : catch (const std::exception& e) {
878 : 0 : PrintExceptionContinue(&e, "AppInitRawTx()");
879 : 0 : return EXIT_FAILURE;
880 : 0 : } catch (...) {
881 : 0 : PrintExceptionContinue(nullptr, "AppInitRawTx()");
882 : 0 : return EXIT_FAILURE;
883 : 0 : }
884 : :
885 : 0 : int ret = EXIT_FAILURE;
886 : : try {
887 : 0 : ret = CommandLineRawTx(argc, argv);
888 : 0 : }
889 : : catch (const std::exception& e) {
890 : 0 : PrintExceptionContinue(&e, "CommandLineRawTx()");
891 : 0 : } catch (...) {
892 : 0 : PrintExceptionContinue(nullptr, "CommandLineRawTx()");
893 : 0 : }
894 : 0 : return ret;
895 : 0 : }
|
