Merge bitcoin/bitcoin#35797: psbt: support output metadata updates before inputs are added

### src/psbt.cpp
@@ -605,8 +605,7 @@ void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransactio
     if (!unsigned_tx) {
         return;
     }
-    CMutableTransaction& tx = *unsigned_tx;
-    const CTxOut& out = tx.vout.at(index);
+    const CTxOut& out = unsigned_tx->vout.at(index);
     PSBTOutput& psbt_out = psbt.outputs.at(index);
 
     // Fill a SignatureData with output info
@@ -616,6 +615,8 @@ void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransactio
     // Construct a would-be spend of this output, to update sigdata with.
     // Note that ProduceSignature is used to fill in metadata (not actual signatures),
     // so provider does not need to provide any private keys (it can be a HidingSigningProvider).
+    CMutableTransaction tx{};
+    tx.vin.emplace_back();
     MutableTransactionSignatureCreator creator(tx, /*input_idx=*/0, out.nValue, {.sighash_type = SIGHASH_ALL});
     ProduceSignature(provider, creator, out.scriptPubKey, sigdata);
 

### src/test/psbt_tests.cpp
@@ -2,10 +2,21 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
+#include <key.h>
 #include <psbt.h>
+#include <script/descriptor.h>
+#include <script/script.h>
+#include <script/signingprovider.h>
+#include <script/solver.h>
+#include <test/util/setup_common.h>
+#include <util/strencodings.h>
+#include <util/string.h>
 
 #include <boost/test/unit_test.hpp>
-#include <test/util/setup_common.h>
+
+#include <string>
+#include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(psbt_tests, BasicTestingSetup)
 
@@ -216,4 +227,89 @@ BOOST_AUTO_TEST_CASE(merge_proprietary_fields)
     BOOST_CHECK(output_it->value == right_prop.value);
 }
 
+struct PSBTOutputTest {
+    CPubKey pubkey;
+    FlatSigningProvider provider;
+    CScript script_pubkey;
+
+    explicit PSBTOutputTest(std::string descriptor)
+    {
+        CKey key{GenerateRandomKey()};
+        pubkey = key.GetPubKey();
+        provider.keys.emplace(pubkey.GetID(), key);
+
+        util::ReplaceAll(descriptor, "<KEY>", HexStr(pubkey));
+        std::string error;
+        auto descriptors{Parse(descriptor, provider, error, /*require_checksum=*/false)};
+        BOOST_REQUIRE_MESSAGE(!descriptors.empty(), error);
+        std::vector<CScript> output_scripts;
+        BOOST_REQUIRE(descriptors[0]->Expand(/*pos=*/0, provider, output_scripts, provider));
+        BOOST_REQUIRE_EQUAL(output_scripts.size(), 1);
+        script_pubkey = output_scripts[0];
+    }
+
+    PSBTOutput UpdateOutput(bool has_input) const
+    {
+        CMutableTransaction tx;
+        if (has_input) tx.vin.emplace_back();
+        tx.vout.emplace_back(0, script_pubkey);
+        PartiallySignedTransaction psbt{tx};
+        UpdatePSBTOutput(provider, psbt, 0);
+        return psbt.outputs[0];
+    }
+};
+
+BOOST_AUTO_TEST_CASE(update_psbt_output_keypaths)
+{
+    for (bool has_input : {false, true}) {
+        for (const auto& descriptor : {"pkh(<KEY>)", "wpkh(<KEY>)"}) {
+            PSBTOutputTest test{descriptor};
+            auto out{test.UpdateOutput(has_input)};
+            BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
+            BOOST_CHECK(out.redeem_script.empty());
+            BOOST_CHECK(out.witness_script.empty());
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(update_psbt_output_redeem_script)
+{
+    for (bool has_input : {false, true}) {
+        PSBTOutputTest test{"sh(wpkh(<KEY>))"};
+        auto out{test.UpdateOutput(has_input)};
+        BOOST_CHECK(out.redeem_script == GetScriptForDestination(WitnessV0KeyHash{test.pubkey}));
+        BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(update_psbt_output_witness_script)
+{
+    for (bool has_input : {false, true}) {
+        PSBTOutputTest test{"wsh(pk(<KEY>))"};
+        auto out{test.UpdateOutput(has_input)};
+        BOOST_CHECK(out.witness_script == GetScriptForRawPubKey(test.pubkey));
+        BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(update_psbt_output_miniscript_timelock)
+{
+    for (bool has_input : {false, true}) {
+        PSBTOutputTest test{"wsh(and_v(v:pk(<KEY>),older(144)))"};
+        auto out{test.UpdateOutput(has_input)};
+        BOOST_CHECK(GetScriptForDestination(WitnessV0ScriptHash{out.witness_script}) == test.script_pubkey);
+        BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(update_psbt_output_taproot)
+{
+    for (bool has_input : {false, true}) {
+        PSBTOutputTest test{"rawtr(<KEY>)"};
+        auto out{test.UpdateOutput(has_input)};
+        BOOST_CHECK(out.m_tap_bip32_paths.contains(XOnlyPubKey{test.pubkey}));
+        BOOST_CHECK(out.hd_keypaths.empty());
+    }
+}
+
 BOOST_AUTO_TEST_SUITE_END()

### test/functional/rpc_psbt.py
@@ -1424,6 +1424,14 @@ def test_psbt_input_keys(psbt_input, keys):
         utxo = self.create_outpoints(self.nodes[0], outputs=[{address: 1}])[0]
         self.sync_all()
 
+        self.log.info("Test descriptorprocesspsbt updates PSBT outputs")
+        for has_input in [False, True]:
+            output_psbt = self.nodes[2].createpsbt([utxo] if has_input else [], {address: 1})
+            processed = self.nodes[2].descriptorprocesspsbt(psbt=output_psbt, descriptors=[descriptor], finalize=False)
+            decoded = self.nodes[2].decodepsbt(processed["psbt"])
+            assert_equal(len(decoded["inputs"]), int(has_input))
+            assert_equal(len(decoded["outputs"][0]["bip32_derivs"]), 1)
+
         psbt = self.nodes[2].createpsbt([utxo], {self.nodes[0].getnewaddress(): 0.99999})
         decoded = self.nodes[2].decodepsbt(psbt)
         test_psbt_input_keys(decoded['inputs'][0], [])