Inside Bitcoin

251    if (GetVersion() < 2) {
252        // This is a v0 psbt, do the v0 AddOutput
253        outputs.push_back(psbtout);
254        return true;
255    }
256
257    // No global tx, must be PSBTv2
258    // Check outputs are modifiable
259    if (!m_tx_modifiable.has_value() || !m_tx_modifiable->test(1)) {
260        return false;
261    }
262    outputs.push_back(psbtout);
263
264    return true;
265}
266
267bool PSBTInput::GetUTXO(CTxOut& utxo) const
268{
269    if (non_witness_utxo) {
270        if (prev_out >= non_witness_utxo->vout.size()) {
271            return false;
272        }
273        if (non_witness_utxo->GetHash() != prev_txid) {
274            return false;
275        }
276        utxo = non_witness_utxo->vout[prev_out];
277    } else if (!witness_utxo.IsNull()) {
278        utxo = witness_utxo;
279    } else {
280        return false;
281    }
282    return true;
283}
284
285COutPoint PSBTInput::GetOutPoint() const
286{
287    return COutPoint(prev_txid, prev_out);
288}
289
290void PSBTInput::FillSignatureData(SignatureData& sigdata) const
291{
292    if (!final_script_sig.empty()) {
293        sigdata.scriptSig = final_script_sig;
294        sigdata.complete = true;
295    }
296    if (!final_script_witness.IsNull()) {
297        sigdata.scriptWitness = final_script_witness;
298        sigdata.complete = true;
299    }
300    if (sigdata.complete) {
301        return;
302    }
303
304    sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
305    if (!redeem_script.empty()) {
306        sigdata.redeem_script = redeem_script;
307    }
308    if (!witness_script.empty()) {
309        sigdata.witness_script = witness_script;
310    }
311    for (const auto& key_pair : hd_keypaths) {
312        sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
313    }
314    if (!m_tap_key_sig.empty()) {
315        sigdata.taproot_key_path_sig = m_tap_key_sig;
316    }
317    for (const auto& [pubkey_leaf, sig] : m_tap_script_sigs) {
318        sigdata.taproot_script_sigs.emplace(pubkey_leaf, sig);
319    }
320    if (!m_tap_internal_key.IsNull()) {
321        sigdata.tr_spenddata.internal_key = m_tap_internal_key;
322    }
323    if (!m_tap_merkle_root.IsNull()) {
324        sigdata.tr_spenddata.merkle_root = m_tap_merkle_root;
325    }
326    for (const auto& [leaf_script, control_block] : m_tap_scripts) {
327        sigdata.tr_spenddata.scripts.emplace(leaf_script, control_block);
328    }
329    for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) {
330        sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin);
331        sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey);
332    }
333    for (const auto& [hash, preimage] : ripemd160_preimages) {
334        sigdata.ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
335    }
336    for (const auto& [hash, preimage] : sha256_preimages) {
337        sigdata.sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
338    }
339    for (const auto& [hash, preimage] : hash160_preimages) {
340        sigdata.hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
341    }
342    for (const auto& [hash, preimage] : hash256_preimages) {
343        sigdata.hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
344    }
345    sigdata.musig2_pubkeys.insert(m_musig2_participants.begin(), m_musig2_participants.end());
346    for (const auto& [agg_key_lh, pubnonces] : m_musig2_pubnonces) {
347        sigdata.musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
348    }
349    for (const auto& [agg_key_lh, psigs] : m_musig2_partial_sigs) {
350        sigdata.musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
351    }
352}
353
354void PSBTInput::FromSignatureData(const SignatureData& sigdata)
355{
356    if (sigdata.complete) {
357        partial_sigs.clear();
358        hd_keypaths.clear();
359        redeem_script.clear();
360        witness_script.clear();
361
362        if (!sigdata.scriptSig.empty()) {
363            final_script_sig = sigdata.scriptSig;
364        }
365        if (!sigdata.scriptWitness.IsNull()) {
366            final_script_witness = sigdata.scriptWitness;
367        }
368        return;
369    }
370
371    partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
372    if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
373        redeem_script = sigdata.redeem_script;
374    }
375    if (witness_script.empty() && !sigdata.witness_script.empty()) {
376        witness_script = sigdata.witness_script;
377    }
378    for (const auto& entry : sigdata.misc_pubkeys) {
379        hd_keypaths.emplace(entry.second);
380    }
381    if (!sigdata.taproot_key_path_sig.empty()) {
382        m_tap_key_sig = sigdata.taproot_key_path_sig;
383    }
384    for (const auto& [pubkey_leaf, sig] : sigdata.taproot_script_sigs) {
385        m_tap_script_sigs.emplace(pubkey_leaf, sig);
386    }
387    if (!sigdata.tr_spenddata.internal_key.IsNull()) {
388        m_tap_internal_key = sigdata.tr_spenddata.internal_key;
389    }
390    if (!sigdata.tr_spenddata.merkle_root.IsNull()) {
391        m_tap_merkle_root = sigdata.tr_spenddata.merkle_root;
392    }
393    for (const auto& [leaf_script, control_block] : sigdata.tr_spenddata.scripts) {
394        m_tap_scripts.emplace(leaf_script, control_block);
395    }
396    for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) {
397        m_tap_bip32_paths.emplace(pubkey, leaf_origin);
398    }
399    m_musig2_participants.insert(sigdata.musig2_pubkeys.begin(), sigdata.musig2_pubkeys.end());
400    for (const auto& [agg_key_lh, pubnonces] : sigdata.musig2_pubnonces) {
401        m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
402    }
403    for (const auto& [agg_key_lh, psigs] : sigdata.musig2_partial_sigs) {
404        m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
405    }
406    for (const auto& [hash, preimage] : sigdata.ripemd160_preimages) {
407        ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
408    }
409    for (const auto& [hash, preimage] : sigdata.sha256_preimages) {
410        sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
411    }
412    for (const auto& [hash, preimage] : sigdata.hash160_preimages) {
413        hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
414    }
415    for (const auto& [hash, preimage] : sigdata.hash256_preimages) {
416        hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage);
417    }
418}
419
420void PSBTInput::Merge(const PSBTInput& input)
421{
422    if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo;
423    if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) {
424        witness_utxo = input.witness_utxo;
425    }
426
427    partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
428    ripemd160_preimages.insert(input.ripemd160_preimages.begin(), input.ripemd160_preimages.end());
429    sha256_preimages.insert(input.sha256_preimages.begin(), input.sha256_preimages.end());
430    hash160_preimages.insert(input.hash160_preimages.begin(), input.hash160_preimages.end());
431    hash256_preimages.insert(input.hash256_preimages.begin(), input.hash256_preimages.end());
432    hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
433    m_proprietary.insert(input.m_proprietary.begin(), input.m_proprietary.end());
434    unknown.insert(input.unknown.begin(), input.unknown.end());
435    m_tap_script_sigs.insert(input.m_tap_script_sigs.begin(), input.m_tap_script_sigs.end());
436    // Merge by control block, the serialized key (BIP 371), to avoid duplicate keys. Keep the
437    // leaf script already present; BIP 174 lets the Combiner pick arbitrarily on conflict.
438    std::set<std::vector<unsigned char>> seen_control_blocks;
439    for (const auto& [_, control_blocks] : m_tap_scripts) {
440        seen_control_blocks.insert(control_blocks.begin(), control_blocks.end());
441    }
442    for (const auto& [leaf, control_blocks] : input.m_tap_scripts) {
443        for (const auto& control_block : control_blocks) {
444            if (seen_control_blocks.insert(control_block).second) m_tap_scripts[leaf].insert(control_block);
445        }
446    }
447    m_tap_bip32_paths.insert(input.m_tap_bip32_paths.begin(), input.m_tap_bip32_paths.end());
448
449    if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script;
450    if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
451    if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
452    if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
453    if (m_tap_key_sig.empty() && !input.m_tap_key_sig.empty()) m_tap_key_sig = input.m_tap_key_sig;
454    if (m_tap_internal_key.IsNull() && !input.m_tap_internal_key.IsNull()) m_tap_internal_key = input.m_tap_internal_key;
455    if (m_tap_merkle_root.IsNull() && !input.m_tap_merkle_root.IsNull()) m_tap_merkle_root = input.m_tap_merkle_root;
456    m_musig2_participants.insert(input.m_musig2_participants.begin(), input.m_musig2_participants.end());
457    for (const auto& [agg_key_lh, pubnonces] : input.m_musig2_pubnonces) {
458        m_musig2_pubnonces[agg_key_lh].insert(pubnonces.begin(), pubnonces.end());
459    }
460    for (const auto& [agg_key_lh, psigs] : input.m_musig2_partial_sigs) {
461        m_musig2_partial_sigs[agg_key_lh].insert(psigs.begin(), psigs.end());
462    }
463    if (sighash_type == std::nullopt && input.sighash_type != std::nullopt) sighash_type = input.sighash_type;
464    if (sequence == std::nullopt && input.sequence != std::nullopt) sequence = input.sequence;
465    if (time_locktime == std::nullopt && input.time_locktime != std::nullopt) time_locktime = input.time_locktime;
466    if (height_locktime == std::nullopt && input.height_locktime != std::nullopt) height_locktime = input.height_locktime;
467}
468
469bool PSBTInput::HasSignatures() const
470{
471    return !final_script_sig.empty()
472           || !final_script_witness.IsNull()
473           || !partial_sigs.empty()
474           || !m_tap_key_sig.empty()
475           || !m_tap_script_sigs.empty()
476           || !m_musig2_partial_sigs.empty();
477}
478
479void PSBTOutput::FillSignatureData(SignatureData& sigdata) const
480{
481    if (!redeem_script.empty()) {
482        sigdata.redeem_script = redeem_script;
483    }
484    if (!witness_script.empty()) {
485        sigdata.witness_script = witness_script;
486    }
487    for (const auto& key_pair : hd_keypaths) {
488        sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair);
489    }
490    if (!m_tap_tree.empty() && m_tap_internal_key.IsFullyValid()) {
491        TaprootBuilder builder;
492        for (const auto& [depth, leaf_ver, script] : m_tap_tree) {
493            builder.Add((int)depth, script, (int)leaf_ver, /*track=*/true);
494        }
495        assert(builder.IsComplete());
496        builder.Finalize(m_tap_internal_key);
497        TaprootSpendData spenddata = builder.GetSpendData();
498
499        sigdata.tr_spenddata.internal_key = m_tap_internal_key;
500        sigdata.tr_spenddata.Merge(spenddata);