76 std::vector<unsigned char>
key;
77 std::vector<unsigned char>
value;
89 template<
typename Stream,
typename...
X>
99 template<
typename Stream,
typename...
X>
103 size_t remaining_before = s.size();
105 size_t remaining_after = s.size();
106 if (remaining_after + expected_size != remaining_before) {
107 throw std::ios_base::failure(
"Size of value was not the stated size");
112 template<
typename Stream>
116 if (length % 4 || length == 0) {
117 throw std::ios_base::failure(
"Invalid length for HD key path");
122 for (
unsigned int i = 4; i < length; i +=
sizeof(uint32_t)) {
125 hd_keypath.
path.push_back(index);
131 template<
typename Stream>
138 template<
typename Stream>
139 void DeserializeHDKeypaths(Stream& s,
const std::vector<unsigned char>& key, std::map<CPubKey, KeyOriginInfo>& hd_keypaths)
143 throw std::ios_base::failure(
"Size of key was not the expected size for the type BIP32 keypath");
146 CPubKey pubkey(key.begin() + 1, key.end());
148 throw std::ios_base::failure(
"Invalid pubkey");
150 if (hd_keypaths.count(pubkey) > 0) {
151 throw std::ios_base::failure(
"Duplicate Key, pubkey derivation path already provided");
158 hd_keypaths.emplace(pubkey, std::move(keypath));
162 template<
typename Stream>
166 for (
const auto& path : hd_keypath.
path) {
172 template<
typename Stream>
180 template<
typename Stream>
183 for (
const auto& keypath_pair : hd_keypaths) {
184 if (!keypath_pair.first.IsValid()) {
185 throw std::ios_base::failure(
"Invalid CPubKey being serialized");
216 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
226 template <
typename Stream>
242 s << sig_pair.second.second;
298 const auto& [xonly, leaf_hash] = pubkey_leaf;
305 const auto& [script, leaf_ver] = leaf;
306 for (
const auto& control_block : control_blocks) {
308 std::vector<unsigned char> value_v(script.begin(), script.end());
309 value_v.push_back((uint8_t)leaf_ver);
316 const auto& [leaf_hashes, origin] = leaf_origin;
318 std::vector<unsigned char> value;
320 s_value << leaf_hashes;
365 template <
typename Stream>
368 std::set<std::vector<unsigned char>> key_lookup;
371 bool found_sep =
false;
374 std::vector<unsigned char> key;
392 if (!key_lookup.emplace(key).second) {
393 throw std::ios_base::failure(
"Duplicate Key, input non-witness utxo already provided");
394 }
else if (key.size() != 1) {
395 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(script_v, (
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>
716 std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>>
m_tap_tree;
718 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
727 template <
typename Stream>
759 std::vector<unsigned char> value;
761 for (
const auto& [depth, leaf_ver, script] :
m_tap_tree) {
771 const auto& [leaf_hashes, origin] = leaf;
773 std::vector<unsigned char> value;
775 s_value << leaf_hashes;
790 template <
typename Stream>
793 std::set<std::vector<unsigned char>> key_lookup;
796 bool found_sep =
false;
799 std::vector<unsigned char> key;
817 if (!key_lookup.emplace(key).second) {
818 throw std::ios_base::failure(
"Duplicate Key, output redeemScript already provided");
819 }
else if (key.size() != 1) {
820 throw std::ios_base::failure(
"Output redeemScript key is more than one byte type");
827 if (!key_lookup.emplace(key).second) {
828 throw std::ios_base::failure(
"Duplicate Key, output witnessScript already provided");
829 }
else if (key.size() != 1) {
830 throw std::ios_base::failure(
"Output witnessScript key is more than one byte type");
842 if (!key_lookup.emplace(key).second) {
843 throw std::ios_base::failure(
"Duplicate Key, output Taproot internal key already provided");
844 }
else if (key.size() != 1) {
845 throw std::ios_base::failure(
"Output Taproot internal key key is more than one byte type");
852 if (!key_lookup.emplace(key).second) {
853 throw std::ios_base::failure(
"Duplicate Key, output Taproot tree already provided");
854 }
else if (key.size() != 1) {
855 throw std::ios_base::failure(
"Output Taproot tree key is more than one byte type");
857 std::vector<unsigned char> tree_v;
860 if (s_tree.empty()) {
861 throw std::ios_base::failure(
"Output Taproot tree must not be empty");
864 while (!s_tree.empty()) {
867 std::vector<unsigned char> script;
872 throw std::ios_base::failure(
"Output Taproot tree has as leaf greater than Taproot maximum depth");
875 throw std::ios_base::failure(
"Output Taproot tree has a leaf with an invalid leaf version");
877 m_tap_tree.emplace_back(depth, leaf_ver, script);
878 builder.
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));
935 throw std::ios_base::failure(
"Separator is missing at the end of an output map");
939 template <
typename Stream>
948 std::optional<CMutableTransaction>
tx;
951 std::map<KeyOriginInfo, std::set<CExtPubKey>>
m_xpubs;
954 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
977 template <
typename Stream>
990 for (
const auto& xpub_pair :
m_xpubs) {
991 for (
const auto& xpub : xpub_pair.second) {
993 xpub.EncodeWithVersion(ser_xpub);
1033 template <
typename Stream>
1039 throw std::ios_base::failure(
"Invalid PSBT magic bytes");
1043 std::set<std::vector<unsigned char>> key_lookup;
1046 std::set<CExtPubKey> global_xpubs;
1049 bool found_sep =
false;
1052 std::vector<unsigned char> key;
1070 if (!key_lookup.emplace(key).second) {
1071 throw std::ios_base::failure(
"Duplicate Key, unsigned tx already provided");
1072 }
else if (key.size() != 1) {
1073 throw std::ios_base::failure(
"Global unsigned tx key is more than one byte type");
1078 tx = std::move(mtx);
1080 for (
const CTxIn& txin :
tx->vin) {
1082 throw std::ios_base::failure(
"Unsigned tx does not have empty scriptSigs and scriptWitnesses.");
1090 throw std::ios_base::failure(
"Size of key was not the expected size for the type global xpub");
1096 throw std::ios_base::failure(
"Invalid pubkey");
1098 if (global_xpubs.count(xpub) > 0) {
1099 throw std::ios_base::failure(
"Duplicate key, global xpub already provided");
1101 global_xpubs.insert(xpub);
1108 if (
m_xpubs.count(keypath) == 0) {
1113 m_xpubs[keypath].insert(xpub);
1120 throw std::ios_base::failure(
"Duplicate Key, version already provided");
1121 }
else if (key.size() != 1) {
1122 throw std::ios_base::failure(
"Global version key is more than one byte type");
1128 throw std::ios_base::failure(
"Unsupported version number");
1137 this_prop.
key = key;
1140 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1142 s >> this_prop.
value;
1149 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1152 std::vector<unsigned char> val_bytes;
1154 unknown.emplace(std::move(key), std::move(val_bytes));
1160 throw std::ios_base::failure(
"Separator is missing at the end of the global map");
1165 throw std::ios_base::failure(
"No unsigned transaction was provided");
1170 while (!s.empty() && i < tx->vin.size()) {
1177 throw std::ios_base::failure(
"Non-witness UTXO does not match outpoint hash");
1182 if (
inputs.size() !=
tx->vin.size()) {
1183 throw std::ios_base::failure(
"Inputs provided does not match the number of inputs in transaction.");
1188 while (!s.empty() && i < tx->vout.size()) {
1195 if (
outputs.size() !=
tx->vout.size()) {
1196 throw std::ios_base::failure(
"Outputs provided does not match the number of outputs in transaction.");
1200 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.
Utility class to construct Taproot outputs from internal key and script tree.
bool IsComplete() const
Return whether there were either no leaves, or the leaves form a Huffman tree.
TaprootBuilder & Add(int depth, Span< const unsigned char > script, int leaf_version, bool track=true)
Add a new script at a certain depth in the tree.
bool IsNull() const
Test whether this is the 0 key (the result of default construction).
constexpr bool IsNull() const
static constexpr uint8_t TAPROOT_LEAF_MASK
static constexpr size_t TAPROOT_CONTROL_MAX_NODE_COUNT
static constexpr TransactionSerParams TX_NO_WITNESS
static constexpr TransactionSerParams TX_WITH_WITNESS
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
bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData *txdata)
Checks whether a PSBTInput is already signed by doing script verification using final fields.
static constexpr uint8_t PSBT_IN_TAP_KEY_SIG
void UnserializeFromVector(Stream &s, X &&... args)
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
void RemoveUnnecessaryTransactions(PartiallySignedTransaction &psbtx, const int &sighash_type)
Reduces the size of the PSBT by dropping unnecessary non_witness_utxos (i.e.
static constexpr uint8_t PSBT_IN_TAP_MERKLE_ROOT
void SerializeKeyOrigin(Stream &s, KeyOriginInfo hd_keypath)
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 by checking for non-null finalized fields.
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, const Args &... args)
Support for (un)serializing many things at once.
void UnserializeMany(Stream &s, Args &&... args)
void WriteCompactSize(SizeComputer &os, uint64_t nSize)
uint64_t ReadCompactSize(Stream &is, bool range_check=true)
Decode a CompactSize-encoded variable-length integer.
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.
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
std::vector< std::tuple< uint8_t, uint8_t, std::vector< unsigned char > > > m_tap_tree
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.