Implement BIP 370 PSBTv2 #21283

1192+        }
1193+        if (psbtx.fallback_locktime != std::nullopt) {
1194+            result.pushKV("fallback_locktime", static_cast<uint64_t>(*psbtx.fallback_locktime));
1195+        }
1196+        result.pushKV("input_count", psbtx.inputs.size());
1197+        result.pushKV("output_count", psbtx.inputs.size());

18@@ -19,6 +19,14 @@ PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction
19     SetupFromTx(tx);
20 }
21 
22+PartiallySignedTransaction::PartiallySignedTransaction(uint32_t version) :
23+    m_version(version)
24+{
25+    if (GetVersion() >= 2) {
26+        tx_version = CTransaction::CURRENT_VERSION;

803@@ -661,6 +804,10 @@ struct PartiallySignedTransaction
804 
805         // Read global data
806         bool found_sep = false;
807+        uint32_t input_count = 0;
808+        uint32_t output_count = 0;

432@@ -428,6 +433,12 @@ struct PartiallySignedTransaction
433         OverrideStream<Stream> os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS);
434         SerializeToVector(os, *tx);
435 
436+        // PSBT version
437+        if (m_version != std::nullopt && m_version > 0) {

306@@ -305,8 +307,20 @@ struct CExtPubKey {
307         return !(a == b);
308     }
309 
310+    friend bool operator<(const CExtPubKey &a, const CExtPubKey &b)
311+    {
312+        if (a.pubkey < b.pubkey) {
313+            return true;
314+        } else if (a.pubkey > b.pubkey) {

183@@ -56,68 +184,109 @@ struct PSBTInput
184     CScriptWitness final_script_witness;
185     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
186     std::map<CKeyID, SigPair> partial_sigs;
187+    uint256 prev_txid;

198     bool IsNull() const;
199     void FillSignatureData(SignatureData& sigdata) const;
200     void FromSignatureData(const SignatureData& sigdata);
201     void Merge(const PSBTInput& input);
202-    PSBTInput() {}
203+    bool GetUTXO(CTxOut& utxo) const;

19@@ -20,6 +20,14 @@ PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction
20     SetupFromTx(tx);
21 }
22 
23+PartiallySignedTransaction::PartiallySignedTransaction(uint32_t version) :

1694+    }
1695+    if (psbt_version != 2 && psbt_version != 0) {
1696+        throw JSONRPCError(RPC_INVALID_PARAMETER, "The PSBT version can only be 2 or 0");
1697+    }
1698+
1699+    PartiallySignedTransaction psbtx(rawTx, /* version=*/ 2);

1178-     * @param[in] input_index Index of the input to retrieve the UTXO of
1179-     * @return Whether the UTXO for the specified input was found
1180-     */
1181-    bool GetInputUTXO(CTxOut& utxo, int input_index) const;
1182+    PartiallySignedTransaction(uint32_t version);
1183+    explicit PartiallySignedTransaction(const CMutableTransaction& tx, uint32_t version = 0);

1784 
1785     // Create a blank psbt where everything will be added
1786     PartiallySignedTransaction merged_psbt;
1787+    merged_psbt.tx_version = best_version;
1788+    merged_psbt.fallback_locktime = best_locktime;
1789+    // TODO: Remove for PSBTv2

1762         PartiallySignedTransaction psbtx;
1763         std::string error;
1764         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
1765             throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
1766         }
1767+        if (psbtx.GetVersion() != 0) {

1769@@ -1770,6 +1770,9 @@ static RPCHelpMan joinpsbts()
1770         if (!DecodeBase64PSBT(psbtx, txs[i].get_str(), error)) {
1771             throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
1772         }
1773+        if (psbtx.GetVersion() != 0) {
1774+            throw JSONRPCError(RPC_INVALID_PARAMETER, "joinpsbts only operates on version 0 PSBTs");
1775+        }

127+
128+    // Get the unsigned transaction
129+    CMutableTransaction mtx = GetUnsignedTx();
130+    // Compute the locktime
131+    bool locktime_success = ComputeTimeLock(mtx.nLockTime);
132+    assert(locktime_success);

1797@@ -1740,40 +1798,46 @@ static RPCHelpMan joinpsbts()
1798         throw JSONRPCError(RPC_INVALID_PARAMETER, "At least two PSBTs are required to join PSBTs.");
1799     }
1800 
1801-    uint32_t best_version = 1;
1802+    int32_t best_version = 1;

 97@@ -98,7 +98,7 @@ std::set<int> InterpretSubtractFeeFromOutputInstructions(const UniValue& sffo_in
 98 static UniValue FinishTransaction(const std::shared_ptr<CWallet> pwallet, const UniValue& options, const CMutableTransaction& rawTx)
 99 {
100     // Make a blank psbt
101-    PartiallySignedTransaction psbtx(rawTx);
102+    PartiallySignedTransaction psbtx(rawTx, /*version=*/2);

1181-     * @param[out] utxo The UTXO of the input if found
1182-     * @param[in] input_index Index of the input to retrieve the UTXO of
1183-     * @return Whether the UTXO for the specified input was found
1184-     */
1185-    bool GetInputUTXO(CTxOut& utxo, int input_index) const;
1186+    explicit PartiallySignedTransaction(const CMutableTransaction& tx, uint32_t version = 2);

155@@ -156,10 +156,10 @@
156         },
157         {
158             "combine" : [
159-                "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAKDwECAwQFBgcICQ8BAgMEBQYHCAkKCwwNDg8ACg8BAgMEBQYHCAkPAQIDBAUGBwgJCgsMDQ4PAAoPAQIDBAUGBwgJDwECAwQFBgcICQoLDA0ODwA=",
160-                "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAKDwECAwQFBgcIEA8BAgMEBQYHCAkKCwwNDg8ACg8BAgMEBQYHCBAPAQIDBAUGBwgJCgsMDQ4PAAoPAQIDBAUGBwgQDwECAwQFBgcICQoLDA0ODwA="
161+                "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAK8AECAwQFBgcICQ8BAgMEBQYHCAkKCwwNDg8ACvABAgMEBQYHCAkPAQIDBAUGBwgJCgsMDQ4PAArwAQIDBAUGBwgJDwECAwQFBgcICQoLDA0ODwA=",
162+                "cHNidP8BAD8CAAAAAf//////////////////////////////////////////AAAAAAD/////AQAAAAAAAAAAA2oBAAAAAAAK8AECAwQFBgcIEA8BAgMEBQYHCAkKCwwNDg8ACvABAgMEBQYHCBAPAQIDBAUGBwgJCgsMDQ4PAArwAQIDBAUGBwgQDwECAwQFBgcICQoLDA0ODwA="

1218@@ -1063,6 +1219,10 @@ struct PartiallySignedTransaction
1219 
1220         // Read global data
1221         bool found_sep = false;
1222+        uint64_t input_count = 0;
1223+        uint64_t output_count = 0;
1224+        bool found_input_count = false;

613@@ -584,6 +614,70 @@ struct PSBTInput
614                     hash256_preimages.emplace(hash, std::move(preimage));
615                     break;
616                 }
617+                case PSBT_IN_PREVIOUS_TXID:
618+                {
619+                    if (!key_lookup.emplace(key).second) {
620+                        throw std::ios_base::failure("Duplicate Key, previous txid is already provided");
621+                    } else if (key.size() != 1) {
622+                        throw std::ios_base::failure("Previous txid key is more than one byte type");

619+                    if (!key_lookup.emplace(key).second) {
620+                        throw std::ios_base::failure("Duplicate Key, previous txid is already provided");
621+                    } else if (key.size() != 1) {
622+                        throw std::ios_base::failure("Previous txid key is more than one byte type");
623+                    }
624+                    UnserializeFromVector(s, prev_txid);

840     bool IsNull() const;
841     void FillSignatureData(SignatureData& sigdata) const;
842     void FromSignatureData(const SignatureData& sigdata);
843     void Merge(const PSBTOutput& output);
844-    PSBTOutput() = default;
845+    PSBTOutput(uint32_t version) : m_psbt_version(version) {}

1407@@ -1404,10 +1408,12 @@ struct PartiallySignedTransaction
1408             throw std::ios_base::failure("No unsigned transaction was provided");
1409         }
1410 
1411+        uint32_t psbt_ver = GetVersion();

1584@@ -1585,10 +1585,10 @@ static RPCHelpMan createpsbt()
1585     PartiallySignedTransaction psbtx;
1586     psbtx.tx = rawTx;
1587     for (unsigned int i = 0; i < rawTx.vin.size(); ++i) {
1588-        psbtx.inputs.emplace_back();
1589+        psbtx.inputs.emplace_back(0);

196@@ -197,11 +197,11 @@ FUZZ_TARGET_DESERIALIZE(prefilled_transaction_deserialize, {
197     DeserializeFromFuzzingInput(buffer, prefilled_transaction);
198 })
199 FUZZ_TARGET_DESERIALIZE(psbt_input_deserialize, {
200-    PSBTInput psbt_input;
201+    PSBTInput psbt_input(0);

1498@@ -1419,10 +1499,14 @@ struct PartiallySignedTransaction
1499 
1500             // Make sure the non-witness utxo matches the outpoint
1501             if (input.non_witness_utxo) {
1502-                if (input.non_witness_utxo->GetHash() != tx->vin[i].prevout.hash) {
1503+                if ((tx != std::nullopt && input.non_witness_utxo->GetHash() != tx->vin[i].prevout.hash)
1504+                    || (!input.prev_txid.IsNull() && input.non_witness_utxo->GetHash() != input.prev_txid)

13@@ -14,6 +14,7 @@ PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction
14 {
15     inputs.resize(tx.vin.size(), PSBTInput(GetVersion()));
16     outputs.resize(tx.vout.size(), PSBTOutput(GetVersion()));
17+    CacheUnsignedTxPieces();

1157@@ -1158,6 +1158,8 @@ struct PartiallySignedTransaction
1158     [[nodiscard]] bool Merge(const PartiallySignedTransaction& psbt);
1159     bool AddInput(const CTxIn& txin, PSBTInput& psbtin);
1160     bool AddOutput(const CTxOut& txout, const PSBTOutput& psbtout);
1161+    void SetupFromTx(const CMutableTransaction& tx);
1162+    void CacheUnsignedTxPieces();

109@@ -110,6 +110,21 @@ CMutableTransaction PartiallySignedTransaction::GetUnsignedTx() const
110     return mtx;
111 }
112 
113+uint256 PartiallySignedTransaction::GetUniqueID() const
114+{
115+    if (tx != std::nullopt) {

142-    psbtin.final_script_witness.SetNull();
143-    inputs.push_back(psbtin);
144-    return true;
145+
146+    if (tx != std::nullopt) {
147+        // This is a v0 psbt, so do the v0 AddInput

155+        psbtin.final_script_witness.SetNull();
156+        inputs.push_back(psbtin);
157+        return true;
158+    }
159+
160+    // TODO: Do PSBTv2

144-    return true;
145+
146+    if (tx != std::nullopt) {
147+        // This is a v0 psbt, so do the v0 AddInput
148+        CTxIn txin(COutPoint(psbtin.prev_txid, *psbtin.prev_out));
149+        if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {

124@@ -125,17 +125,32 @@ uint256 PartiallySignedTransaction::GetUniqueID() const
125     return mtx.GetHash();
126 }
127 
128-bool PartiallySignedTransaction::AddInput(const CTxIn& txin, PSBTInput& psbtin)
129+bool PartiallySignedTransaction::AddInput(PSBTInput& psbtin)
130 {
131-    if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) {
132+    if (std::find_if(inputs.begin(), inputs.end(),
133+        [psbtin](const PSBTInput& psbt) {

29@@ -30,6 +30,7 @@ bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
30         return false;
31     }
32 
33+    assert(*tx_version == psbt.tx_version);

65@@ -66,8 +66,8 @@ def signet_txs(block, challenge):
66 def decode_challenge_psbt(b64psbt):
67     psbt = PSBT.from_base64(b64psbt)
68 
69-    assert len(psbt.tx.vin) == 1
70-    assert len(psbt.tx.vout) == 1
71+    assert len(psbt.i) == 1
72+    assert len(psbt.i) == 1

1309+        // Make sure required PSBTv2 fields are present
1310+        if (m_psbt_version >= 2) {
1311+            if (amount == std::nullopt) {
1312+                throw std::ios_base::failure("Output amount is required in PSBTv2");
1313+            }
1314+            if (!script.has_value()) {

586-    std::vector<CTxOut> utxos(tx.vin.size());
587-    for (size_t idx = 0; idx < tx.vin.size(); ++idx) {
588-        if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false;
589+    std::vector<CTxOut> utxos;
590+    for (const PSBTInput& input : psbt.inputs) {
591+        if (!input.GetUTXO(utxos.emplace_back())) have_all_spent_outputs = false;

169+            return false;
170+        }
171+        // Prevent duplicate inputs
172+        if (std::find_if(inputs.begin(), inputs.end(),
173+            [psbtin](const PSBTInput& psbt) {
174+                return psbt.prev_txid == psbtin.prev_txid && psbt.prev_out == psbtin.prev_out;

194+                return false;
195+            }
196+
197+            std::optional<uint32_t> time_lock = psbtin.time_locktime;
198+            std::optional<uint32_t> height_lock = psbtin.height_locktime;
199+            bool has_sigs = false;

247+    if (tx != std::nullopt) {
248+        // This is a v0 psbt, do the v0 AddOutput
249+        CTxOut txout(*psbtout.amount, *psbtout.script);
250+        tx->vout.push_back(txout);
251+        outputs.push_back(psbtout);
252+        return true;

186+        // For now, we only do this if the new input has a required time lock.
187+        // The BIP states that we should also do this if m_tx_modifiable's bit 2 is set
188+        // (Has SIGHASH_SINGLE flag) but since we are only adding inputs at the end of the vector,
189+        // we don't care about that.
190+        bool iterate_inputs = psbtin.time_locktime != std::nullopt || psbtin.height_locktime != std::nullopt;
191+        if (iterate_inputs) {

131+    return mtx;
132+}
133+
134+Txid PartiallySignedTransaction::GetUniqueID() const
135+{
136+    if (m_version == 0) {

470@@ -463,6 +471,28 @@ struct PSBTInput
471             SerializeToVector(s, final_script_witness.stack);
472         }
473 
474+        // Write prev txid, vout, sequence, and lock times
475+        if (!prev_txid.IsNull()) {

780+                        throw std::ios_base::failure("Required height based locktime is more than one byte type");
781+                    }
782+                    uint32_t v;
783+                    UnserializeFromVector(s, v);
784+                    if (v >= LOCKTIME_THRESHOLD) {
785+                        throw std::ios_base::failure("Required time based locktime is invalid (greater than or equal to 500000000)");

1152+                    } else if (key.size() != 1) {
1153+                        throw std::ios_base::failure("Output script key is more than one byte type");
1154+                    }
1155+                    CScript v;
1156+                    s >> v;
1157+                    script = v;

310     bool IsNull() const;
311     void FillSignatureData(SignatureData& sigdata) const;
312     void FromSignatureData(const SignatureData& sigdata);
313     void Merge(const PSBTInput& input);
314-    PSBTInput() = default;
315+    PSBTInput(uint32_t psbt_version) : m_psbt_version(psbt_version) {}

733@@ -731,6 +734,8 @@ struct PSBTInput
734                         throw std::ios_base::failure("Duplicate Key, previous txid is already provided");
735                     } else if (key.size() != 1) {
736                         throw std::ios_base::failure("Previous txid key is more than one byte type");
737+                    } else if (m_psbt_version == 0) {