1251}
1252
1253bool DescriptorScriptPubKeyMan::HaveCryptedKeys() const
1254{
1255    LOCK(cs_desc_man);
1256    return !m_map_crypted_keys.empty();
1257}
1258
1259unsigned int DescriptorScriptPubKeyMan::GetKeyPoolSize() const
1260{
1261    LOCK(cs_desc_man);
1262    return m_wallet_descriptor.GetEnd() - m_wallet_descriptor.GetNext();
1263}
1264
1265int64_t DescriptorScriptPubKeyMan::GetTimeFirstKey() const
1266{
1267    LOCK(cs_desc_man);
1268    return m_wallet_descriptor.creation_time;
1269}
1270
1271std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CScript& script, bool include_private) const
1272{
1273    LOCK(cs_desc_man);
1274
1275    // Find the index of the script
1276    auto it = m_map_script_pub_keys.find(script);
1277    if (it == m_map_script_pub_keys.end()) {
1278        return nullptr;
1279    }
1280    int32_t index = it->second;
1281
1282    return GetSigningProvider(index, include_private);
1283}
1284
1285std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(const CPubKey& pubkey) const
1286{
1287    LOCK(cs_desc_man);
1288
1289    // Find index of the pubkey
1290    auto it = m_map_pubkeys.find(pubkey);
1291    if (it == m_map_pubkeys.end()) {
1292        return nullptr;
1293    }
1294    int32_t index = it->second;
1295
1296    // Always try to get the signing provider with private keys. This function should only be called during signing anyways
1297    std::unique_ptr<FlatSigningProvider> out = GetSigningProvider(index, true);
1298    if (!out->HaveKey(pubkey.GetID())) {
1299        return nullptr;
1300    }
1301    return out;
1302}
1303
1304std::unique_ptr<FlatSigningProvider> DescriptorScriptPubKeyMan::GetSigningProvider(int32_t index, bool include_private) const
1305{
1306    AssertLockHeld(cs_desc_man);
1307
1308    std::unique_ptr<FlatSigningProvider> out_keys = std::make_unique<FlatSigningProvider>();
1309
1310    // Fetch SigningProvider from cache to avoid re-deriving
1311    auto it = m_map_signing_providers.find(index);
1312    if (it != m_map_signing_providers.end()) {
1313        out_keys->Merge(FlatSigningProvider{it->second});
1314    } else {
1315        // Get the scripts, keys, and key origins for this script
1316        std::vector<CScript> scripts_temp;
1317        if (!m_wallet_descriptor.descriptor->ExpandFromCache(index, m_wallet_descriptor.cache, scripts_temp, *out_keys)) return nullptr;
1318
1319        // Cache SigningProvider so we don't need to re-derive if we need this SigningProvider again
1320        m_map_signing_providers[index] = *out_keys;
1321    }
1322
1323    if (HavePrivateKeys() && include_private) {
1324        FlatSigningProvider master_provider;
1325        master_provider.keys = GetKeys();
1326        m_wallet_descriptor.descriptor->ExpandPrivate(index, master_provider, *out_keys);
1327
1328        // Always include musig_secnonces as this descriptor may have a participant private key
1329        // but not a musig() descriptor
1330        out_keys->musig2_secnonces = &m_musig2_secnonces;
1331    }
1332
1333    return out_keys;
1334}
1335
1336std::unique_ptr<SigningProvider> DescriptorScriptPubKeyMan::GetSolvingProvider(const CScript& script) const
1337{
1338    return GetSigningProvider(script, false);
1339}
1340
1341bool DescriptorScriptPubKeyMan::CanProvide(const CScript& script, SignatureData& sigdata)
1342{
1343    return IsMine(script);
1344}
1345
1346bool DescriptorScriptPubKeyMan::SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const
1347{
1348    std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
1349    for (const auto& coin_pair : coins) {
1350        std::unique_ptr<FlatSigningProvider> coin_keys = GetSigningProvider(coin_pair.second.out.scriptPubKey, true);
1351        if (!coin_keys) {
1352            continue;
1353        }
1354        keys->Merge(std::move(*coin_keys));
1355    }
1356
1357    return ::SignTransaction(tx, keys.get(), coins, {.sighash_type = sighash}, input_errors);
1358}
1359
1360SigningResult DescriptorScriptPubKeyMan::SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const
1361{
1362    std::unique_ptr<FlatSigningProvider> keys = GetSigningProvider(GetScriptForDestination(pkhash), true);
1363    if (!keys) {
1364        return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
1365    }
1366
1367    CKey key;
1368    if (!keys->GetKey(ToKeyID(pkhash), key)) {
1369        return SigningResult::PRIVATE_KEY_NOT_AVAILABLE;
1370    }
1371
1372    if (!MessageSign(key, message, str_sig)) {
1373        return SigningResult::SIGNING_FAILED;
1374    }
1375    return SigningResult::OK;
1376}
1377
1378std::optional<PSBTError> DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, const common::PSBTFillOptions& options, int* n_signed) const
1379{
1380    if (n_signed) {
1381        *n_signed = 0;
1382    }
1383    for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
1384        PSBTInput& input = psbtx.inputs.at(i);
1385
1386        if (PSBTInputSigned(input)) {
1387            continue;
1388        }
1389
1390        // Get the scriptPubKey to know which SigningProvider to use
1391        CScript script;
1392        if (!input.witness_utxo.IsNull()) {
1393            script = input.witness_utxo.scriptPubKey;
1394        } else if (input.non_witness_utxo) {
1395            if (input.prev_out >= input.non_witness_utxo->vout.size()) {
1396                return PSBTError::MISSING_INPUTS;
1397            }
1398            script = input.non_witness_utxo->vout[input.prev_out].scriptPubKey;
1399        } else {
1400            // There's no UTXO so we can just skip this now
1401            continue;
1402        }
1403
1404        std::unique_ptr<FlatSigningProvider> keys = std::make_unique<FlatSigningProvider>();
1405        std::unique_ptr<FlatSigningProvider> script_keys = GetSigningProvider(script, /*include_private=*/options.sign);
1406        if (script_keys) {
1407            keys->Merge(std::move(*script_keys));
1408        } else {
1409            // Maybe there are pubkeys listed that we can sign for
1410            std::vector<CPubKey> pubkeys;
1411            pubkeys.reserve(input.hd_keypaths.size() + 2);
1412
1413            // ECDSA Pubkeys
1414            for (const auto& [pk, _] : input.hd_keypaths) {
1415                pubkeys.push_back(pk);
1416            }
1417
1418            // Taproot output pubkey
1419            std::vector<std::vector<unsigned char>> sols;
1420            if (Solver(script, sols) == TxoutType::WITNESS_V1_TAPROOT) {
1421                sols[0].insert(sols[0].begin(), 0x02);
1422                pubkeys.emplace_back(sols[0]);
1423                sols[0][0] = 0x03;
1424                pubkeys.emplace_back(sols[0]);
1425            }
1426
1427            // Taproot pubkeys
1428            for (const auto& pk_pair : input.m_tap_bip32_paths) {
1429                const XOnlyPubKey& pubkey = pk_pair.first;
1430                for (unsigned char prefix : {0x02, 0x03}) {
1431                    unsigned char b[33] = {prefix};
1432                    std::copy(pubkey.begin(), pubkey.end(), b + 1);
1433                    CPubKey fullpubkey;
1434                    fullpubkey.Set(b, b + 33);
1435                    pubkeys.push_back(fullpubkey);
1436                }
1437            }
1438
1439            for (const auto& pubkey : pubkeys) {
1440                std::unique_ptr<FlatSigningProvider> pk_keys = GetSigningProvider(pubkey);
1441                if (pk_keys) {
1442                    keys->Merge(std::move(*pk_keys));
1443                }
1444            }
1445        }
1446
1447        const auto sign_result = SignPSBTInput(HidingSigningProvider(keys.get(), /*hide_secret=*/!options.sign, /*hide_origin=*/!options.bip32_derivs), psbtx, i, &txdata, options, /*out_sigdata=*/nullptr);
1448        if (!sign_result.has_value() && sign_result.error() != PSBTError::INCOMPLETE) {
1449            return sign_result.error();
1450        }
1451
1452        bool signed_one = PSBTInputSigned(input);
1453        if (n_signed && (signed_one || !options.sign)) {
1454            // If sign is false, we assume that we _could_ sign if we get here. This
1455            // will never have false negatives; it is hard to tell under what i
1456            // circumstances it could have false positives.
1457            (*n_signed)++;
1458        }
1459    }
1460
1461    // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
1462    for (unsigned int i = 0; i < psbtx.outputs.size(); ++i) {
1463        std::unique_ptr<SigningProvider> keys = GetSolvingProvider(psbtx.outputs.at(i).script);
1464        if (!keys) {
1465            continue;
1466        }
1467        UpdatePSBTOutput(HidingSigningProvider(keys.get(), /*hide_secret=*/true, /*hide_origin=*/!options.bip32_derivs), psbtx, i);
1468    }
1469
1470    return {};
1471}
1472
1473std::unique_ptr<CKeyMetadata> DescriptorScriptPubKeyMan::GetMetadata(const CTxDestination& dest) const
1474{
1475    std::unique_ptr<SigningProvider> provider = GetSigningProvider(GetScriptForDestination(dest));
1476    if (provider) {
1477        KeyOriginInfo orig;
1478        CKeyID key_id = GetKeyForDestination(*provider, dest);
1479        if (provider->GetKeyOrigin(key_id, orig)) {
1480            LOCK(cs_desc_man);
1481            std::unique_ptr<CKeyMetadata> meta = std::make_unique<CKeyMetadata>();
1482            meta->key_origin = orig;
1483            meta->has_key_origin = true;
1484            meta->nCreateTime = m_wallet_descriptor.creation_time;
1485            return meta;
1486        }
1487    }
1488    return nullptr;
1489}
1490
1491uint256 DescriptorScriptPubKeyMan::GetID() const
1492{
1493    return m_id;
1494}
1495
1496void DescriptorScriptPubKeyMan::Load()
1497{
1498    LOCK(cs_desc_man);
1499    std::set<CScript> new_spks;
1500    for (int32_t i = m_wallet_descriptor.GetStart(); i < m_wallet_descriptor.GetEnd(); ++i) {