84 std::vector<unsigned char>
key;
85 std::vector<unsigned char>
value;
97template<
typename Stream,
typename...
X>
107template<
typename Stream,
typename...
X>
111 size_t remaining_before =
s.size();
113 size_t remaining_after =
s.size();
114 if (remaining_after + expected_size != remaining_before) {
115 throw std::ios_base::failure(
"Size of value was not the stated size");
120template<
typename Stream>
124 if (length % 4 || length == 0) {
125 throw std::ios_base::failure(
"Invalid length for HD key path");
130 for (
unsigned int i = 4; i < length; i +=
sizeof(uint32_t)) {
133 hd_keypath.
path.push_back(index);
139template<
typename Stream>
146template<
typename Stream>
147void DeserializeHDKeypaths(Stream&
s,
const std::vector<unsigned char>& key, std::map<CPubKey, KeyOriginInfo>& hd_keypaths)
151 throw std::ios_base::failure(
"Size of key was not the expected size for the type BIP32 keypath");
154 CPubKey pubkey(key.begin() + 1, key.end());
156 throw std::ios_base::failure(
"Invalid pubkey");
158 if (hd_keypaths.count(pubkey) > 0) {
159 throw std::ios_base::failure(
"Duplicate Key, pubkey derivation path already provided");
166 hd_keypaths.emplace(pubkey, std::move(keypath));
170template<
typename Stream>
174 for (
const auto& path : hd_keypath.
path) {
180template<
typename Stream>
188template<
typename Stream>
191 for (
const auto& keypath_pair : hd_keypaths) {
192 if (!keypath_pair.first.IsValid()) {
193 throw std::ios_base::failure(
"Invalid CPubKey being serialized");
201template<
typename Stream>
204 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> agg_pubkey_bytes;
205 skey >> std::as_writable_bytes(std::span{agg_pubkey_bytes});
206 CPubKey agg_pubkey(agg_pubkey_bytes);
208 std::vector<CPubKey> participants;
209 std::vector<unsigned char> val;
213 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> part_pubkey_bytes;
214 s_val >> std::as_writable_bytes(std::span{part_pubkey_bytes});
215 participants.emplace_back(std::span{part_pubkey_bytes});
217 if (!s_val.empty()) {
218 throw std::ios_base::failure(context +
" musig2 participants pubkeys value size is not a multiple of 33");
221 out.emplace(agg_pubkey, participants);
226template<
typename Stream>
231 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> part_pubkey_bytes;
232 std::array<unsigned char, CPubKey::COMPRESSED_SIZE> agg_pubkey_bytes;
234 skey >> std::as_writable_bytes(std::span{part_pubkey_bytes}) >> std::as_writable_bytes(std::span{agg_pubkey_bytes});
235 agg_pub.
Set(agg_pubkey_bytes.begin(), agg_pubkey_bytes.end());
236 part_pub.
Set(part_pubkey_bytes.begin(), part_pubkey_bytes.end());
274 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
284 template <
typename Stream>
300 s << sig_pair.second.second;
356 const auto& [xonly, leaf_hash] = pubkey_leaf;
363 const auto& [
script, leaf_ver] = leaf;
364 for (
const auto& control_block : control_blocks) {
366 std::vector<unsigned char> value_v(
script.begin(),
script.end());
367 value_v.push_back((uint8_t)leaf_ver);
374 const auto& [leaf_hashes, origin] = leaf_origin;
376 std::vector<unsigned char> value;
378 s_value << leaf_hashes;
398 std::vector<unsigned char> value;
400 for (
auto&
pk : part_pubs) {
401 s_value << std::span{
pk};
408 const auto& [agg_pubkey, leaf_hash] = agg_pubkey_leaf_hash;
409 for (
const auto& [part_pubkey, pubnonce] : pubnonces) {
410 if (leaf_hash.IsNull()) {
421 const auto& [agg_pubkey, leaf_hash] = agg_pubkey_leaf_hash;
422 for (
const auto& [pubkey, psig] : psigs) {
423 if (leaf_hash.IsNull()) {
460 template <
typename Stream>
463 std::set<std::vector<unsigned char>> key_lookup;
466 bool found_sep =
false;
469 std::vector<unsigned char> key;
487 if (!key_lookup.emplace(key).second) {
488 throw std::ios_base::failure(
"Duplicate Key, input non-witness utxo already provided");
489 }
else if (key.size() != 1) {
490 throw std::ios_base::failure(
"Non-witness utxo key is more than one byte type");
497 if (!key_lookup.emplace(key).second) {
498 throw std::ios_base::failure(
"Duplicate Key, input witness utxo already provided");
499 }
else if (key.size() != 1) {
500 throw std::ios_base::failure(
"Witness utxo key is more than one byte type");
508 throw std::ios_base::failure(
"Size of key was not the expected size for the type partial signature pubkey");
511 CPubKey pubkey(key.begin() + 1, key.end());
513 throw std::ios_base::failure(
"Invalid pubkey");
516 throw std::ios_base::failure(
"Duplicate Key, input partial signature for pubkey already provided");
520 std::vector<unsigned char> sig;
528 if (!key_lookup.emplace(key).second) {
529 throw std::ios_base::failure(
"Duplicate Key, input sighash type already provided");
530 }
else if (key.size() != 1) {
531 throw std::ios_base::failure(
"Sighash type key is more than one byte type");
539 if (!key_lookup.emplace(key).second) {
540 throw std::ios_base::failure(
"Duplicate Key, input redeemScript already provided");
541 }
else if (key.size() != 1) {
542 throw std::ios_base::failure(
"Input redeemScript key is more than one byte type");
549 if (!key_lookup.emplace(key).second) {
550 throw std::ios_base::failure(
"Duplicate Key, input witnessScript already provided");
551 }
else if (key.size() != 1) {
552 throw std::ios_base::failure(
"Input witnessScript key is more than one byte type");
564 if (!key_lookup.emplace(key).second) {
565 throw std::ios_base::failure(
"Duplicate Key, input final scriptSig already provided");
566 }
else if (key.size() != 1) {
567 throw std::ios_base::failure(
"Final scriptSig key is more than one byte type");
574 if (!key_lookup.emplace(key).second) {
575 throw std::ios_base::failure(
"Duplicate Key, input final scriptWitness already provided");
576 }
else if (key.size() != 1) {
577 throw std::ios_base::failure(
"Final scriptWitness key is more than one byte type");
586 throw std::ios_base::failure(
"Size of key was not the expected size for the type ripemd160 preimage");
589 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
592 throw std::ios_base::failure(
"Duplicate Key, input ripemd160 preimage already provided");
596 std::vector<unsigned char> preimage;
607 throw std::ios_base::failure(
"Size of key was not the expected size for the type sha256 preimage");
610 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
613 throw std::ios_base::failure(
"Duplicate Key, input sha256 preimage already provided");
617 std::vector<unsigned char> preimage;
628 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash160 preimage");
631 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
634 throw std::ios_base::failure(
"Duplicate Key, input hash160 preimage already provided");
638 std::vector<unsigned char> preimage;
649 throw std::ios_base::failure(
"Size of key was not the expected size for the type hash256 preimage");
652 std::vector<unsigned char> hash_vec(key.begin() + 1, key.end());
655 throw std::ios_base::failure(
"Duplicate Key, input hash256 preimage already provided");
659 std::vector<unsigned char> preimage;
668 if (!key_lookup.emplace(key).second) {
669 throw std::ios_base::failure(
"Duplicate Key, input Taproot key signature already provided");
670 }
else if (key.size() != 1) {
671 throw std::ios_base::failure(
"Input Taproot key signature key is more than one byte type");
675 throw std::ios_base::failure(
"Input Taproot key path signature is shorter than 64 bytes");
677 throw std::ios_base::failure(
"Input Taproot key path signature is longer than 65 bytes");
683 if (!key_lookup.emplace(key).second) {
684 throw std::ios_base::failure(
"Duplicate Key, input Taproot script signature already provided");
685 }
else if (key.size() != 65) {
686 throw std::ios_base::failure(
"Input Taproot script signature key is not 65 bytes");
693 std::vector<unsigned char> sig;
695 if (sig.size() < 64) {
696 throw std::ios_base::failure(
"Input Taproot script path signature is shorter than 64 bytes");
697 }
else if (sig.size() > 65) {
698 throw std::ios_base::failure(
"Input Taproot script path signature is longer than 65 bytes");
705 if (!key_lookup.emplace(key).second) {
706 throw std::ios_base::failure(
"Duplicate Key, input Taproot leaf script already provided");
707 }
else if (key.size() < 34) {
708 throw std::ios_base::failure(
"Taproot leaf script key is not at least 34 bytes");
709 }
else if ((key.size() - 2) % 32 != 0) {
710 throw std::ios_base::failure(
"Input Taproot leaf script key's control block size is not valid");
712 std::vector<unsigned char> script_v;
714 if (script_v.empty()) {
715 throw std::ios_base::failure(
"Input Taproot leaf script must be at least 1 byte");
717 uint8_t leaf_ver = script_v.back();
719 const auto leaf_script = std::make_pair(script_v, (
int)leaf_ver);
720 m_tap_scripts[leaf_script].insert(std::vector<unsigned char>(key.begin() + 1, key.end()));
725 if (!key_lookup.emplace(key).second) {
726 throw std::ios_base::failure(
"Duplicate Key, input Taproot BIP32 keypath already provided");
727 }
else if (key.size() != 33) {
728 throw std::ios_base::failure(
"Input Taproot BIP32 keypath key is not at 33 bytes");
733 std::set<uint256> leaf_hashes;
735 size_t before_hashes =
s.size();
737 size_t after_hashes =
s.size();
738 size_t hashes_len = before_hashes - after_hashes;
739 if (hashes_len > value_len) {
740 throw std::ios_base::failure(
"Input Taproot BIP32 keypath has an invalid length");
742 size_t origin_len = value_len - hashes_len;
748 if (!key_lookup.emplace(key).second) {
749 throw std::ios_base::failure(
"Duplicate Key, input Taproot internal key already provided");
750 }
else if (key.size() != 1) {
751 throw std::ios_base::failure(
"Input Taproot internal key key is more than one byte type");
758 if (!key_lookup.emplace(key).second) {
759 throw std::ios_base::failure(
"Duplicate Key, input Taproot merkle root already provided");
760 }
else if (key.size() != 1) {
761 throw std::ios_base::failure(
"Input Taproot merkle root key is more than one byte type");
768 if (!key_lookup.emplace(key).second) {
769 throw std::ios_base::failure(
"Duplicate Key, input participant pubkeys for an aggregate key already provided");
771 throw std::ios_base::failure(
"Input musig2 participants pubkeys aggregate key is not 34 bytes");
778 if (!key_lookup.emplace(key).second) {
779 throw std::ios_base::failure(
"Duplicate Key, input musig2 pubnonce already provided");
781 throw std::ios_base::failure(
"Input musig2 pubnonce key is not expected size of 67 or 99 bytes");
787 std::vector<uint8_t> pubnonce;
789 if (pubnonce.size() != 66) {
790 throw std::ios_base::failure(
"Input musig2 pubnonce value is not 66 bytes");
798 if (!key_lookup.emplace(key).second) {
799 throw std::ios_base::failure(
"Duplicate Key, input musig2 partial sig already provided");
801 throw std::ios_base::failure(
"Input musig2 partial sig key is not expected size of 67 or 99 bytes");
821 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
830 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
833 std::vector<unsigned char> val_bytes;
835 unknown.emplace(std::move(key), std::move(val_bytes));
841 throw std::ios_base::failure(
"Separator is missing at the end of an input map");
845 template <
typename Stream>
858 std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>>
m_tap_tree;
861 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
870 template <
typename Stream>
902 std::vector<unsigned char> value;
914 const auto& [leaf_hashes, origin] = leaf;
916 std::vector<unsigned char> value;
918 s_value << leaf_hashes;
926 std::vector<unsigned char> value;
928 for (
auto&
pk : part_pubs) {
929 s_value << std::span{
pk};
944 template <
typename Stream>
947 std::set<std::vector<unsigned char>> key_lookup;
950 bool found_sep =
false;
953 std::vector<unsigned char> key;
971 if (!key_lookup.emplace(key).second) {
972 throw std::ios_base::failure(
"Duplicate Key, output redeemScript already provided");
973 }
else if (key.size() != 1) {
974 throw std::ios_base::failure(
"Output redeemScript key is more than one byte type");
981 if (!key_lookup.emplace(key).second) {
982 throw std::ios_base::failure(
"Duplicate Key, output witnessScript already provided");
983 }
else if (key.size() != 1) {
984 throw std::ios_base::failure(
"Output witnessScript key is more than one byte type");
996 if (!key_lookup.emplace(key).second) {
997 throw std::ios_base::failure(
"Duplicate Key, output Taproot internal key already provided");
998 }
else if (key.size() != 1) {
999 throw std::ios_base::failure(
"Output Taproot internal key key is more than one byte type");
1006 if (!key_lookup.emplace(key).second) {
1007 throw std::ios_base::failure(
"Duplicate Key, output Taproot tree already provided");
1008 }
else if (key.size() != 1) {
1009 throw std::ios_base::failure(
"Output Taproot tree key is more than one byte type");
1011 std::vector<unsigned char> tree_v;
1014 if (s_tree.empty()) {
1015 throw std::ios_base::failure(
"Output Taproot tree must not be empty");
1018 while (!s_tree.empty()) {
1021 std::vector<unsigned char>
script;
1026 throw std::ios_base::failure(
"Output Taproot tree has as leaf greater than Taproot maximum depth");
1029 throw std::ios_base::failure(
"Output Taproot tree has a leaf with an invalid leaf version");
1032 builder.
Add((
int)depth,
script, (
int)leaf_ver,
true);
1035 throw std::ios_base::failure(
"Output Taproot tree is malformed");
1041 if (!key_lookup.emplace(key).second) {
1042 throw std::ios_base::failure(
"Duplicate Key, output Taproot BIP32 keypath already provided");
1043 }
else if (key.size() != 33) {
1044 throw std::ios_base::failure(
"Output Taproot BIP32 keypath key is not at 33 bytes");
1047 std::set<uint256> leaf_hashes;
1049 size_t before_hashes =
s.size();
1051 size_t after_hashes =
s.size();
1052 size_t hashes_len = before_hashes - after_hashes;
1053 if (hashes_len > value_len) {
1054 throw std::ios_base::failure(
"Output Taproot BIP32 keypath has an invalid length");
1056 size_t origin_len = value_len - hashes_len;
1062 if (!key_lookup.emplace(key).second) {
1063 throw std::ios_base::failure(
"Duplicate Key, output participant pubkeys for an aggregate key already provided");
1065 throw std::ios_base::failure(
"Output musig2 participants pubkeys aggregate key is not 34 bytes");
1075 this_prop.
key = key;
1078 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1087 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1090 std::vector<unsigned char> val_bytes;
1092 unknown.emplace(std::move(key), std::move(val_bytes));
1099 throw std::ios_base::failure(
"Separator is missing at the end of an output map");
1103 template <
typename Stream>
1112 std::optional<CMutableTransaction>
tx;
1115 std::map<KeyOriginInfo, std::set<CExtPubKey>>
m_xpubs;
1118 std::map<std::vector<unsigned char>, std::vector<unsigned char>>
unknown;
1141 template <
typename Stream>
1154 for (
const auto& xpub_pair :
m_xpubs) {
1155 for (
const auto& xpub : xpub_pair.second) {
1157 xpub.EncodeWithVersion(ser_xpub);
1197 template <
typename Stream>
1203 throw std::ios_base::failure(
"Invalid PSBT magic bytes");
1207 std::set<std::vector<unsigned char>> key_lookup;
1210 std::set<CExtPubKey> global_xpubs;
1213 bool found_sep =
false;
1216 std::vector<unsigned char> key;
1234 if (!key_lookup.emplace(key).second) {
1235 throw std::ios_base::failure(
"Duplicate Key, unsigned tx already provided");
1236 }
else if (key.size() != 1) {
1237 throw std::ios_base::failure(
"Global unsigned tx key is more than one byte type");
1242 tx = std::move(mtx);
1244 for (
const CTxIn& txin :
tx->vin) {
1246 throw std::ios_base::failure(
"Unsigned tx does not have empty scriptSigs and scriptWitnesses.");
1254 throw std::ios_base::failure(
"Size of key was not the expected size for the type global xpub");
1260 throw std::ios_base::failure(
"Invalid pubkey");
1262 if (global_xpubs.count(xpub) > 0) {
1263 throw std::ios_base::failure(
"Duplicate key, global xpub already provided");
1265 global_xpubs.insert(xpub);
1272 if (
m_xpubs.count(keypath) == 0) {
1277 m_xpubs[keypath].insert(xpub);
1284 throw std::ios_base::failure(
"Duplicate Key, version already provided");
1285 }
else if (key.size() != 1) {
1286 throw std::ios_base::failure(
"Global version key is more than one byte type");
1292 throw std::ios_base::failure(
"Unsupported version number");
1301 this_prop.
key = key;
1304 throw std::ios_base::failure(
"Duplicate Key, proprietary key already found");
1313 throw std::ios_base::failure(
"Duplicate Key, key for unknown value already provided");
1316 std::vector<unsigned char> val_bytes;
1318 unknown.emplace(std::move(key), std::move(val_bytes));
1324 throw std::ios_base::failure(
"Separator is missing at the end of the global map");
1329 throw std::ios_base::failure(
"No unsigned transaction was provided");
1334 while (!
s.empty() && i < tx->vin.size()) {
1342 throw std::ios_base::failure(
"Non-witness UTXO does not match outpoint hash");
1345 throw std::ios_base::failure(
"Input specifies output index that does not exist");
1351 if (
inputs.size() !=
tx->vin.size()) {
1352 throw std::ios_base::failure(
"Inputs provided does not match the number of inputs in transaction.");
1357 while (!
s.empty() && i < tx->vout.size()) {
1364 if (
outputs.size() !=
tx->vout.size()) {
1365 throw std::ios_base::failure(
"Outputs provided does not match the number of outputs in transaction.");
1369 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
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
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
static constexpr uint8_t PSBT_IN_PROPRIETARY
KeyOriginInfo DeserializeKeyOrigin(Stream &s, uint64_t length)
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
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
bool DecodeRawPSBT(PartiallySignedTransaction &decoded_psbt, std::span< const std::byte > raw_psbt, std::string &error)
Decode a raw (binary blob) PSBT into a PartiallySignedTransaction.
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.
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.