5#include <bitcoin-build-config.h>
63 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. "
66 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. "
69 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. "
72 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. "
75 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. "
94 tfm::format(std::cerr,
"Error parsing command line arguments: %s\n", error);
101 }
catch (
const std::exception& e) {
110 std::string strUsage = CLIENT_NAME
" bitcoin-tx utility version " +
FormatFullVersion() +
"\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"
119 "Usage: bitcoin-tx [options] <hex-tx> [commands]\n"
120 "or: bitcoin-tx [options] -create [commands]\n"
128 tfm::format(std::cerr,
"Error: too few parameters\n");
139 if (!val.
read(rawJson)) {
140 std::string strErr =
"Cannot parse JSON for key " + key;
141 throw std::runtime_error(strErr);
150 size_t pos = strInput.find(
':');
151 if ((pos == std::string::npos) ||
153 (pos == (strInput.size() - 1)))
154 throw std::runtime_error(
"Register input requires NAME:VALUE");
156 std::string key = strInput.substr(0, pos);
157 std::string valStr = strInput.substr(pos + 1, std::string::npos);
165 size_t pos = strInput.find(
':');
166 if ((pos == std::string::npos) ||
168 (pos == (strInput.size() - 1)))
169 throw std::runtime_error(
"Register load requires NAME:FILENAME");
171 std::string key = strInput.substr(0, pos);
172 std::string filename = strInput.substr(pos + 1, std::string::npos);
176 std::string strErr =
"Cannot open file " + filename;
177 throw std::runtime_error(strErr);
182 while ((!feof(f)) && (!ferror(f))) {
184 int bread = fread(buf, 1,
sizeof(buf), f);
188 valStr.insert(valStr.size(), buf, bread);
191 int error = ferror(f);
195 std::string strErr =
"Error reading file " + filename;
196 throw std::runtime_error(strErr);
205 if (std::optional<CAmount> parsed =
ParseMoney(strValue)) {
206 return parsed.value();
208 throw std::runtime_error(
"invalid TX output value");
214 const auto ver{ToIntegral<uint32_t>(cmdVal)};
216 throw std::runtime_error(
"Invalid TX version requested: '" + cmdVal +
"'");
223 const auto locktime{ToIntegral<uint32_t>(cmdVal)};
225 throw std::runtime_error(
"Invalid TX locktime requested: '" + cmdVal +
"'");
232 const auto idx{ToIntegral<uint32_t>(strInIdx)};
233 if (strInIdx !=
"" && (!idx || *idx >= tx.
vin.size())) {
234 throw std::runtime_error(
"Invalid TX input index '" + strInIdx +
"'");
240 if (strInIdx ==
"" || cnt == *idx) {
253 if (!parsed.has_value()) {
254 throw std::runtime_error(err +
" '" + int_str +
"'");
256 return parsed.value();
261 std::vector<std::string> vStrInputParts =
SplitString(strInput,
':');
264 if (vStrInputParts.size()<2)
265 throw std::runtime_error(
"TX input missing separator");
270 throw std::runtime_error(
"invalid TX input txid");
273 static const unsigned int minTxOutSz = 9;
277 const std::string& strVout = vStrInputParts[1];
278 const auto vout{ToIntegral<uint32_t>(strVout)};
279 if (!vout || *vout > maxVout) {
280 throw std::runtime_error(
"invalid TX input vout '" + strVout +
"'");
285 if (vStrInputParts.size() > 2) {
286 nSequenceIn = TrimAndParse<uint32_t>(vStrInputParts.at(2),
"invalid TX sequence id");
291 tx.
vin.push_back(txin);
297 std::vector<std::string> vStrInputParts =
SplitString(strInput,
':');
299 if (vStrInputParts.size() != 2)
300 throw std::runtime_error(
"TX output missing or too many separators");
306 const std::string& strAddr = vStrInputParts[1];
309 throw std::runtime_error(
"invalid TX output address");
314 CTxOut txout(value, scriptPubKey);
315 tx.
vout.push_back(txout);
321 std::vector<std::string> vStrInputParts =
SplitString(strInput,
':');
323 if (vStrInputParts.size() < 2 || vStrInputParts.size() > 3)
324 throw std::runtime_error(
"TX output missing or too many separators");
332 throw std::runtime_error(
"invalid TX output pubkey");
336 bool bSegWit =
false;
337 bool bScriptHash =
false;
338 if (vStrInputParts.size() == 3) {
339 const std::string&
flags = vStrInputParts[2];
340 bSegWit = (
flags.find(
'W') != std::string::npos);
341 bScriptHash = (
flags.find(
'S') != std::string::npos);
346 throw std::runtime_error(
"Uncompressed pubkeys are not useable for SegWit outputs");
357 CTxOut txout(value, scriptPubKey);
358 tx.
vout.push_back(txout);
364 std::vector<std::string> vStrInputParts =
SplitString(strInput,
':');
367 if (vStrInputParts.size()<3)
368 throw std::runtime_error(
"Not enough multisig parameters");
374 const uint32_t required{TrimAndParse<uint32_t>(vStrInputParts.at(1),
"invalid multisig required number")};
377 const uint32_t numkeys{TrimAndParse<uint32_t>(vStrInputParts.at(2),
"invalid multisig total number")};
380 if (vStrInputParts.size() < numkeys + 3)
381 throw std::runtime_error(
"incorrect number of multisig pubkeys");
384 throw std::runtime_error(
"multisig parameter mismatch. Required " \
388 std::vector<CPubKey> pubkeys;
389 for(
int pos = 1; pos <= int(numkeys); pos++) {
392 throw std::runtime_error(
"invalid TX output pubkey");
393 pubkeys.push_back(pubkey);
397 bool bSegWit =
false;
398 bool bScriptHash =
false;
399 if (vStrInputParts.size() == numkeys + 4) {
400 const std::string&
flags = vStrInputParts.back();
401 bSegWit = (
flags.find(
'W') != std::string::npos);
402 bScriptHash = (
flags.find(
'S') != std::string::npos);
404 else if (vStrInputParts.size() > numkeys + 4) {
406 throw std::runtime_error(
"Too many parameters");
412 for (
const CPubKey& pubkey : pubkeys) {
413 if (!pubkey.IsCompressed()) {
414 throw std::runtime_error(
"Uncompressed pubkeys are not useable for SegWit outputs");
430 CTxOut txout(value, scriptPubKey);
431 tx.
vout.push_back(txout);
439 size_t pos = strInput.find(
':');
442 throw std::runtime_error(
"TX output value not specified");
444 if (pos == std::string::npos) {
453 const std::string strData{strInput.substr(pos, std::string::npos)};
456 throw std::runtime_error(
"invalid TX output data");
461 tx.
vout.push_back(txout);
467 std::vector<std::string> vStrInputParts =
SplitString(strInput,
':');
468 if (vStrInputParts.size() < 2)
469 throw std::runtime_error(
"TX output missing separator");
475 const std::string& strScript = vStrInputParts[1];
479 bool bSegWit =
false;
480 bool bScriptHash =
false;
481 if (vStrInputParts.size() == 3) {
482 const std::string&
flags = vStrInputParts.back();
483 bSegWit = (
flags.find(
'W') != std::string::npos);
484 bScriptHash = (
flags.find(
'S') != std::string::npos);
504 CTxOut txout(value, scriptPubKey);
505 tx.
vout.push_back(txout);
510 const auto idx{ToIntegral<uint32_t>(strInIdx)};
511 if (!idx || idx >= tx.
vin.size()) {
512 throw std::runtime_error(
"Invalid TX input index '" + strInIdx +
"'");
514 tx.
vin.erase(tx.
vin.begin() + *idx);
519 const auto idx{ToIntegral<uint32_t>(strOutIdx)};
520 if (!idx || idx >= tx.
vout.size()) {
521 throw std::runtime_error(
"Invalid TX output index '" + strOutIdx +
"'");
523 tx.
vout.erase(tx.
vout.begin() + *idx);
557 throw std::runtime_error(
"Amount is not a number or string");
560 throw std::runtime_error(
"Invalid amount");
562 throw std::runtime_error(
"Amount out of range");
572 throw std::runtime_error(strName +
" must be hexadecimal string (not '" + strHex +
"')");
582 throw std::runtime_error(
"unknown sighash flag/sign option");
592 throw std::runtime_error(
"privatekeys register variable must be set.");
596 for (
unsigned int kidx = 0; kidx < keysObj.
size(); kidx++) {
597 if (!keysObj[kidx].isStr())
598 throw std::runtime_error(
"privatekey not a std::string");
601 throw std::runtime_error(
"privatekey not valid");
608 throw std::runtime_error(
"prevtxs register variable must be set.");
611 for (
unsigned int previdx = 0; previdx < prevtxsObj.
size(); previdx++) {
612 const UniValue& prevOut = prevtxsObj[previdx];
614 throw std::runtime_error(
"expected prevtxs internal object");
616 std::map<std::string, UniValue::VType> types = {
622 throw std::runtime_error(
"prevtxs internal object typecheck fail");
626 throw std::runtime_error(
"txid must be hexadecimal string (not '" + prevOut[
"txid"].get_str() +
"')");
629 const int nOut = prevOut[
"vout"].
getInt<
int>();
631 throw std::runtime_error(
"vout cannot be negative");
634 std::vector<unsigned char> pkData(
ParseHexUV(prevOut[
"scriptPubKey"],
"scriptPubKey"));
635 CScript scriptPubKey(pkData.begin(), pkData.end());
640 std::string err(
"Previous output scriptPubKey mismatch:\n");
643 throw std::runtime_error(err);
648 if (prevOut.
exists(
"amount")) {
658 prevOut.
exists(
"redeemScript")) {
659 UniValue v = prevOut[
"redeemScript"];
660 std::vector<unsigned char> rsData(
ParseHexUV(v,
"redeemScript"));
661 CScript redeemScript(rsData.begin(), rsData.end());
669 bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) ==
SIGHASH_SINGLE);
672 for (
unsigned int i = 0; i < mergedTx.vin.size(); i++) {
673 CTxIn& txin = mergedTx.vin[i];
683 if (!fHashSingle || (i < mergedTx.vout.size()))
687 throw std::runtime_error(
strprintf(
"Missing amount for CTxOut with scriptPubKey=%s",
HexStr(prevPubKey)));
697 const std::string& commandVal)
699 std::unique_ptr<ECC_Context> ecc;
703 else if (
command ==
"locktime")
705 else if (
command ==
"replaceable") {
718 else if (
command ==
"outpubkey") {
721 }
else if (
command ==
"outmultisig") {
724 }
else if (
command ==
"outscript")
741 throw std::runtime_error(
"unknown command");
749 std::string jsonOutput = entry.
write(4);
782 while (!feof(stdin)) {
783 size_t bread = fread(buf, 1,
sizeof(buf), stdin);
784 ret.append(buf, bread);
785 if (bread <
sizeof(buf))
790 throw std::runtime_error(
"error reading stdin");
813 throw std::runtime_error(
"too few parameters");
816 std::string strHexTx(argv[1]);
821 throw std::runtime_error(
"invalid transaction encoding");
827 for (
int i = startArg; i < argc; i++) {
828 std::string arg = argv[i];
829 std::string key, value;
830 size_t eqpos = arg.find(
'=');
831 if (eqpos == std::string::npos)
834 key = arg.substr(0, eqpos);
835 value = arg.substr(eqpos + 1);
843 catch (
const std::exception& e) {
844 strPrint = std::string(
"error: ") + e.what();
867 catch (
const std::exception& e) {
879 catch (
const std::exception& e) {
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
static constexpr CAmount MAX_MONEY
No amount larger than this (in satoshi) is valid.
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
bool HelpRequested(const ArgsManager &args)
void SetupHelpOptions(ArgsManager &args)
Add help options to the args manager.
bool IsSwitchChar(char c)
static bool findSighashFlags(int &flags, const std::string &flagStr)
static void OutputTxHash(const CTransaction &tx)
static const unsigned int N_SIGHASH_OPTS
static void MutateTxSign(CMutableTransaction &tx, const std::string &flagStr)
static const int CONTINUE_EXECUTION
static std::string readStdin()
static void OutputTxJSON(const CTransaction &tx)
static void RegisterSet(const std::string &strInput)
static void RegisterSetJson(const std::string &key, const std::string &rawJson)
static CAmount ExtractAndValidateValue(const std::string &strValue)
static std::vector< unsigned char > ParseHexUV(const UniValue &v, const std::string &strName)
static void MutateTxDelOutput(CMutableTransaction &tx, const std::string &strOutIdx)
static const struct @0 sighashOptions[N_SIGHASH_OPTS]
static CAmount AmountFromValue(const UniValue &value)
static void MutateTx(CMutableTransaction &tx, const std::string &command, const std::string &commandVal)
static T TrimAndParse(const std::string &int_str, const std::string &err)
static void MutateTxAddOutPubKey(CMutableTransaction &tx, const std::string &strInput)
static void MutateTxRBFOptIn(CMutableTransaction &tx, const std::string &strInIdx)
static void MutateTxAddOutData(CMutableTransaction &tx, const std::string &strInput)
static void MutateTxVersion(CMutableTransaction &tx, const std::string &cmdVal)
static void MutateTxAddOutAddr(CMutableTransaction &tx, const std::string &strInput)
static int CommandLineRawTx(int argc, char *argv[])
const TranslateFn G_TRANSLATION_FUN
Translate string to current locale using Qt.
static void OutputTxHex(const CTransaction &tx)
static void RegisterLoad(const std::string &strInput)
static void MutateTxDelInput(CMutableTransaction &tx, const std::string &strInIdx)
static int AppInitRawTx(int argc, char *argv[])
static void MutateTxAddInput(CMutableTransaction &tx, const std::string &strInput)
static std::map< std::string, UniValue > registers
static void SetupBitcoinTxArgs(ArgsManager &argsman)
static void MutateTxAddOutMultiSig(CMutableTransaction &tx, const std::string &strInput)
static void MutateTxAddOutScript(CMutableTransaction &tx, const std::string &strInput)
static void MutateTxLocktime(CMutableTransaction &tx, const std::string &cmdVal)
static void OutputTx(const CTransaction &tx)
void SelectParams(const ChainType chain)
Sets the params returned by Params() to those for the given chain type.
void SetupChainParamsBaseOptions(ArgsManager &argsman)
Set the arguments for chainparams.
@ ALLOW_ANY
disable validation
ChainType GetChainType() const
Returns the appropriate chain type from the program arguments.
bool ParseParameters(int argc, const char *const argv[], std::string &error)
std::string GetHelpMessage() const
Get the help string.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat)
Add argument.
CCoinsView that adds a memory cache for transactions to another CCoinsView.
void AddCoin(const COutPoint &outpoint, Coin &&coin, bool possible_overwrite)
Add a coin.
const Coin & AccessCoin(const COutPoint &output) const
Return a reference to Coin in the cache, or coinEmpty if not found.
Abstract view on the open txout dataset.
An encapsulated private key.
bool IsValid() const
Check whether this private key is valid.
An outpoint - a combination of a transaction hash and an index n into its vout.
An encapsulated public key.
bool IsCompressed() const
Check whether this is a compressed public key.
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
Serialized script, used inside transaction inputs and outputs.
bool IsPayToScriptHash() const
bool IsPayToWitnessScriptHash() const
The basic transaction that is broadcasted on the network and contained in blocks.
const Txid & GetHash() const LIFETIMEBOUND
An input of a transaction.
static const uint32_t SEQUENCE_FINAL
Setting nSequence to this value for every input in a transaction disables nLockTime/IsFinalTx().
An output of a transaction.
CTxOut out
unspent transaction output
bool IsSpent() const
Either this coin never existed (see e.g.
uint32_t nHeight
at which height this containing transaction was included in the active block chain
RAII class initializing and deinitializing global state for elliptic curve support.
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddCScript(const CScript &redeemScript)
virtual bool AddKey(const CKey &key)
A signature creator for transactions.
bool checkObject(const std::map< std::string, UniValue::VType > &memberTypes) const
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
const std::string & getValStr() const
bool read(std::string_view raw)
bool exists(const std::string &key) const
std::string GetHex() const
static std::optional< transaction_identifier > FromHex(std::string_view hex)
std::string FormatFullVersion()
std::string LicenseInfo()
Returns licensing information (for -version)
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const int WITNESS_SCALE_FACTOR
std::string EncodeHexTx(const CTransaction &tx)
void TxToUniv(const CTransaction &tx, const uint256 &block_hash, UniValue &entry, bool include_hex=true, const CTxUndo *txundo=nullptr, TxVerbosity verbosity=TxVerbosity::SHOW_DETAILS)
CScript ParseScript(const std::string &s)
std::string ScriptToAsmStr(const CScript &script, const bool fAttemptSighashDecode=false)
Create the assembly string representation of a CScript object.
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
void PrintExceptionContinue(const std::exception *pex, std::string_view thread_name)
#define T(expected, seed, data)
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
CKey DecodeSecret(const std::string &str)
std::optional< CAmount > ParseMoney(const std::string &money_string)
Parse an amount denoted in full coins.
FILE * fopen(const fs::path &p, const char *mode)
std::vector< std::string > SplitString(std::string_view str, char sep)
std::string_view TrimStringView(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
std::string ToString(const T &t)
Locale-independent version of std::to_string.
std::string TrimString(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
static constexpr decltype(CTransaction::version) TX_MAX_STANDARD_VERSION
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
static const int MAX_SCRIPT_SIZE
static const int MAX_PUBKEYS_PER_MULTISIG
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
void UpdateInput(CTxIn &input, const SignatureData &data)
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
A mutable version of CTransaction.
std::vector< CTxOut > vout
CScriptWitness scriptWitness
The scriptWitness of an input. Contains complete signatures or the traditional partial signatures for...
std::function< std::string(const char *)> TranslateFn
Translate a message to the native language of the user.
static constexpr uint32_t MAX_BIP125_RBF_SEQUENCE
bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
Parse number as fixed point according to JSON number syntax.
bool IsHex(std::string_view str)
std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
Format a paragraph of text to a fixed width, adding spaces for indentation to any added line.