Methods for interacting with PSBT structs

Added methods which move data to/from SignaturData objects to
PSBTInput and PSBTOutput objects.

Added sanity checks for PSBTs as a whole which are done immediately
after deserialization.

Added Merge methods to merge a PSBT into another one.

2 files changed, 146 insertions, 0 deletions

diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index b62fe2e92e..28dfdecdfc 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -447,12 +447,144 @@ bool PartiallySignedTransaction::IsNull() const
     return !tx && inputs.empty() && outputs.empty() && unknown.empty();
 }
 
+void PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
+{
+    for (unsigned int i = 0; i < inputs.size(); ++i) {
+        inputs[i].Merge(psbt.inputs[i]);
+    }
+    for (unsigned int i = 0; i < outputs.size(); ++i) {
+        outputs[i].Merge(psbt.outputs[i]);
+    }
+}
+
+bool PartiallySignedTransaction::IsSane() const
+{
+    for (PSBTInput input : inputs) {
+        if (!input.IsSane()) return false;
+    }
+    return true;
+}
+
 bool PSBTInput::IsNull() const
 {
     return !non_witness_utxo && witness_utxo.IsNull() && partial_sigs.empty() && unknown.empty() && hd_keypaths.empty() && redeem_script.empty() && witness_script.empty();
 }
 
+void PSBTInput::FillSignatureData(SignatureData& sigdata) const
+{
+    if (!final_script_sig.empty()) {
+        sigdata.scriptSig = final_script_sig;
+        sigdata.complete = true;
+    }
+    if (!final_script_witness.IsNull()) {
+        sigdata.scriptWitness = final_script_witness;
+        sigdata.complete = true;
+    }
+    if (sigdata.complete) {
+        return;
+    }
+
+    sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end());
+    if (!redeem_script.empty()) {
+        sigdata.redeem_script = redeem_script;
+    }
+    if (!witness_script.empty()) {
+        sigdata.witness_script = witness_script;
+    }
+    for (const auto& key_pair : hd_keypaths) {
+        sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair.first);
+    }
+}
+
+void PSBTInput::FromSignatureData(const SignatureData& sigdata)
+{
+    if (sigdata.complete) {
+        partial_sigs.clear();
+        hd_keypaths.clear();
+        redeem_script.clear();
+        witness_script.clear();
+
+        if (!sigdata.scriptSig.empty()) {
+            final_script_sig = sigdata.scriptSig;
+        }
+        if (!sigdata.scriptWitness.IsNull()) {
+            final_script_witness = sigdata.scriptWitness;
+        }
+        return;
+    }
+
+    partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end());
+    if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+        redeem_script = sigdata.redeem_script;
+    }
+    if (witness_script.empty() && !sigdata.witness_script.empty()) {
+        witness_script = sigdata.witness_script;
+    }
+}
+
+void PSBTInput::Merge(const PSBTInput& input)
+{
+    if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo;
+    if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) {
+        witness_utxo = input.witness_utxo;
+        non_witness_utxo = nullptr; // Clear out any non-witness utxo when we set a witness one.
+    }
+
+    partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end());
+    hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end());
+    unknown.insert(input.unknown.begin(), input.unknown.end());
+
+    if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script;
+    if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
+    if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
+    if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
+}
+
+bool PSBTInput::IsSane() const
+{
+    // Cannot have both witness and non-witness utxos
+    if (!witness_utxo.IsNull() && non_witness_utxo) return false;
+
+    // If we have a witness_script or a scriptWitness, we must also have a witness utxo
+    if (!witness_script.empty() && witness_utxo.IsNull()) return false;
+    if (!final_script_witness.IsNull() && witness_utxo.IsNull()) return false;
+
+    return true;
+}
+
+void PSBTOutput::FillSignatureData(SignatureData& sigdata) const
+{
+    if (!redeem_script.empty()) {
+        sigdata.redeem_script = redeem_script;
+    }
+    if (!witness_script.empty()) {
+        sigdata.witness_script = witness_script;
+    }
+    for (const auto& key_pair : hd_keypaths) {
+        sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair.first);
+    }
+}
+
+void PSBTOutput::FromSignatureData(const SignatureData& sigdata)
+{
+    if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+        redeem_script = sigdata.redeem_script;
+    }
+    if (witness_script.empty() && !sigdata.witness_script.empty()) {
+        witness_script = sigdata.witness_script;
+    }
+}
+
 bool PSBTOutput::IsNull() const
 {
     return redeem_script.empty() && witness_script.empty() && hd_keypaths.empty() && unknown.empty();
 }
+
+void PSBTOutput::Merge(const PSBTOutput& output)
+{
+    hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end());
+    unknown.insert(output.unknown.begin(), output.unknown.end());
+
+    if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script;
+    if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script;
+}
diff --git a/src/script/sign.h b/src/script/sign.h
index 5384f97539..ab2153e3b9 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -187,6 +187,10 @@ struct PSBTInput
     int sighash_type = 0;
 
     bool IsNull() const;
+    void FillSignatureData(SignatureData& sigdata) const;
+    void FromSignatureData(const SignatureData& sigdata);
+    void Merge(const PSBTInput& input);
+    bool IsSane() const;
     PSBTInput() {}
 
     template <typename Stream>
@@ -375,6 +379,10 @@ struct PSBTOutput
     std::map<std::vector<unsigned char>, std::vector<unsigned char>> unknown;
 
     bool IsNull() const;
+    void FillSignatureData(SignatureData& sigdata) const;
+    void FromSignatureData(const SignatureData& sigdata);
+    void Merge(const PSBTOutput& output);
+    bool IsSane() const;
     PSBTOutput() {}
 
     template <typename Stream>
@@ -472,6 +480,8 @@ struct PartiallySignedTransaction
     std::map<std::vector<unsigned char>, std::vector<unsigned char>> unknown;
 
     bool IsNull() const;
+    void Merge(const PartiallySignedTransaction& psbt);
+    bool IsSane() const;
     PartiallySignedTransaction() {}
     PartiallySignedTransaction(const PartiallySignedTransaction& psbt_in) : tx(psbt_in.tx), inputs(psbt_in.inputs), outputs(psbt_in.outputs), unknown(psbt_in.unknown) {}
 
@@ -605,6 +615,10 @@ struct PartiallySignedTransaction
         if (outputs.size() != tx->vout.size()) {
             throw std::ios_base::failure("Outputs provided does not match the number of outputs in transaction.");
         }
+        // Sanity check
+        if (!IsSane()) {
+            throw std::ios_base::failure("PSBT is not sane.");
+        }
     }
 
     template <typename Stream>