1001    while (true) {
1002        DatabaseCursor::Status status = cursor->Next(key, value);
1003        if (status == DatabaseCursor::Status::DONE) break;
1004        if (status == DatabaseCursor::Status::FAIL) {
1005            throw std::runtime_error(strprintf("Error reading '%s' record", DBKeys::WTX_VARIANT));
1006        }
1007        CTransactionRef tx;
1008        value >> TX_WITH_WITNESS(tx);
1009        if (tx->GetHash() != txid) {
1010            throw std::runtime_error(strprintf("Corrupted witness variant, tx hash differs"));
1011        }
1012        if (!variants.emplace(tx->GetWitnessHash(), std::move(tx)).second) {
1013            throw std::runtime_error(strprintf("Duplicate witness variant"));
1014        }
1015    }
1016    return variants;
1017}
1018
1019static DBErrors LoadTxRecords(CWallet* pwallet, DatabaseBatch& batch, bool& any_unordered) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1020{
1021    AssertLockHeld(pwallet->cs_wallet);
1022    DBErrors result = DBErrors::LOAD_OK;
1023
1024    // Load tx record
1025    any_unordered = false;
1026    LoadResult tx_res = LoadRecords(pwallet, batch, DBKeys::TX,
1027        [&any_unordered, &batch] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1028        DBErrors result = DBErrors::LOAD_OK;
1029        Txid hash;
1030        key >> hash;
1031        try {
1032            CWalletTx wtx{deserialize, value, ReadWtxVariants(batch, hash)};
1033            if (wtx.GetHash() != hash) {
1034                result = std::max(result, DBErrors::NEED_RESCAN);
1035            }
1036
1037            if (wtx.nOrderPos == -1) {
1038                any_unordered = true;
1039            }
1040
1041            if (!pwallet->LoadToWallet(std::move(wtx))) {
1042                err = "Error: Corrupt transaction found. This can be fixed by removing transactions from wallet and rescanning.";
1043                return DBErrors::CORRUPT;
1044            }
1045        } catch (const std::exception& e) {
1046            err = strprintf("Error: Corrupt tx record found: %s" ,e.what());
1047            return DBErrors::CORRUPT;
1048        }
1049        return result;
1050    });
1051    result = std::max(result, tx_res.m_result);
1052
1053    // Load locked utxo record
1054    LoadResult locked_utxo_res = LoadRecords(pwallet, batch, DBKeys::LOCKED_UTXO,
1055        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1056        Txid hash;
1057        uint32_t n;
1058        key >> hash;
1059        key >> n;
1060        pwallet->LoadLockedCoin(COutPoint(hash, n), /*persistent=*/true);
1061        return DBErrors::LOAD_OK;
1062    });
1063    result = std::max(result, locked_utxo_res.m_result);
1064
1065    // Load orderposnext record
1066    // Note: There should only be one ORDERPOSNEXT record with nothing trailing the type
1067    LoadResult order_pos_res = LoadRecords(pwallet, batch, DBKeys::ORDERPOSNEXT,
1068        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
1069        try {
1070            value >> pwallet->nOrderPosNext;
1071        } catch (const std::exception& e) {
1072            err = e.what();
1073            return DBErrors::NONCRITICAL_ERROR;
1074        }
1075        return DBErrors::LOAD_OK;
1076    });
1077    result = std::max(result, order_pos_res.m_result);
1078
1079    // After loading all tx records, abandon any coinbase that is no longer in the active chain.
1080    // This could happen during an external wallet load, or if the user replaced the chain data.
1081    for (auto& [id, wtx] : pwallet->mapWallet) {
1082        if (wtx.IsCoinBase() && wtx.isInactive()) {
1083            pwallet->AbandonTransaction(wtx);
1084        }
1085    }
1086
1087    return result;
1088}
1089
1090static DBErrors LoadActiveSPKMs(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1091{
1092    AssertLockHeld(pwallet->cs_wallet);
1093    DBErrors result = DBErrors::LOAD_OK;
1094
1095    // Load spk records
1096    std::set<std::pair<OutputType, bool>> seen_spks;
1097    for (const auto& spk_key : {DBKeys::ACTIVEEXTERNALSPK, DBKeys::ACTIVEINTERNALSPK}) {
1098        LoadResult spkm_res = LoadRecords(pwallet, batch, spk_key,
1099            [&seen_spks, &spk_key] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& strErr) {
1100            uint8_t output_type;
1101            key >> output_type;
1102            uint256 id;
1103            value >> id;
1104
1105            bool internal = spk_key == DBKeys::ACTIVEINTERNALSPK;
1106            auto [it, insert] = seen_spks.emplace(static_cast<OutputType>(output_type), internal);
1107            if (!insert) {
1108                strErr = "Multiple ScriptpubKeyMans specified for a single type";
1109                return DBErrors::CORRUPT;
1110            }
1111            pwallet->LoadActiveScriptPubKeyMan(id, static_cast<OutputType>(output_type), /*internal=*/internal);
1112            return DBErrors::LOAD_OK;
1113        });
1114        result = std::max(result, spkm_res.m_result);
1115    }
1116    return result;
1117}
1118
1119static DBErrors LoadDecryptionKeys(CWallet* pwallet, DatabaseBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
1120{
1121    AssertLockHeld(pwallet->cs_wallet);
1122
1123    // Load decryption key (mkey) records
1124    LoadResult mkey_res = LoadRecords(pwallet, batch, DBKeys::MASTER_KEY,
1125        [] (CWallet* pwallet, DataStream& key, DataStream& value, std::string& err) {
1126        if (!LoadEncryptionKey(pwallet, key, value, err)) {
1127            return DBErrors::CORRUPT;
1128        }
1129        return DBErrors::LOAD_OK;
1130    });
1131    return mkey_res.m_result;
1132}
1133
1134DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
1135{
1136    DBErrors result = DBErrors::LOAD_OK;
1137    bool any_unordered = false;
1138
1139    LOCK(pwallet->cs_wallet);
1140
1141    // Last client version to open this wallet
1142    int last_client = CLIENT_VERSION;
1143    bool has_last_client = m_batch->Read(DBKeys::VERSION, last_client);
1144    if (has_last_client) pwallet->WalletLogPrintf("Last client version = %d\n", last_client);
1145
1146    try {
1147        // Load wallet flags, so they are known when processing other records.
1148        // The FLAGS key is absent during wallet creation.
1149        if ((result = LoadWalletFlags(pwallet, *m_batch)) != DBErrors::LOAD_OK) return result;
1150
1151#ifndef ENABLE_EXTERNAL_SIGNER
1152        if (pwallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
1153            pwallet->WalletLogPrintf("Error: External signer wallet being loaded without external signer support compiled\n");
1154            return DBErrors::EXTERNAL_SIGNER_SUPPORT_REQUIRED;
1155        }
1156#endif
1157
1158        // Load legacy wallet keys
1159        result = std::max(LoadLegacyWalletRecords(pwallet, *m_batch, last_client), result);
1160
1161        // Load descriptors
1162        result = std::max(LoadDescriptorWalletRecords(pwallet, *m_batch, last_client), result);
1163        // Early return if there are unknown descriptors. Later loading of ACTIVEINTERNALSPK and ACTIVEEXTERNALEXPK
1164        // may reference the unknown descriptor's ID which can result in a misleading corruption error
1165        // when in reality the wallet is simply too new.
1166        if (result == DBErrors::UNKNOWN_DESCRIPTOR) return result;
1167
1168        // Load address book
1169        result = std::max(LoadAddressBookRecords(pwallet, *m_batch), result);
1170
1171        // Load SPKMs
1172        result = std::max(LoadActiveSPKMs(pwallet, *m_batch), result);
1173
1174        // Load decryption keys
1175        result = std::max(LoadDecryptionKeys(pwallet, *m_batch), result);
1176
1177        // Load tx records
1178        result = std::max(LoadTxRecords(pwallet, *m_batch, any_unordered), result);
1179    } catch (std::runtime_error& e) {
1180        // Exceptions that can be ignored or treated as non-critical are handled by the individual loading functions.
1181        // Any uncaught exceptions will be caught here and treated as critical.
1182        // Catch std::runtime_error specifically as many functions throw these and they at least have some message that
1183        // we can log
1184        pwallet->WalletLogPrintf("%s\n", e.what());
1185        result = DBErrors::CORRUPT;
1186    } catch (...) {
1187        // All other exceptions are still problematic, but we can't log them
1188        result = DBErrors::CORRUPT;
1189    }
1190
1191    // Any wallet corruption at all: skip any rewriting or
1192    // upgrading, we don't want to make it worse.
1193    if (result != DBErrors::LOAD_OK)
1194        return result;
1195
1196    if (!has_last_client || last_client != CLIENT_VERSION) // Update
1197        this->WriteVersion(CLIENT_VERSION);
1198
1199    if (any_unordered)
1200        result = pwallet->ReorderTransactions();
1201
1202    // Upgrade all of the descriptor caches to cache the last hardened xpub
1203    // This operation is not atomic, but if it fails, only new entries are added so it is backwards compatible
1204    try {
1205        pwallet->UpgradeDescriptorCache();
1206    } catch (...) {
1207        result = DBErrors::CORRUPT;
1208    }
1209
1210    // Since it was accidentally possible to "encrypt" a wallet with private keys disabled, we should check if this is
1211    // such a wallet and remove the encryption key records to avoid any future issues.
1212    // Although wallets without private keys should not have *ckey records, we should double check that.
1213    // Removing the mkey records is only safe if there are no *ckey records.
1214    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && pwallet->HasEncryptionKeys() && !pwallet->HaveCryptedKeys()) {
1215        pwallet->WalletLogPrintf("Detected extraneous encryption keys in this wallet without private keys. Removing extraneous encryption keys.\n");
1216        for (const auto& [id, _] : pwallet->mapMasterKeys) {
1217            if (!EraseMasterKey(id)) {
1218                pwallet->WalletLogPrintf("Error: Unable to remove extraneous encryption key '%u'. Wallet corrupt.\n", id);
1219                return DBErrors::CORRUPT;
1220            }
1221        }
1222        pwallet->mapMasterKeys.clear();
1223    }
1224
1225    return result;
1226}
1227
1228static bool RunWithinTxn(WalletBatch& batch, std::string_view process_desc, const std::function<bool(WalletBatch&)>& func)
1229{
1230    if (!batch.TxnBegin()) {
1231        LogDebug(BCLog::WALLETDB, "Error: cannot create db txn for %s\n", process_desc);
1232        return false;
1233    }
1234
1235    // Run procedure
1236    if (!func(batch)) {
1237        LogDebug(BCLog::WALLETDB, "Error: %s failed\n", process_desc);
1238        batch.TxnAbort();
1239        return false;
1240    }
1241
1242    if (!batch.TxnCommit()) {
1243        LogDebug(BCLog::WALLETDB, "Error: cannot commit db txn for %s\n", process_desc);
1244        return false;
1245    }
1246
1247    // All good
1248    return true;
1249}
1250