76 std::vector<unsigned char>
key;
77 std::vector<unsigned char>
value;
89 template<
typename Stream,
typename...
X>
97 template<
typename Stream,
typename...
X>
101 size_t remaining_before = s.size();
103 size_t remaining_after = s.size();
104 if (remaining_after + expected_size != remaining_before) {
105 throw std::ios_base::failure(
"Size of value was not the stated size");
110 template<
typename Stream>
114 if (length % 4 || length == 0) {
115 throw std::ios_base::failure(
"Invalid length for HD key path");
120 for (
unsigned int i = 4; i < length; i +=
sizeof(uint32_t)) {
123 hd_keypath.
path.push_back(index);
129 template<
typename Stream>
136 template<
typename Stream>
137 void DeserializeHDKeypaths(Stream& s,
const std::vector<unsigned char>& key, std::map<CPubKey, KeyOriginInfo>& hd_keypaths)
141 throw std::ios_base::failure(
"Size of key was not the expected size for the type BIP32 keypath");
144 CPubKey pubkey(key.begin() + 1, key.end());
146 throw std::ios_base::failure(
"Invalid pubkey");
148 if (hd_keypaths.count(pubkey) > 0) {
149 throw std::ios_base::failure(
"Duplicate Key, pubkey derivation path already provided");
156 hd_keypaths.emplace(pubkey, std::move(keypath));
160 template<
typename Stream>
164 for (
const auto& path : hd_keypath.
path) {
170 template<
typename Stream>
178 template<
typename Stream>
181 for (
auto keypath_pair : hd_keypaths) {
182 if (!keypath_pair.first.IsValid()) {
183 throw std::ios_base::failure(
"Invalid CPubKey being serialized");
214 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
224 template <
typename Stream>
241 s << sig_pair.second.second;
297 const auto& [xonly, leaf_hash] = pubkey_leaf;
304 const auto& [script, leaf_ver] = leaf;
305 for (
const auto& control_block : control_blocks) {
307 std::vector<unsigned char> value_v(script.begin(), script.end());
308 value_v.push_back((uint8_t)leaf_ver);
315 const auto& [leaf_hashes, origin] = leaf_origin;
317 std::vector<unsigned char> value;
318 CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0);
319 s_value << leaf_hashes;
364 template <
typename Stream>
367 std::set<std::vector<unsigned char>> key_lookup;
370 bool found_sep =
false;
373 std::vector<unsigned char> key;
384 SpanReader skey(s.GetType(), s.GetVersion(), key);
391 if (!key_lookup.emplace(key).second) {
392 throw std::ios_base::failure(
"Duplicate Key, input non-witness utxo already provided");
393 }
else if (key.size() != 1) {
394 throw std::ios_base::failure(
"Non-witness utxo key is more than one byte type");
402 if (!key_lookup.emplace(key).second) {
403 throw std::ios_base::failure(
"Duplicate Key, input witness utxo already provided");
404 }
else if (key.size() != 1) {
405 throw std::ios_base::failure(
"Witness utxo key is more than one byte type");
413 throw std::ios_base::failure(
"Size of key was not the expected size for the type partial signature pubkey");
416 CPubKey pubkey(key.begin() + 1, key.end());
418 throw std::ios_base::failure(
"Invalid pubkey");
421 throw std::ios_base::failure(
"Duplicate Key, input partial signature for pubkey already provided");
425 std::vector<unsigned char> sig;
433 if (!key_lookup.emplace(key).second) {
434 throw std::ios_base::failure(
"Duplicate Key, input sighash type already provided");
435 }
else if (key.size() != 1) {
436 throw std::ios_base::failure(
"Sighash type key is more than one byte type");
444 if (!key_lookup.emplace(key).second) {
445 throw std::ios_base::failure(
"Duplicate Key, input redeemScript already provided");
446 }
else if (key.size() != 1) {
447 throw std::ios_base::failure(
"Input redeemScript key is more than one byte type");
454 if (!key_lookup.emplace(key).second) {
455 throw std::ios_base::failure(
"Duplicate Key, input witnessScript already provided");
456 }
else if (key.size() != 1) {
457 throw std::ios_base::failure(
"Input witnessScript key is more than one byte type");
469 if (!key_lookup.emplace(key).second) {
470 throw std::ios_base::failure(
"Duplicate Key, input final scriptSig already provided");
471 }
else if (key.size() != 1) {
472 throw std::ios_base::failure(
"Final scriptSig key is more than one byte type");
479 if (!key_lookup.emplace(key).second) {
480 throw std::ios_base::failure(
"Duplicate Key, input final scriptWitness already provided");
481 }
else if (key.size() != 1) {
482 throw std::ios_base::failure(
"Final scriptWitness key is more than one byte type");
491 throw std::ios_base::failure(
"Size of key was not the expected size for the type ripemd160 preimage");
494 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
497 throw std::ios_base::failure(
"Duplicate Key, input ripemd160 preimage already provided");
501 std::vector<unsigned char> preimage;
512 throw std::ios_base::failure(
"Size of key was not the expected size for the type sha256 preimage");
515 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
518 throw std::ios_base::failure(
"Duplicate Key, input sha256 preimage already provided");
522 std::vector<unsigned char> preimage;
533 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash160 preimage");
536 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
539 throw std::ios_base::failure(
"Duplicate Key, input hash160 preimage already provided");
543 std::vector<unsigned char> preimage;
554 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash256 preimage");
557 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
560 throw std::ios_base::failure(
"Duplicate Key, input hash256 preimage already provided");
564 std::vector<unsigned char> preimage;
573 if (!key_lookup.emplace(key).second) {
574 throw std::ios_base::failure(
"Duplicate Key, input Taproot key signature already provided");
575 }
else if (key.size() != 1) {
576 throw std::ios_base::failure(
"Input Taproot key signature key is more than one byte type");
580 throw std::ios_base::failure(
"Input Taproot key path signature is shorter than 64 bytes");
582 throw std::ios_base::failure(
"Input Taproot key path signature is longer than 65 bytes");
588 if (!key_lookup.emplace(key).second) {
589 throw std::ios_base::failure(
"Duplicate Key, input Taproot script signature already provided");
590 }
else if (key.size() != 65) {
591 throw std::ios_base::failure(
"Input Taproot script signature key is not 65 bytes");
598 std::vector<unsigned char> sig;
600 if (sig.size() < 64) {
601 throw std::ios_base::failure(
"Input Taproot script path signature is shorter than 64 bytes");
602 }
else if (sig.size() > 65) {
603 throw std::ios_base::failure(
"Input Taproot script path signature is longer than 65 bytes");
610 if (!key_lookup.emplace(key).second) {
611 throw std::ios_base::failure(
"Duplicate Key, input Taproot leaf script already provided");
612 }
else if (key.size() < 34) {
613 throw std::ios_base::failure(
"Taproot leaf script key is not at least 34 bytes");
614 }
else if ((key.size() - 2) % 32 != 0) {
615 throw std::ios_base::failure(
"Input Taproot leaf script key's control block size is not valid");
617 std::vector<unsigned char> script_v;
619 if (script_v.empty()) {
620 throw std::ios_base::failure(
"Input Taproot leaf script must be at least 1 byte");
622 uint8_t leaf_ver = script_v.back();
624 const auto leaf_script = std::make_pair(
CScript(script_v.begin(), script_v.end()), (
int)leaf_ver);
625 m_tap_scripts[leaf_script].insert(std::vector<unsigned char>(key.begin() + 1, key.end()));
630 if (!key_lookup.emplace(key).second) {
631 throw std::ios_base::failure(
"Duplicate Key, input Taproot BIP32 keypath already provided");
632 }
else if (key.size() != 33) {
633 throw std::ios_base::failure(
"Input Taproot BIP32 keypath key is not at 33 bytes");
638 std::set<uint256> leaf_hashes;
640 size_t before_hashes = s.size();
642 size_t after_hashes = s.size();
643 size_t hashes_len = before_hashes - after_hashes;
644 if (hashes_len > value_len) {
645 throw std::ios_base::failure(
"Input Taproot BIP32 keypath has an invalid length");
647 size_t origin_len = value_len - hashes_len;
653 if (!key_lookup.emplace(key).second) {
654 throw std::ios_base::failure(
"Duplicate Key, input Taproot internal key already provided");
655 }
else if (key.size() != 1) {
656 throw std::ios_base::failure(
"Input Taproot internal key key is more than one byte type");
663 if (!key_lookup.emplace(key).second) {
664 throw std::ios_base::failure(
"Duplicate Key, input Taproot merkle root already provided");
665 }
else if (key.size() != 1) {
666 throw std::ios_base::failure(
"Input Taproot merkle root key is more than one byte type");
679 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
681 s >> this_prop.
value;
688 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
691 std::vector<unsigned char> val_bytes;
693 unknown.emplace(std::move(key), std::move(val_bytes));
699 throw std::ios_base::failure(
"Separator is missing at the end of an input map");
703 template <
typename Stream>
718 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
727 template <
typename Stream>
759 std::vector<unsigned char> value;
760 CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0);
761 const auto& tuples =
m_tap_tree->GetTreeTuples();
762 for (
const auto& tuple : tuples) {
763 uint8_t depth = std::get<0>(tuple);
764 uint8_t leaf_ver = std::get<1>(tuple);
765 CScript script = std::get<2>(tuple);
775 const auto& [leaf_hashes, origin] = leaf;
777 std::vector<unsigned char> value;
778 CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0);
779 s_value << leaf_hashes;
794 template <
typename Stream>
797 std::set<std::vector<unsigned char>> key_lookup;
800 bool found_sep =
false;
803 std::vector<unsigned char> key;
814 SpanReader skey(s.GetType(), s.GetVersion(), key);
821 if (!key_lookup.emplace(key).second) {
822 throw std::ios_base::failure(
"Duplicate Key, output redeemScript already provided");
823 }
else if (key.size() != 1) {
824 throw std::ios_base::failure(
"Output redeemScript key is more than one byte type");
831 if (!key_lookup.emplace(key).second) {
832 throw std::ios_base::failure(
"Duplicate Key, output witnessScript already provided");
833 }
else if (key.size() != 1) {
834 throw std::ios_base::failure(
"Output witnessScript key is more than one byte type");
846 if (!key_lookup.emplace(key).second) {
847 throw std::ios_base::failure(
"Duplicate Key, output Taproot internal key already provided");
848 }
else if (key.size() != 1) {
849 throw std::ios_base::failure(
"Output Taproot internal key key is more than one byte type");
856 if (!key_lookup.emplace(key).second) {
857 throw std::ios_base::failure(
"Duplicate Key, output Taproot tree already provided");
858 }
else if (key.size() != 1) {
859 throw std::ios_base::failure(
"Output Taproot tree key is more than one byte type");
862 std::vector<unsigned char> tree_v;
864 SpanReader s_tree(s.GetType(), s.GetVersion(), tree_v);
865 while (!s_tree.
empty()) {
873 throw std::ios_base::failure(
"Output Taproot tree has as leaf greater than Taproot maximum depth");
876 throw std::ios_base::failure(
"Output Taproot tree has a leaf with an invalid leaf version");
878 m_tap_tree->Add((
int)depth, script, (
int)leaf_ver,
true );
881 throw std::ios_base::failure(
"Output Taproot tree is malformed");
887 if (!key_lookup.emplace(key).second) {
888 throw std::ios_base::failure(
"Duplicate Key, output Taproot BIP32 keypath already provided");
889 }
else if (key.size() != 33) {
890 throw std::ios_base::failure(
"Output Taproot BIP32 keypath key is not at 33 bytes");
893 std::set<uint256> leaf_hashes;
895 size_t before_hashes = s.size();
897 size_t after_hashes = s.size();
898 size_t hashes_len = before_hashes - after_hashes;
899 if (hashes_len > value_len) {
900 throw std::ios_base::failure(
"Output Taproot BIP32 keypath has an invalid length");
902 size_t origin_len = value_len - hashes_len;
914 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
916 s >> this_prop.
value;
923 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
926 std::vector<unsigned char> val_bytes;
928 unknown.emplace(std::move(key), std::move(val_bytes));
940 throw std::ios_base::failure(
"Separator is missing at the end of an output map");
944 template <
typename Stream>
953 std::optional<CMutableTransaction>
tx;
956 std::map<KeyOriginInfo, std::set<CExtPubKey>>
m_xpubs;
959 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
982 template <
typename Stream>
996 for (
const auto& xpub_pair :
m_xpubs) {
997 for (
const auto& xpub : xpub_pair.second) {
999 xpub.EncodeWithVersion(ser_xpub);
1039 template <
typename Stream>
1045 throw std::ios_base::failure(
"Invalid PSBT magic bytes");
1049 std::set<std::vector<unsigned char>> key_lookup;
1052 std::set<CExtPubKey> global_xpubs;
1055 bool found_sep =
false;
1058 std::vector<unsigned char> key;
1069 SpanReader skey(s.GetType(), s.GetVersion(), key);
1076 if (!key_lookup.emplace(key).second) {
1077 throw std::ios_base::failure(
"Duplicate Key, unsigned tx already provided");
1078 }
else if (key.size() != 1) {
1079 throw std::ios_base::failure(
"Global unsigned tx key is more than one byte type");
1085 tx = std::move(mtx);
1087 for (
const CTxIn& txin :
tx->vin) {
1089 throw std::ios_base::failure(
"Unsigned tx does not have empty scriptSigs and scriptWitnesses.");
1097 throw std::ios_base::failure(
"Size of key was not the expected size for the type global xpub");
1103 throw std::ios_base::failure(
"Invalid pubkey");
1105 if (global_xpubs.count(xpub) > 0) {
1106 throw std::ios_base::failure(
"Duplicate key, global xpub already provided");
1108 global_xpubs.insert(xpub);
1115 if (
m_xpubs.count(keypath) == 0) {
1120 m_xpubs[keypath].insert(xpub);
1127 throw std::ios_base::failure(
"Duplicate Key, version already provided");
1128 }
else if (key.size() != 1) {
1129 throw std::ios_base::failure(
"Global version key is more than one byte type");
1135 throw std::ios_base::failure(
"Unsupported version number");
1144 this_prop.
key = key;
1147 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1149 s >> this_prop.
value;
1156 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1159 std::vector<unsigned char> val_bytes;
1161 unknown.emplace(std::move(key), std::move(val_bytes));
1167 throw std::ios_base::failure(
"Separator is missing at the end of the global map");
1172 throw std::ios_base::failure(
"No unsigned transcation was provided");
1177 while (!s.empty() && i < tx->vin.size()) {
1184 throw std::ios_base::failure(
"Non-witness UTXO does not match outpoint hash");
1189 if (
inputs.size() !=
tx->vin.size()) {
1190 throw std::ios_base::failure(
"Inputs provided does not match the number of inputs in transaction.");
1195 while (!s.empty() && i < tx->vout.size()) {
1202 if (
outputs.size() !=
tx->vout.size()) {
1203 throw std::ios_base::failure(
"Outputs provided does not match the number of outputs in transaction.");
1207 template <
typename Stream>
static const size_t OUTPUT_SIZE
static const size_t OUTPUT_SIZE
An encapsulated public key.
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
static constexpr unsigned int COMPRESSED_SIZE
static constexpr unsigned int SIZE
secp256k1:
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
static const size_t OUTPUT_SIZE
static const size_t OUTPUT_SIZE
Serialized script, used inside transaction inputs and outputs.
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
An output of a transaction.
An interface to be implemented by keystores that support signing.
A Span is an object that can refer to a contiguous sequence of objects.
CONSTEXPR_IF_NOT_DEBUG Span< C > first(std::size_t count) const noexcept
CONSTEXPR_IF_NOT_DEBUG Span< C > subspan(std::size_t offset) const noexcept
Minimal stream for reading from an existing byte array by Span.
bool IsNull() const
Test whether this is the 0 key (the result of default construction).
bool IsFullyValid() const
Determine if this pubkey is fully valid.
static constexpr uint8_t TAPROOT_LEAF_MASK
static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT
static const int SERIALIZE_TRANSACTION_NO_WITNESS
A flag that is ORed into the protocol version to designate that a transaction should be (un)serialize...
std::shared_ptr< const CTransaction > CTransactionRef
void SerializeToVector(Stream &s, const X &... args)
static constexpr uint8_t PSBT_IN_RIPEMD160
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
static constexpr uint8_t PSBT_IN_HASH256
static constexpr uint8_t PSBT_GLOBAL_UNSIGNED_TX
static constexpr uint8_t PSBT_IN_NON_WITNESS_UTXO
static constexpr uint8_t PSBT_IN_TAP_KEY_SIG
static constexpr uint8_t PSBT_IN_SCRIPTSIG
static constexpr uint8_t PSBT_IN_WITNESSSCRIPT
std::string PSBTRoleName(PSBTRole role)
static constexpr uint8_t PSBT_OUT_REDEEMSCRIPT
static constexpr uint8_t PSBT_GLOBAL_VERSION
static constexpr uint8_t PSBT_IN_TAP_LEAF_SCRIPT
static constexpr uint8_t PSBT_OUT_PROPRIETARY
static constexpr uint8_t PSBT_MAGIC_BYTES[5]
static constexpr uint32_t PSBT_HIGHEST_VERSION
static constexpr uint8_t PSBT_SEPARATOR
static constexpr uint8_t PSBT_IN_BIP32_DERIVATION
static constexpr uint8_t PSBT_IN_SCRIPTWITNESS
static constexpr uint8_t PSBT_OUT_TAP_TREE
static constexpr uint8_t PSBT_OUT_BIP32_DERIVATION
static constexpr uint8_t PSBT_GLOBAL_PROPRIETARY
bool DecodeRawPSBT(PartiallySignedTransaction &decoded_psbt, Span< const std::byte > raw_psbt, std::string &error)
Decode a raw (binary blob) PSBT into a PartiallySignedTransaction.
static constexpr uint8_t PSBT_IN_PROPRIETARY
KeyOriginInfo DeserializeKeyOrigin(Stream &s, uint64_t length)
static constexpr uint8_t PSBT_IN_TAP_SCRIPT_SIG
void SerializeHDKeypaths(Stream &s, const std::map< CPubKey, KeyOriginInfo > &hd_keypaths, CompactSizeWriter type)
static constexpr uint8_t PSBT_IN_TAP_BIP32_DERIVATION
static constexpr uint8_t PSBT_IN_HASH160
static constexpr uint8_t PSBT_IN_REDEEMSCRIPT
bool DecodeBase64PSBT(PartiallySignedTransaction &decoded_psbt, const std::string &base64_psbt, std::string &error)
Decode a base64ed PSBT into a PartiallySignedTransaction.
static constexpr uint8_t PSBT_OUT_WITNESSSCRIPT
static constexpr uint8_t PSBT_GLOBAL_XPUB
bool SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, const PrecomputedTransactionData *txdata, int sighash=SIGHASH_ALL, SignatureData *out_sigdata=nullptr, bool finalize=true)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
static constexpr uint8_t PSBT_OUT_TAP_BIP32_DERIVATION
static constexpr uint8_t PSBT_IN_PARTIAL_SIG
static constexpr uint8_t PSBT_IN_TAP_INTERNAL_KEY
size_t CountPSBTUnsignedInputs(const PartiallySignedTransaction &psbt)
Counts the unsigned inputs of a PSBT.
bool FinalizeAndExtractPSBT(PartiallySignedTransaction &psbtx, CMutableTransaction &result)
Finalizes a PSBT if possible, and extracts it to a CMutableTransaction if it could be finalized.
static constexpr uint8_t PSBT_OUT_TAP_INTERNAL_KEY
static constexpr uint8_t PSBT_IN_TAP_MERKLE_ROOT
void SerializeKeyOrigin(Stream &s, KeyOriginInfo hd_keypath)
void UnserializeFromVector(Stream &s, X &... args)
void DeserializeHDKeypaths(Stream &s, const std::vector< unsigned char > &key, std::map< CPubKey, KeyOriginInfo > &hd_keypaths)
static constexpr uint8_t PSBT_IN_SIGHASH
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed.
void SerializeHDKeypath(Stream &s, KeyOriginInfo hd_keypath)
PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction &psbt)
Compute a PrecomputedTransactionData object from a psbt.
void DeserializeHDKeypath(Stream &s, KeyOriginInfo &hd_keypath)
TransactionError CombinePSBTs(PartiallySignedTransaction &out, const std::vector< PartiallySignedTransaction > &psbtxs)
Combines PSBTs with the same underlying transaction, resulting in a single PSBT with all partial sign...
bool FinalizePSBT(PartiallySignedTransaction &psbtx)
Finalizes a PSBT if possible, combining partial signatures.
const std::streamsize MAX_FILE_SIZE_PSBT
static constexpr uint8_t PSBT_IN_WITNESS_UTXO
static constexpr uint8_t PSBT_IN_SHA256
const unsigned int BIP32_EXTKEY_WITH_VERSION_SIZE
std::vector< unsigned char > ToByteVector(const T &in)
void SerializeMany(Stream &s)
uint64_t ReadCompactSize(Stream &is, bool range_check=true)
Decode a CompactSize-encoded variable-length integer.
void UnserializeMany(Stream &s)
size_t GetSerializeSizeMany(int nVersion, const T &... t)
void WriteCompactSize(CSizeComputer &os, uint64_t nSize)
std::pair< CPubKey, std::vector< unsigned char > > SigPair
void DecodeWithVersion(const unsigned char code[BIP32_EXTKEY_WITH_VERSION_SIZE])
A mutable version of CTransaction.
std::vector< std::vector< unsigned char > > stack
unsigned char fingerprint[4]
First 32 bits of the Hash160 of the public key at the root of the path.
std::vector< uint32_t > path
A structure for PSBTs which contains per output information.
std::optional< TaprootBuilder > m_tap_tree
XOnlyPubKey m_tap_internal_key
std::map< XOnlyPubKey, std::pair< std::set< uint256 >, KeyOriginInfo > > m_tap_bip32_paths
void Merge(const PSBTOutput &output)
std::set< PSBTProprietary > m_proprietary
void Serialize(Stream &s) const
PSBTOutput(deserialize_type, Stream &s)
std::map< CPubKey, KeyOriginInfo > hd_keypaths
void Unserialize(Stream &s)
std::map< std::vector< unsigned char >, std::vector< unsigned char > > unknown
void FillSignatureData(SignatureData &sigdata) const
void FromSignatureData(const SignatureData &sigdata)
A structure for PSBT proprietary types.
std::vector< unsigned char > value
bool operator<(const PSBTProprietary &b) const
std::vector< unsigned char > identifier
std::vector< unsigned char > key
bool operator==(const PSBTProprietary &b) const
A version of CTransaction with the PSBT format.
uint32_t GetVersion() const
bool Merge(const PartiallySignedTransaction &psbt)
Merge psbt into this.
std::map< KeyOriginInfo, std::set< CExtPubKey > > m_xpubs
PartiallySignedTransaction()
std::optional< uint32_t > m_version
bool GetInputUTXO(CTxOut &utxo, int input_index) const
Finds the UTXO for a given input index.
std::map< std::vector< unsigned char >, std::vector< unsigned char > > unknown
bool AddOutput(const CTxOut &txout, const PSBTOutput &psbtout)
std::vector< PSBTInput > inputs
std::optional< CMutableTransaction > tx
bool AddInput(const CTxIn &txin, PSBTInput &psbtin)
std::vector< PSBTOutput > outputs
std::set< PSBTProprietary > m_proprietary
void Serialize(Stream &s) const
PartiallySignedTransaction(deserialize_type, Stream &s)
void Unserialize(Stream &s)
Dummy data type to identify deserializing constructors.
bool error(const char *fmt, const Args &... args)