Managing descriptor scripts, derivation caches and PSBT data

1501        FlatSigningProvider out_keys;
1502        std::vector<CScript> scripts_temp;
1503        if (!m_wallet_descriptor.descriptor->ExpandFromCache(i, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
1504            throw std::runtime_error("Error: Unable to expand wallet descriptor from cache");
1505        }
1506        // Add all of the scriptPubKeys to the scriptPubKey set
1507        new_spks.insert(scripts_temp.begin(), scripts_temp.end());
1508        for (const CScript& script : scripts_temp) {
1509            if (m_map_script_pub_keys.contains(script)) {
1510                throw std::runtime_error(strprintf("Error: Already loaded script at index %d as being at index %d", i, m_map_script_pub_keys[script]));
1511            }
1512            m_map_script_pub_keys[script] = i;
1513        }
1514        for (const auto& pk_pair : out_keys.pubkeys) {
1515            const CPubKey& pubkey = pk_pair.second;
1516            if (m_map_pubkeys.contains(pubkey)) {
1517                // We don't need to give an error here.
1518                // It doesn't matter which of many valid indexes the pubkey has, we just need an index where we can derive it and its private key
1519                continue;
1520            }
1521            m_map_pubkeys[pubkey] = i;
1522        }
1523        m_max_cached_index++;
1524    }
1525    // Make sure the wallet knows about our new spks
1526    m_storage.TopUpCallback(new_spks, this);
1527}
1528
1529bool DescriptorScriptPubKeyMan::HasWalletDescriptor(const WalletDescriptor& desc) const
1530{
1531    LOCK(cs_desc_man);
1532    return m_wallet_descriptor.IsCanonicallyEquivalent(desc);
1533}
1534
1535void DescriptorScriptPubKeyMan::WriteDescriptor()
1536{
1537    LOCK(cs_desc_man);
1538    WalletBatch batch(m_storage.GetDatabase());
1539    if (!batch.WriteDescriptor(GetID(), m_wallet_descriptor)) {
1540        throw std::runtime_error(std::string(__func__) + ": writing descriptor failed");
1541    }
1542}
1543
1544WalletDescriptor DescriptorScriptPubKeyMan::GetWalletDescriptor() const
1545{
1546    return m_wallet_descriptor;
1547}
1548
1549std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys() const
1550{
1551    return GetScriptPubKeys(0);
1552}
1553
1554std::unordered_set<CScript, SaltedSipHasher> DescriptorScriptPubKeyMan::GetScriptPubKeys(int32_t minimum_index) const
1555{
1556    LOCK(cs_desc_man);
1557    std::unordered_set<CScript, SaltedSipHasher> script_pub_keys;
1558    script_pub_keys.reserve(m_map_script_pub_keys.size());
1559
1560    for (auto const& [script_pub_key, index] : m_map_script_pub_keys) {
1561        if (index >= minimum_index) script_pub_keys.insert(script_pub_key);
1562    }
1563    return script_pub_keys;
1564}
1565
1566int32_t DescriptorScriptPubKeyMan::GetEndRange() const
1567{
1568    return m_max_cached_index + 1;
1569}
1570
1571bool DescriptorScriptPubKeyMan::GetDescriptorString(std::string& out, const bool priv) const
1572{
1573    LOCK(cs_desc_man);
1574
1575    FlatSigningProvider provider;
1576    provider.keys = GetKeys();
1577
1578    if (priv) {
1579        // For the private version, always return the master key to avoid
1580        // exposing child private keys. The risk implications of exposing child
1581        // private keys together with the parent xpub may be non-obvious for users.
1582        return m_wallet_descriptor.descriptor->ToPrivateString(provider, out);
1583    }
1584
1585    return m_wallet_descriptor.descriptor->ToNormalizedString(provider, out, &m_wallet_descriptor.cache);
1586}
1587
1588void DescriptorScriptPubKeyMan::UpgradeDescriptorCache()
1589{
1590    LOCK(cs_desc_man);
1591    if (m_storage.IsLocked() || m_storage.IsWalletFlagSet(WALLET_FLAG_LAST_HARDENED_XPUB_CACHED)) {
1592        return;
1593    }
1594
1595    // Skip if we have the last hardened xpub cache
1596    if (m_wallet_descriptor.cache.GetCachedLastHardenedExtPubKeys().size() > 0) {
1597        return;
1598    }
1599
1600    // Expand the descriptor
1601    FlatSigningProvider provider;
1602    provider.keys = GetKeys();
1603    FlatSigningProvider out_keys;
1604    std::vector<CScript> scripts_temp;
1605    DescriptorCache temp_cache;
1606    if (!m_wallet_descriptor.descriptor->Expand(0, provider, scripts_temp, out_keys, &temp_cache)){
1607        throw std::runtime_error("Unable to expand descriptor");
1608    }
1609
1610    // Cache the last hardened xpubs
1611    DescriptorCache diff = m_wallet_descriptor.cache.MergeAndDiff(temp_cache);
1612    if (!WalletBatch(m_storage.GetDatabase()).WriteDescriptorCacheItems(GetID(), diff)) {
1613        throw std::runtime_error(std::string(__func__) + ": writing cache items failed");
1614    }
1615}
1616
1617util::Result<void> DescriptorScriptPubKeyMan::UpdateWalletDescriptor(WalletDescriptor& descriptor, const FlatSigningProvider& provider)
1618{
1619    LOCK(cs_desc_man);
1620    std::string error;
1621    if (!CanUpdateToWalletDescriptor(descriptor, error)) {
1622        return util::Error{Untranslated(std::move(error))};
1623    }
1624
1625    m_map_pubkeys.clear();
1626    m_map_script_pub_keys.clear();
1627    m_max_cached_index = -1;
1628    m_wallet_descriptor.UpdateFrom(descriptor);
1629
1630    WalletBatch batch(m_storage.GetDatabase());
1631    UpdateWithSigningProvider(batch, provider);
1632    NotifyFirstKeyTimeChanged(this, m_wallet_descriptor.creation_time);
1633    return {};
1634}
1635
1636void DescriptorScriptPubKeyMan::UpdateWithSigningProvider(WalletBatch& batch, const FlatSigningProvider& signing_provider)
1637{
1638    AssertLockHeld(cs_desc_man);
1639    // Add the private keys to the descriptor
1640    for (const auto& entry : signing_provider.keys) {
1641        const CKey& key = entry.second;
1642        if (!AddDescriptorKeyWithDB(batch, key, key.GetPubKey())) {
1643            throw std::runtime_error(std::string(__func__) + ": writing descriptor private key failed");
1644        }
1645    }
1646
1647    // Top up key pool, to generate scriptPubKeys
1648    if (!TopUpWithDB(batch)) {
1649        throw std::runtime_error("Could not top up scriptPubKeys");
1650    }
1651}
1652
1653bool DescriptorScriptPubKeyMan::CanUpdateToWalletDescriptor(const WalletDescriptor& descriptor, std::string& error)
1654{
1655    LOCK(cs_desc_man);
1656    if (!HasWalletDescriptor(descriptor)) {
1657        error = "can only update matching descriptor";
1658        return false;
1659    }
1660
1661    if (!descriptor.descriptor->IsRange()) {
1662        // Skip range check for non-range descriptors
1663        return true;
1664    }
1665
1666    if (descriptor.GetStart() > m_wallet_descriptor.GetStart() ||
1667        descriptor.GetEnd() < m_wallet_descriptor.GetEnd()) {
1668        // Use inclusive range for error
1669        error = strprintf("new range must include current range = [%d,%d]",
1670                          m_wallet_descriptor.GetStart(),
1671                          m_wallet_descriptor.GetEnd() - 1);
1672        return false;
1673    }
1674
1675    return true;
1676}
1677} // namespace wallet
1678