87 std::vector<unsigned char>
key;
88 std::vector<unsigned char>
value;
100template<
typename Stream,
typename...
X>
110template<
typename Stream,
typename...
X>
114 size_t remaining_before =
s.size();
116 size_t remaining_after =
s.size();
117 if (remaining_after + expected_size != remaining_before) {
118 throw std::ios_base::failure(
"Size of value was not the stated size");
123template<
typename Stream>
127 if (length % 4 || length == 0) {
128 throw std::ios_base::failure(
"Invalid length for HD key path");
133 for (
unsigned int i = 4; i < length; i +=
sizeof(uint32_t)) {
136 hd_keypath.
path.push_back(index);
142template<
typename Stream>
149template<
typename Stream>
150void DeserializeHDKeypaths(Stream&
s,
const std::vector<unsigned char>& key, std::map<CPubKey, KeyOriginInfo>& hd_keypaths)
154 throw std::ios_base::failure(
"Size of key was not the expected size for the type BIP32 keypath");
157 CPubKey pubkey(key.begin() + 1, key.end());
159 throw std::ios_base::failure(
"Invalid pubkey");
161 if (hd_keypaths.count(pubkey) > 0) {
162 throw std::ios_base::failure(
"Duplicate Key, pubkey derivation path already provided");
169 hd_keypaths.emplace(pubkey, std::move(keypath));
173template<
typename Stream>
177 for (
const auto& path : hd_keypath.
path) {
183template<
typename Stream>
191template<
typename Stream>
194 for (
const auto& keypath_pair : hd_keypaths) {
195 if (!keypath_pair.first.IsValid()) {
196 throw std::ios_base::failure(
"Invalid CPubKey being serialized");
204template<
typename Stream>
207 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> agg_pubkey_bytes;
208 skey >> std::as_writable_bytes(std::span{agg_pubkey_bytes});
209 CPubKey agg_pubkey(agg_pubkey_bytes);
211 std::vector<CPubKey> participants;
212 std::vector<unsigned char> val;
216 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> part_pubkey_bytes;
217 s_val >> std::as_writable_bytes(std::span{part_pubkey_bytes});
218 participants.emplace_back(std::span{part_pubkey_bytes});
220 if (!s_val.empty()) {
221 throw std::ios_base::failure(context +
" musig2 participants pubkeys value size is not a multiple of 33");
224 out.emplace(agg_pubkey, participants);
229template<
typename Stream>
234 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> part_pubkey_bytes;
235 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> agg_pubkey_bytes;
237 skey >> std::as_writable_bytes(std::span{part_pubkey_bytes}) >> std::as_writable_bytes(std::span{agg_pubkey_bytes});
238 agg_pub.
Set(agg_pubkey_bytes.begin(), agg_pubkey_bytes.end());
239 part_pub.
Set(part_pubkey_bytes.begin(), part_pubkey_bytes.end());
277 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
287 template <
typename Stream>
303 s << sig_pair.second.second;
359 const auto& [xonly, leaf_hash] = pubkey_leaf;
366 const auto& [
script, leaf_ver] = leaf;
367 for (
const auto& control_block : control_blocks) {
369 std::vector<unsigned char> value_v(
script.begin(),
script.end());
370 value_v.push_back((uint8_t)leaf_ver);
377 const auto& [leaf_hashes, origin] = leaf_origin;
379 std::vector<unsigned char> value;
381 s_value << leaf_hashes;
401 std::vector<unsigned char> value;
403 for (
auto&
pk : part_pubs) {
404 s_value << std::span{
pk};
411 const auto& [agg_pubkey, leaf_hash] = agg_pubkey_leaf_hash;
412 for (
const auto& [part_pubkey, pubnonce] : pubnonces) {
413 if (leaf_hash.IsNull()) {
424 const auto& [agg_pubkey, leaf_hash] = agg_pubkey_leaf_hash;
425 for (
const auto& [pubkey, psig] : psigs) {
426 if (leaf_hash.IsNull()) {
463 template <
typename Stream>
466 std::set<std::vector<unsigned char>> key_lookup;
469 bool found_sep =
false;
472 std::vector<unsigned char> key;
490 if (!key_lookup.emplace(key).second) {
491 throw std::ios_base::failure(
"Duplicate Key, input non-witness utxo already provided");
492 }
else if (key.size() != 1) {
493 throw std::ios_base::failure(
"Non-witness utxo key is more than one byte type");
500 if (!key_lookup.emplace(key).second) {
501 throw std::ios_base::failure(
"Duplicate Key, input witness utxo already provided");
502 }
else if (key.size() != 1) {
503 throw std::ios_base::failure(
"Witness utxo key is more than one byte type");
511 throw std::ios_base::failure(
"Size of key was not the expected size for the type partial signature pubkey");
514 CPubKey pubkey(key.begin() + 1, key.end());
516 throw std::ios_base::failure(
"Invalid pubkey");
519 throw std::ios_base::failure(
"Duplicate Key, input partial signature for pubkey already provided");
523 std::vector<unsigned char> sig;
528 throw std::ios_base::failure(
"Signature is not a valid encoding");
536 if (!key_lookup.emplace(key).second) {
537 throw std::ios_base::failure(
"Duplicate Key, input sighash type already provided");
538 }
else if (key.size() != 1) {
539 throw std::ios_base::failure(
"Sighash type key is more than one byte type");
547 if (!key_lookup.emplace(key).second) {
548 throw std::ios_base::failure(
"Duplicate Key, input redeemScript already provided");
549 }
else if (key.size() != 1) {
550 throw std::ios_base::failure(
"Input redeemScript key is more than one byte type");
557 if (!key_lookup.emplace(key).second) {
558 throw std::ios_base::failure(
"Duplicate Key, input witnessScript already provided");
559 }
else if (key.size() != 1) {
560 throw std::ios_base::failure(
"Input witnessScript key is more than one byte type");
572 if (!key_lookup.emplace(key).second) {
573 throw std::ios_base::failure(
"Duplicate Key, input final scriptSig already provided");
574 }
else if (key.size() != 1) {
575 throw std::ios_base::failure(
"Final scriptSig key is more than one byte type");
582 if (!key_lookup.emplace(key).second) {
583 throw std::ios_base::failure(
"Duplicate Key, input final scriptWitness already provided");
584 }
else if (key.size() != 1) {
585 throw std::ios_base::failure(
"Final scriptWitness key is more than one byte type");
594 throw std::ios_base::failure(
"Size of key was not the expected size for the type ripemd160 preimage");
597 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
600 throw std::ios_base::failure(
"Duplicate Key, input ripemd160 preimage already provided");
604 std::vector<unsigned char> preimage;
615 throw std::ios_base::failure(
"Size of key was not the expected size for the type sha256 preimage");
618 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
621 throw std::ios_base::failure(
"Duplicate Key, input sha256 preimage already provided");
625 std::vector<unsigned char> preimage;
636 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash160 preimage");
639 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
642 throw std::ios_base::failure(
"Duplicate Key, input hash160 preimage already provided");
646 std::vector<unsigned char> preimage;
657 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash256 preimage");
660 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
663 throw std::ios_base::failure(
"Duplicate Key, input hash256 preimage already provided");
667 std::vector<unsigned char> preimage;
676 if (!key_lookup.emplace(key).second) {
677 throw std::ios_base::failure(
"Duplicate Key, input Taproot key signature already provided");
678 }
else if (key.size() != 1) {
679 throw std::ios_base::failure(
"Input Taproot key signature key is more than one byte type");
683 throw std::ios_base::failure(
"Input Taproot key path signature is shorter than 64 bytes");
685 throw std::ios_base::failure(
"Input Taproot key path signature is longer than 65 bytes");
691 if (!key_lookup.emplace(key).second) {
692 throw std::ios_base::failure(
"Duplicate Key, input Taproot script signature already provided");
693 }
else if (key.size() != 65) {
694 throw std::ios_base::failure(
"Input Taproot script signature key is not 65 bytes");
701 std::vector<unsigned char> sig;
703 if (sig.size() < 64) {
704 throw std::ios_base::failure(
"Input Taproot script path signature is shorter than 64 bytes");
705 }
else if (sig.size() > 65) {
706 throw std::ios_base::failure(
"Input Taproot script path signature is longer than 65 bytes");
713 if (!key_lookup.emplace(key).second) {
714 throw std::ios_base::failure(
"Duplicate Key, input Taproot leaf script already provided");
715 }
else if (key.size() < 34) {
716 throw std::ios_base::failure(
"Taproot leaf script key is not at least 34 bytes");
717 }
else if ((key.size() - 2) % 32 != 0) {
718 throw std::ios_base::failure(
"Input Taproot leaf script key's control block size is not valid");
720 std::vector<unsigned char> script_v;
722 if (script_v.empty()) {
723 throw std::ios_base::failure(
"Input Taproot leaf script must be at least 1 byte");
725 uint8_t leaf_ver = script_v.back();
727 const auto leaf_script = std::make_pair(script_v, (
int)leaf_ver);
728 m_tap_scripts[leaf_script].insert(std::vector<unsigned char>(key.begin() + 1, key.end()));
733 if (!key_lookup.emplace(key).second) {
734 throw std::ios_base::failure(
"Duplicate Key, input Taproot BIP32 keypath already provided");
735 }
else if (key.size() != 33) {
736 throw std::ios_base::failure(
"Input Taproot BIP32 keypath key is not at 33 bytes");
741 std::set<uint256> leaf_hashes;
743 size_t before_hashes =
s.size();
745 size_t after_hashes =
s.size();
746 size_t hashes_len = before_hashes - after_hashes;
747 if (hashes_len > value_len) {
748 throw std::ios_base::failure(
"Input Taproot BIP32 keypath has an invalid length");
750 size_t origin_len = value_len - hashes_len;
756 if (!key_lookup.emplace(key).second) {
757 throw std::ios_base::failure(
"Duplicate Key, input Taproot internal key already provided");
758 }
else if (key.size() != 1) {
759 throw std::ios_base::failure(
"Input Taproot internal key key is more than one byte type");
766 if (!key_lookup.emplace(key).second) {
767 throw std::ios_base::failure(
"Duplicate Key, input Taproot merkle root already provided");
768 }
else if (key.size() != 1) {
769 throw std::ios_base::failure(
"Input Taproot merkle root key is more than one byte type");
776 if (!key_lookup.emplace(key).second) {
777 throw std::ios_base::failure(
"Duplicate Key, input participant pubkeys for an aggregate key already provided");
779 throw std::ios_base::failure(
"Input musig2 participants pubkeys aggregate key is not 34 bytes");
786 if (!key_lookup.emplace(key).second) {
787 throw std::ios_base::failure(
"Duplicate Key, input musig2 pubnonce already provided");
789 throw std::ios_base::failure(
"Input musig2 pubnonce key is not expected size of 67 or 99 bytes");
795 std::vector<uint8_t> pubnonce;
797 if (pubnonce.size() != 66) {
798 throw std::ios_base::failure(
"Input musig2 pubnonce value is not 66 bytes");
806 if (!key_lookup.emplace(key).second) {
807 throw std::ios_base::failure(
"Duplicate Key, input musig2 partial sig already provided");
809 throw std::ios_base::failure(
"Input musig2 partial sig key is not expected size of 67 or 99 bytes");
829 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
838 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
841 std::vector<unsigned char> val_bytes;
843 unknown.emplace(std::move(key), std::move(val_bytes));
849 throw std::ios_base::failure(
"Separator is missing at the end of an input map");
853 template <
typename Stream>
866 std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>>
m_tap_tree;
869 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
878 template <
typename Stream>
910 std::vector<unsigned char> value;
922 const auto& [leaf_hashes, origin] = leaf;
924 std::vector<unsigned char> value;
926 s_value << leaf_hashes;
934 std::vector<unsigned char> value;
936 for (
auto&
pk : part_pubs) {
937 s_value << std::span{
pk};
952 template <
typename Stream>
955 std::set<std::vector<unsigned char>> key_lookup;
958 bool found_sep =
false;
961 std::vector<unsigned char> key;
979 if (!key_lookup.emplace(key).second) {
980 throw std::ios_base::failure(
"Duplicate Key, output redeemScript already provided");
981 }
else if (key.size() != 1) {
982 throw std::ios_base::failure(
"Output redeemScript key is more than one byte type");
989 if (!key_lookup.emplace(key).second) {
990 throw std::ios_base::failure(
"Duplicate Key, output witnessScript already provided");
991 }
else if (key.size() != 1) {
992 throw std::ios_base::failure(
"Output witnessScript key is more than one byte type");
1004 if (!key_lookup.emplace(key).second) {
1005 throw std::ios_base::failure(
"Duplicate Key, output Taproot internal key already provided");
1006 }
else if (key.size() != 1) {
1007 throw std::ios_base::failure(
"Output Taproot internal key key is more than one byte type");
1014 if (!key_lookup.emplace(key).second) {
1015 throw std::ios_base::failure(
"Duplicate Key, output Taproot tree already provided");
1016 }
else if (key.size() != 1) {
1017 throw std::ios_base::failure(
"Output Taproot tree key is more than one byte type");
1019 std::vector<unsigned char> tree_v;
1022 if (s_tree.empty()) {
1023 throw std::ios_base::failure(
"Output Taproot tree must not be empty");
1026 while (!s_tree.empty()) {
1029 std::vector<unsigned char>
script;
1034 throw std::ios_base::failure(
"Output Taproot tree has as leaf greater than Taproot maximum depth");
1037 throw std::ios_base::failure(
"Output Taproot tree has a leaf with an invalid leaf version");
1040 builder.
Add((
int)depth,
script, (
int)leaf_ver,
true);
1043 throw std::ios_base::failure(
"Output Taproot tree is malformed");
1049 if (!key_lookup.emplace(key).second) {
1050 throw std::ios_base::failure(
"Duplicate Key, output Taproot BIP32 keypath already provided");
1051 }
else if (key.size() != 33) {
1052 throw std::ios_base::failure(
"Output Taproot BIP32 keypath key is not at 33 bytes");
1055 std::set<uint256> leaf_hashes;
1057 size_t before_hashes =
s.size();
1059 size_t after_hashes =
s.size();
1060 size_t hashes_len = before_hashes - after_hashes;
1061 if (hashes_len > value_len) {
1062 throw std::ios_base::failure(
"Output Taproot BIP32 keypath has an invalid length");
1064 size_t origin_len = value_len - hashes_len;
1070 if (!key_lookup.emplace(key).second) {
1071 throw std::ios_base::failure(
"Duplicate Key, output participant pubkeys for an aggregate key already provided");
1073 throw std::ios_base::failure(
"Output musig2 participants pubkeys aggregate key is not 34 bytes");
1083 this_prop.
key = key;
1086 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1095 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1098 std::vector<unsigned char> val_bytes;
1100 unknown.emplace(std::move(key), std::move(val_bytes));
1107 throw std::ios_base::failure(
"Separator is missing at the end of an output map");
1111 template <
typename Stream>
1120 std::optional<CMutableTransaction>
tx;
1123 std::map<KeyOriginInfo, std::set<CExtPubKey>>
m_xpubs;
1126 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
1149 template <
typename Stream>
1162 for (
const auto& xpub_pair :
m_xpubs) {
1163 for (
const auto& xpub : xpub_pair.second) {
1165 xpub.EncodeWithVersion(ser_xpub);
1205 template <
typename Stream>
1211 throw std::ios_base::failure(
"Invalid PSBT magic bytes");
1215 std::set<std::vector<unsigned char>> key_lookup;
1218 std::set<CExtPubKey> global_xpubs;
1221 bool found_sep =
false;
1224 std::vector<unsigned char> key;
1242 if (!key_lookup.emplace(key).second) {
1243 throw std::ios_base::failure(
"Duplicate Key, unsigned tx already provided");
1244 }
else if (key.size() != 1) {
1245 throw std::ios_base::failure(
"Global unsigned tx key is more than one byte type");
1250 tx = std::move(mtx);
1252 for (
const CTxIn& txin :
tx->vin) {
1254 throw std::ios_base::failure(
"Unsigned tx does not have empty scriptSigs and scriptWitnesses.");
1262 throw std::ios_base::failure(
"Size of key was not the expected size for the type global xpub");
1268 throw std::ios_base::failure(
"Invalid pubkey");
1270 if (global_xpubs.count(xpub) > 0) {
1271 throw std::ios_base::failure(
"Duplicate key, global xpub already provided");
1273 global_xpubs.insert(xpub);
1280 if (
m_xpubs.count(keypath) == 0) {
1285 m_xpubs[keypath].insert(xpub);
1292 throw std::ios_base::failure(
"Duplicate Key, version already provided");
1293 }
else if (key.size() != 1) {
1294 throw std::ios_base::failure(
"Global version key is more than one byte type");
1300 throw std::ios_base::failure(
"Unsupported version number");
1309 this_prop.
key = key;
1312 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1321 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1324 std::vector<unsigned char> val_bytes;
1326 unknown.emplace(std::move(key), std::move(val_bytes));
1332 throw std::ios_base::failure(
"Separator is missing at the end of the global map");
1337 throw std::ios_base::failure(
"No unsigned transaction was provided");
1342 while (!
s.empty() && i < tx->vin.size()) {
1350 throw std::ios_base::failure(
"Non-witness UTXO does not match outpoint hash");
1353 throw std::ios_base::failure(
"Input specifies output index that does not exist");
1359 if (
inputs.size() !=
tx->vin.size()) {
1360 throw std::ios_base::failure(
"Inputs provided does not match the number of inputs in transaction.");
1365 while (!
s.empty() && i < tx->vout.size()) {
1372 if (
outputs.size() !=
tx->vout.size()) {
1373 throw std::ios_base::failure(
"Outputs provided does not match the number of outputs in transaction.");
1377 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())
void Set(const T pbegin, const T pend)
Initialize a public key using begin/end iterators to byte data.
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.
Minimal stream for reading from an existing byte array by std::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, std::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
is a home for simple enum and struct type definitions that can be used internally by functions in the...
bool CheckSignatureEncoding(const std::vector< unsigned char > &vchSig, unsigned int flags, ScriptError *serror)
static constexpr uint8_t TAPROOT_LEAF_MASK
@ SCRIPT_VERIFY_STRICTENC
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
bool CombinePSBTs(PartiallySignedTransaction &out, const std::vector< PartiallySignedTransaction > &psbtxs)
Combines PSBTs with the same underlying transaction, resulting in a single PSBT with all partial sign...
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
void DeserializeMuSig2ParticipantPubkeys(Stream &s, SpanReader &skey, std::map< CPubKey, std::vector< CPubKey > > &out, std::string context)
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
void RemoveUnnecessaryTransactions(PartiallySignedTransaction &psbtx)
Reduces the size of the PSBT by dropping unnecessary non_witness_utxos (i.e.
static constexpr uint8_t PSBT_IN_PROPRIETARY
KeyOriginInfo DeserializeKeyOrigin(Stream &s, uint64_t length)
PSBTError SignPSBTInput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index, const PrecomputedTransactionData *txdata, std::optional< int > sighash=std::nullopt, SignatureData *out_sigdata=nullptr, bool finalize=true)
Signs a PSBTInput, verifying that all provided data matches what is being signed.
void DeserializeMuSig2ParticipantDataIdentifier(Stream &skey, CPubKey &agg_pub, CPubKey &part_pub, uint256 &leaf_hash)
static constexpr uint8_t PSBT_IN_TAP_SCRIPT_SIG
static constexpr uint8_t PSBT_IN_MUSIG2_PUB_NONCE
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
static constexpr uint8_t PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS
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
bool DecodeRawPSBT(PartiallySignedTransaction &decoded_psbt, std::span< const std::byte > raw_psbt, std::string &error)
Decode a raw (binary blob) PSBT into a PartiallySignedTransaction.
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.
static constexpr uint8_t PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS
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)
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_MUSIG2_PARTIAL_SIG
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.
std::map< CPubKey, std::vector< CPubKey > > m_musig2_participants
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
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
PartiallySignedTransaction()=default
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.