251        DataStream ssKey{};
252        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
253        // Key serialization is the only operation that may throw.
254        // Callers are expected to provide well-formed keys.
255        ssKey << key;
256
257        std::optional<std::string> strValue;
258        try {
259            strValue = ReadImpl(ssKey);
260            if (!strValue) {
261                return false; // not found
262            }
263        } catch (const std::exception& e) {
264            return util::Unexpected(ReadFailure{ReadFailure::Code::DatabaseError, e.what()});
265        }
266
267        try {
268            std::span ssValue{MakeWritableByteSpan(*strValue)};
269            m_obfuscation(ssValue);
270            SpanReader{ssValue} >> value;
271        } catch (const std::exception& e) {
272            return util::Unexpected(ReadFailure{ReadFailure::Code::DeserializationError, e.what()});
273        }
274
275        return true;
276    }
277
278    /**
279     * Wrapper around TryRead() that preserves the original Read() semantics:
280     * returns true on success, false if the key is absent or deserialization
281     * fails, and throws dbwrapper_error on an internal DB error.
282     *
283     * Prefer TryRead() when the caller needs to distinguish between a missing
284     * key and a corrupt value.
285     */
286    template <typename K, typename V>
287    bool Read(const K& key, V& value) const
288    {
289        const ReadStatus res = TryRead(key,value);
290        if (res.has_value()) return res.value();
291        switch (const auto& [err_code, err_msg] = res.error(); err_code) {
292            case ReadFailure::Code::DeserializationError: return false;
293            case ReadFailure::Code::DatabaseError: throw dbwrapper_error(err_msg);
294        } // no default case, so the compiler can warn about missing cases
295        std::abort(); // unreachable
296    }
297
298    template <typename K, typename V>
299    void Write(const K& key, const V& value, bool fSync = false)
300    {
301        CDBBatch batch(*this);
302        batch.Write(key, value);
303        WriteBatch(batch, fSync);
304    }
305
306    template <typename K>
307    bool Exists(const K& key) const
308    {
309        DataStream ssKey{};
310        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
311        ssKey << key;
312        return ExistsImpl(ssKey);
313    }
314
315    template <typename K>
316    void Erase(const K& key, bool fSync = false)
317    {
318        CDBBatch batch(*this);
319        batch.Erase(key);
320        WriteBatch(batch, fSync);
321    }
322
323    void WriteBatch(CDBBatch& batch, bool fSync = false);
324
325    //! Perform a blocking full compaction of the underlying LevelDB.
326    void CompactFull();
327
328    //! Return a LevelDB property value, if available.
329    std::optional<std::string> GetProperty(const std::string& property) const;
330
331    // Get an estimate of LevelDB memory usage (in bytes).
332    size_t DynamicMemoryUsage() const;
333
334    CDBIterator* NewIterator();
335
336    /**
337     * Return true if the database managed by this class contains no entries.
338     */
339    bool IsEmpty();
340
341    //! Probe an unopened database for a key prefix. Return true if a database at
342    //! path exists and contains at least 1 entry beginning with prefix; missing
343    //! or empty databases return false, and database errors throw dbwrapper_error.
344    static bool HasKeyStartingWith(const fs::path& path, uint8_t prefix);
345
346    template<typename K>
347    size_t EstimateSize(const K& key_begin, const K& key_end) const
348    {
349        DataStream ssKey1{}, ssKey2{};
350        ssKey1.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
351        ssKey2.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
352        ssKey1 << key_begin;
353        ssKey2 << key_end;
354        return EstimateSizeImpl(ssKey1, ssKey2);
355    }
356};
357
358#endif // BITCOIN_DBWRAPPER_H
359