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