Merge branch 'develop' into vlntb/mem-leak-ledger-history-3

.github/scripts/levelization/results/ordering.txt

@@ -145,6 +145,7 @@ test.toplevel > xrpl.json
 test.unit_test > xrpl.basics
 tests.libxrpl > xrpl.basics
 tests.libxrpl > xrpl.json
+tests.libxrpl > xrpl.ledger
 tests.libxrpl > xrpl.net
 xrpl.json > xrpl.basics
 xrpl.ledger > xrpl.basics

conan.lock

@@ -6,18 +6,18 @@
         "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1756234266.869",
         "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1756234262.318",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246",
-        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1762797952.535",
+        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1759820024.194",
         "re2/20230301#dfd6e2bf050eb90ddd8729cfb4c844a4%1756234257.976",
         "protobuf/3.21.12#d927114e28de9f4691a6bbcdd9a529d1%1756234251.614",
         "openssl/3.5.4#a1d5835cc6ed5c5b8f3cd5b9b5d24205%1760106486.594",
-        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1763150366.909",
+        "nudb/2.0.9#c62cfd501e57055a7e0d8ee3d5e5427d%1756234237.107",
         "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1756234228.999",
         "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1756223727.64",
         "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1756230911.03",
         "libarchive/3.8.1#5cf685686322e906cb42706ab7e099a8%1756234256.696",
         "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244",
         "grpc/1.50.1#02291451d1e17200293a409410d1c4e1%1756234248.958",
-        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1762797941.757",
+        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1749889324.069",
         "date/3.0.4#f74bbba5a08fa388256688743136cb6f%1756234217.493",
         "c-ares/1.34.5#b78b91e7cfb1f11ce777a285bbf169c6%1756234217.915",
         "bzip2/1.0.8#00b4a4658791c1f06914e087f0e792f5%1756234261.716",
@@ -53,9 +53,6 @@
         ],
         "lz4/[>=1.9.4 <2]": [
             "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"
-        ],
-        "sqlite3/3.44.2": [
-            "sqlite3/3.49.1"
         ]
     },
     "config_requires": []

include/xrpl/basics/TaggedCache.h

@@ -151,9 +151,6 @@ public:
     bool
     retrieve(key_type const& key, T& data);
 
-    mutex_type&
-    peekMutex();
-
     std::vector<key_type>
     getKeys() const;
 

include/xrpl/basics/TaggedCache.ipp

@@ -649,29 +649,6 @@ TaggedCache<
     return true;
 }
 
-template <
-    class Key,
-    class T,
-    bool IsKeyCache,
-    class SharedWeakUnionPointer,
-    class SharedPointerType,
-    class Hash,
-    class KeyEqual,
-    class Mutex>
-inline auto
-TaggedCache<
-    Key,
-    T,
-    IsKeyCache,
-    SharedWeakUnionPointer,
-    SharedPointerType,
-    Hash,
-    KeyEqual,
-    Mutex>::peekMutex() -> mutex_type&
-{
-    return m_mutex;
-}
-
 template <
     class Key,
     class T,

include/xrpl/ledger/LedgerIndexMap.h

@@ -0,0 +1,119 @@
+#ifndef XRPL_APP_LEDGER_INDEX_MAP_H_INCLUDED
+#define XRPL_APP_LEDGER_INDEX_MAP_H_INCLUDED
+
+#include <algorithm>
+#include <mutex>
+#include <unordered_map>
+
+namespace ripple {
+
+template <class Key, class Mapped>
+class LedgerIndexMap
+{
+public:
+    LedgerIndexMap() = default;
+    explicit LedgerIndexMap(std::size_t reserve_capacity)
+    {
+        data_.reserve(reserve_capacity);
+    }
+
+    LedgerIndexMap(LedgerIndexMap const&) = delete;
+    LedgerIndexMap&
+    operator=(LedgerIndexMap const&) = delete;
+    LedgerIndexMap(LedgerIndexMap&&) = delete;
+    LedgerIndexMap&
+    operator=(LedgerIndexMap&&) = delete;
+
+    Mapped&
+    operator[](Key const& k)
+    {
+        std::lock_guard lock(mutex_);
+        return data_[k];
+    }
+
+    Mapped&
+    operator[](Key&& k)
+    {
+        std::lock_guard lock(mutex_);
+        return data_[std::move(k)];
+    }
+
+    [[nodiscard]] Mapped*
+    get(Key const& k)
+    {
+        std::lock_guard lock(mutex_);
+        auto it = data_.find(k);
+        return it == data_.end() ? nullptr : &it->second;
+    }
+
+    [[nodiscard]] Mapped const*
+    get(Key const& k) const
+    {
+        std::lock_guard lock(mutex_);
+        auto it = data_.find(k);
+        return it == data_.end() ? nullptr : &it->second;
+    }
+
+    template <class... Args>
+    Mapped&
+    put(Key const& k, Args&&... args)
+    {
+        std::lock_guard lock(mutex_);
+        auto [it, inserted] = data_.try_emplace(k, std::forward<Args>(args)...);
+        if (!inserted)
+            it->second = Mapped(std::forward<Args>(args)...);
+        return it->second;
+    }
+
+    bool
+    contains(Key const& k) const
+    {
+        std::lock_guard lock(mutex_);
+        return data_.find(k) != data_.end();
+    }
+
+    std::size_t
+    size() const noexcept
+    {
+        std::lock_guard lock(mutex_);
+        return data_.size();
+    }
+
+    bool
+    empty() const noexcept
+    {
+        std::lock_guard lock(mutex_);
+        return data_.empty();
+    }
+
+    void
+    reserve(std::size_t n)
+    {
+        std::lock_guard lock(mutex_);
+        data_.reserve(n);
+    }
+
+    void
+    rehash(std::size_t n)
+    {
+        std::lock_guard lock(mutex_);
+        data_.rehash(n);
+    }
+
+    std::size_t
+    eraseBefore(Key const& cutoff)
+    {
+        std::lock_guard lock(mutex_);
+        auto const before = data_.size();
+        std::erase_if(data_, [&](auto const& kv) { return kv.first < cutoff; });
+        return before - data_.size();
+    }
+
+private:
+    std::unordered_map<Key, Mapped> data_;
+    mutable std::mutex mutex_;
+};
+
+}  // namespace ripple
+
+#endif  // XRPL_APP_LEDGER_INDEX_MAP_H_INCLUDED

src/test/app/Vault_test.cpp

@@ -1329,7 +1329,7 @@ class Vault_test : public beast::unit_test::suite
                      Vault& vault) {
             auto [tx, keylet] = vault.create({.owner = owner, .asset = asset});
             testcase("insufficient fee");
-            env(tx, fee(env.current()->fees().base - 1), ter(telINSUF_FEE_P));
+            env(tx, fee(env.current()->fees().base), ter(telINSUF_FEE_P));
         });
 
         testCase([this](
@@ -2074,10 +2074,6 @@ class Vault_test : public beast::unit_test::suite
                     auto const sleMPT = env.le(mptoken);
                     BEAST_EXPECT(sleMPT == nullptr);
 
-                    // Use one reserve so the next transaction fails
-                    env(ticket::create(owner, 1));
-                    env.close();
-
                     // No reserve to create MPToken for asset in VaultWithdraw
                     tx = vault.withdraw(
                         {.depositor = owner,
@@ -2095,7 +2091,7 @@ class Vault_test : public beast::unit_test::suite
                 }
             },
             {.requireAuth = false,
-             .initialXRP = acctReserve + incReserve * 4 + 1});
+             .initialXRP = acctReserve + incReserve * 4 - 1});
 
         testCase([this](
                      Env& env,
@@ -2984,9 +2980,6 @@ class Vault_test : public beast::unit_test::suite
                     env.le(keylet::line(owner, asset.raw().get<Issue>()));
                 BEAST_EXPECT(trustline == nullptr);
 
-                env(ticket::create(owner, 1));
-                env.close();
-
                 // Fail because not enough reserve to create trust line
                 tx = vault.withdraw(
                     {.depositor = owner,
@@ -3002,7 +2995,7 @@ class Vault_test : public beast::unit_test::suite
                 env(tx);
                 env.close();
             },
-            CaseArgs{.initialXRP = acctReserve + incReserve * 4 + 1});
+            CaseArgs{.initialXRP = acctReserve + incReserve * 4 - 1});
 
         testCase(
             [&, this](
@@ -3023,7 +3016,8 @@ class Vault_test : public beast::unit_test::suite
                 env(pay(owner, charlie, asset(100)));
                 env.close();
 
-                env(ticket::create(charlie, 3));
+                // Use up some reserve on tickets
+                env(ticket::create(charlie, 2));
                 env.close();
 
                 // Fail because not enough reserve to create MPToken for shares
@@ -3041,7 +3035,7 @@ class Vault_test : public beast::unit_test::suite
                 env(tx);
                 env.close();
             },
-            CaseArgs{.initialXRP = acctReserve + incReserve * 4 + 1});
+            CaseArgs{.initialXRP = acctReserve + incReserve * 4 - 1});
 
         testCase([&, this](
                      Env& env,

src/test/jtx/impl/vault.cpp

@@ -19,6 +19,7 @@ Vault::create(CreateArgs const& args)
     jv[jss::TransactionType] = jss::VaultCreate;
     jv[jss::Account] = args.owner.human();
     jv[jss::Asset] = to_json(args.asset);
+    jv[jss::Fee] = STAmount(env.current()->fees().increment).getJson();
     if (args.flags)
         jv[jss::Flags] = *args.flags;
     return {jv, keylet};

src/test/rpc/LedgerEntry_test.cpp

@@ -5,8 +5,6 @@
 #include <test/jtx/multisign.h>
 #include <test/jtx/xchain_bridge.h>
 
-#include <xrpld/app/tx/apply.h>
-
 #include <xrpl/beast/unit_test.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/protocol/AccountID.h>
@@ -2010,370 +2008,6 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
     }
 
-    /// Test the ledger entry types that don't take parameters
-    void
-    testLedgerEntryFixed()
-    {
-        using namespace test::jtx;
-
-        Account const alice{"alice"};
-        Account const bob{"bob"};
-
-        Env env{*this, envconfig([](auto cfg) {
-                    cfg->START_UP = Config::FRESH;
-                    return cfg;
-                })};
-
-        env.close();
-
-        /** Verifies that the RPC result has the expected data
-         *
-         * @param good: Indicates that the request should have succeeded
-         *   and returned a ledger object of `expectedType` type.
-         * @param jv: The RPC result Json value
-         * @param expectedType: The type that the ledger object should
-         *   have if "good".
-         * @param expectedError: Optional. The expected error if not
-         *   good. Defaults to "entryNotFound".
-         */
-        auto checkResult =
-            [&](bool good,
-                Json::Value const& jv,
-                Json::StaticString const& expectedType,
-                std::optional<std::string> const& expectedError = {}) {
-                if (good)
-                {
-                    BEAST_EXPECTS(
-                        jv.isObject() && jv.isMember(jss::result) &&
-                            !jv[jss::result].isMember(jss::error) &&
-                            jv[jss::result].isMember(jss::node) &&
-                            jv[jss::result][jss::node].isMember(
-                                sfLedgerEntryType.jsonName) &&
-                            jv[jss::result][jss::node]
-                              [sfLedgerEntryType.jsonName] == expectedType,
-                        to_string(jv));
-                }
-                else
-                {
-                    BEAST_EXPECTS(
-                        jv.isObject() && jv.isMember(jss::result) &&
-                            jv[jss::result].isMember(jss::error) &&
-                            !jv[jss::result].isMember(jss::node) &&
-                            jv[jss::result][jss::error] ==
-                                expectedError.value_or("entryNotFound"),
-                        to_string(jv));
-                }
-            };
-
-        /** Runs a series of tests for a given fixed-position ledger
-         * entry.
-         *
-         * @param field: The Json request field to use.
-         * @param expectedType: The type that the ledger object should
-         *   have if "good".
-         * @param expectedKey: The keylet of the fixed object.
-         * @param good: Indicates whether the object is expected to
-         *   exist.
-         */
-        auto test = [&](Json::StaticString const& field,
-                        Json::StaticString const& expectedType,
-                        Keylet const& expectedKey,
-                        bool good) {
-            testcase << "ledger_entry " << expectedType.c_str()
-                     << (good ? "" : " not") << " found";
-
-            auto const hexKey = strHex(expectedKey.key);
-
-            // Test bad values
-            // "field":null
-            Json::Value params;
-            params[jss::ledger_index] = jss::validated;
-            params[field] = Json::nullValue;
-            auto jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, expectedType, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "field":"string"
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[field] = "arbitrary string";
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, expectedType, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "field":false
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[field] = false;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, expectedType, "invalidParams");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            {
-                // "field":[incorrect index hash]
-                auto const badKey = strHex(expectedKey.key + uint256{1});
-                params.clear();
-                params[jss::ledger_index] = jss::validated;
-                params[field] = badKey;
-                jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, expectedType, "entryNotFound");
-                BEAST_EXPECTS(
-                    jv[jss::result][jss::index] == badKey, to_string(jv));
-            }
-
-            // "index":"field" using API 2
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::index] = field;
-            params[jss::api_version] = 2;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, expectedType, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // Test good values
-            // Use the "field":true notation
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[field] = true;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            // Index will always be returned for valid parameters.
-            std::string const pdIdx = jv[jss::result][jss::index].asString();
-            BEAST_EXPECTS(hexKey == pdIdx, to_string(jv));
-            checkResult(good, jv, expectedType);
-
-            // "field":"[index hash]"
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[field] = hexKey;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(good, jv, expectedType);
-            BEAST_EXPECT(jv[jss::result][jss::index].asString() == hexKey);
-
-            // Use the "index":"field" notation with API 3
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::index] = field;
-            params[jss::api_version] = 3;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            // Index is correct either way
-            BEAST_EXPECT(jv[jss::result][jss::index].asString() == hexKey);
-            checkResult(good, jv, expectedType);
-
-            // Use the "index":"[index hash]" notation
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::index] = pdIdx;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            // Index is correct either way
-            BEAST_EXPECT(jv[jss::result][jss::index].asString() == hexKey);
-            checkResult(good, jv, expectedType);
-        };
-
-        test(jss::amendments, jss::Amendments, keylet::amendments(), true);
-        test(jss::fee, jss::FeeSettings, keylet::fees(), true);
-        // There won't be an nunl
-        test(jss::nunl, jss::NegativeUNL, keylet::negativeUNL(), false);
-        // Can only get the short skip list this way
-        test(jss::hashes, jss::LedgerHashes, keylet::skip(), true);
-    }
-
-    void
-    testLedgerEntryHashes()
-    {
-        using namespace test::jtx;
-
-        Account const alice{"alice"};
-        Account const bob{"bob"};
-
-        Env env{*this, envconfig([](auto cfg) {
-                    cfg->START_UP = Config::FRESH;
-                    return cfg;
-                })};
-
-        env.close();
-
-        /** Verifies that the RPC result has the expected data
-         *
-         * @param good: Indicates that the request should have succeeded
-         *   and returned a ledger object of `expectedType` type.
-         * @param jv: The RPC result Json value
-         * @param expectedCount: The number of Hashes expected in the
-         *   object if "good".
-         * @param expectedError: Optional. The expected error if not
-         *   good. Defaults to "entryNotFound".
-         */
-        auto checkResult =
-            [&](bool good,
-                Json::Value const& jv,
-                int expectedCount,
-                std::optional<std::string> const& expectedError = {}) {
-                if (good)
-                {
-                    BEAST_EXPECTS(
-                        jv.isObject() && jv.isMember(jss::result) &&
-                            !jv[jss::result].isMember(jss::error) &&
-                            jv[jss::result].isMember(jss::node) &&
-                            jv[jss::result][jss::node].isMember(
-                                sfLedgerEntryType.jsonName) &&
-                            jv[jss::result][jss::node]
-                              [sfLedgerEntryType.jsonName] == jss::LedgerHashes,
-                        to_string(jv));
-                    BEAST_EXPECTS(
-                        jv[jss::result].isMember(jss::node) &&
-                            jv[jss::result][jss::node].isMember("Hashes") &&
-                            jv[jss::result][jss::node]["Hashes"].size() ==
-                                expectedCount,
-                        to_string(jv[jss::result][jss::node]["Hashes"].size()));
-                }
-                else
-                {
-                    BEAST_EXPECTS(
-                        jv.isObject() && jv.isMember(jss::result) &&
-                            jv[jss::result].isMember(jss::error) &&
-                            !jv[jss::result].isMember(jss::node) &&
-                            jv[jss::result][jss::error] ==
-                                expectedError.value_or("entryNotFound"),
-                        to_string(jv));
-                }
-            };
-
-        /** Runs a series of tests for a given ledger index.
-         *
-         * @param ledger: The ledger index value of the "hashes" request
-         *   parameter. May not necessarily be a number.
-         * @param expectedKey: The expected keylet of the object.
-         * @param good: Indicates whether the object is expected to
-         *   exist.
-         * @param expectedCount: The number of Hashes expected in the
-         *   object if "good".
-         */
-        auto test = [&](Json::Value ledger,
-                        Keylet const& expectedKey,
-                        bool good,
-                        int expectedCount = 0) {
-            testcase << "ledger_entry LedgerHashes: seq: "
-                     << env.current()->info().seq
-                     << " \"hashes\":" << to_string(ledger)
-                     << (good ? "" : " not") << " found";
-
-            auto const hexKey = strHex(expectedKey.key);
-
-            // Test bad values
-            // "hashes":null
-            Json::Value params;
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = Json::nullValue;
-            auto jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, 0, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "hashes":"non-uint string"
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = "arbitrary string";
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, 0, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "hashes":"uint string" is invalid, too
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = "10";
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, 0, "malformedRequest");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "hashes":false
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = false;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, 0, "invalidParams");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "hashes":-1
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = -1;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(false, jv, 0, "internal");
-            BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
-
-            // "hashes":[incorrect index hash]
-            {
-                auto const badKey = strHex(expectedKey.key + uint256{1});
-                params.clear();
-                params[jss::ledger_index] = jss::validated;
-                params[jss::hashes] = badKey;
-                jv = env.rpc("json", "ledger_entry", to_string(params));
-                checkResult(false, jv, 0, "entryNotFound");
-                BEAST_EXPECT(jv[jss::result][jss::index] == badKey);
-            }
-
-            // Test good values
-            // Use the "hashes":ledger notation
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = ledger;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(good, jv, expectedCount);
-            // Index will always be returned for valid parameters.
-            std::string const pdIdx = jv[jss::result][jss::index].asString();
-            BEAST_EXPECTS(hexKey == pdIdx, strHex(pdIdx));
-
-            // "hashes":"[index hash]"
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::hashes] = hexKey;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(good, jv, expectedCount);
-            // Index is correct either way
-            BEAST_EXPECTS(
-                hexKey == jv[jss::result][jss::index].asString(),
-                strHex(jv[jss::result][jss::index].asString()));
-
-            // Use the "index":"[index hash]" notation
-            params.clear();
-            params[jss::ledger_index] = jss::validated;
-            params[jss::index] = hexKey;
-            jv = env.rpc("json", "ledger_entry", to_string(params));
-            checkResult(good, jv, expectedCount);
-            // Index is correct either way
-            BEAST_EXPECTS(
-                hexKey == jv[jss::result][jss::index].asString(),
-                strHex(jv[jss::result][jss::index].asString()));
-        };
-
-        // short skip list
-        test(true, keylet::skip(), true, 2);
-        // long skip list at index 0
-        test(1, keylet::skip(1), false);
-        // long skip list at index 1
-        test(1 << 17, keylet::skip(1 << 17), false);
-
-        // Close more ledgers, but stop short of the flag ledger
-        for (auto i = env.current()->seq(); i <= 250; ++i)
-            env.close();
-
-        // short skip list
-        test(true, keylet::skip(), true, 249);
-        // long skip list at index 0
-        test(1, keylet::skip(1), false);
-        // long skip list at index 1
-        test(1 << 17, keylet::skip(1 << 17), false);
-
-        // Close a flag ledger so the first "long" skip list is created
-        for (auto i = env.current()->seq(); i <= 260; ++i)
-            env.close();
-
-        // short skip list
-        test(true, keylet::skip(), true, 256);
-        // long skip list at index 0
-        test(1, keylet::skip(1), true, 1);
-        // long skip list at index 1
-        test(1 << 17, keylet::skip(1 << 17), false);
-    }
-
     void
     testLedgerEntryCLI()
     {
@@ -2423,8 +2057,6 @@ public:
         testOracleLedgerEntry();
         testLedgerEntryMPT();
         testLedgerEntryPermissionedDomain();
-        testLedgerEntryFixed();
-        testLedgerEntryHashes();
         testLedgerEntryCLI();
     }
 };

src/tests/libxrpl/CMakeLists.txt

@@ -29,3 +29,7 @@ if(NOT WIN32)
   target_link_libraries(xrpl.test.net PRIVATE xrpl.imports.test)
   add_dependencies(xrpl.tests xrpl.test.net)
 endif()
+
+xrpl_add_test(ledger)
+target_link_libraries(xrpl.test.ledger PRIVATE xrpl.imports.test)
+add_dependencies(xrpl.tests xrpl.test.ledger)

src/tests/libxrpl/ledger/LedgerIndexMap.cpp

@@ -0,0 +1,191 @@
+#include <xrpl/ledger/LedgerIndexMap.h>
+
+#include <doctest/doctest.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+using namespace ripple;
+
+TEST_SUITE_BEGIN("LedgerIndexMap");
+
+using TestMap = LedgerIndexMap<int, std::string>;
+
+TEST_CASE("Default empty")
+{
+    TestMap m;
+    CHECK(m.size() == 0);
+    CHECK(m.empty());
+    CHECK(m.get(42) == nullptr);
+    CHECK_FALSE(m.contains(42));
+}
+
+TEST_CASE("Operator bracket inserts default")
+{
+    TestMap m;
+    auto& v = m[10];
+    CHECK(m.size() == 1);
+    CHECK(m.contains(10));
+    CHECK(v.empty());
+}
+
+TEST_CASE("Operator bracket, rvalue key")
+{
+    TestMap m;
+    int k = 7;
+    auto& v1 = m[std::move(k)];
+    v1 = "seven";
+    CHECK(m.size() == 1);
+    auto* got = m.get(7);
+    REQUIRE(got != nullptr);
+    CHECK(*got == "seven");
+}
+
+TEST_CASE("Insert through put")
+{
+    TestMap m;
+    auto& v = m.put(20, "twenty");
+    CHECK(v == "twenty");
+    auto* got = m.get(20);
+    REQUIRE(got != nullptr);
+    CHECK(*got == "twenty");
+    CHECK(m.size() == 1);
+}
+
+TEST_CASE("Overwrite existing key with put")
+{
+    TestMap m;
+    m.put(5, "five");
+    CHECK(m.size() == 1);
+    m.put(5, "FIVE");
+    CHECK(m.size() == 1);
+    auto* got = m.get(5);
+    REQUIRE(got != nullptr);
+    CHECK(*got == "FIVE");
+}
+
+TEST_CASE("Once found, one not found")
+{
+    TestMap m;
+    m.put(1, "one");
+    CHECK(m.get(1) != nullptr);
+    CHECK(m.get(2) == nullptr);
+}
+
+TEST_CASE("Try eraseBefore - nothing to do")
+{
+    TestMap m;
+    m.put(10, "a");
+    m.put(11, "b");
+    m.put(12, "c");
+    CHECK(m.eraseBefore(10) == 0);
+    CHECK(m.size() == 3);
+    CHECK(m.contains(10));
+    CHECK(m.contains(11));
+    CHECK(m.contains(12));
+}
+
+TEST_CASE("eraseBefore - removes several entries")
+{
+    TestMap m;
+    m.put(10, "a");
+    m.put(11, "b");
+    m.put(12, "c");
+    m.put(13, "d");
+    CHECK(m.eraseBefore(12) == 2);
+    CHECK_FALSE(m.contains(10));
+    CHECK_FALSE(m.contains(11));
+    CHECK(m.contains(12));
+    CHECK(m.contains(13));
+    CHECK(m.size() == 2);
+}
+
+TEST_CASE("eraseBefore - removes all entries")
+{
+    TestMap m;
+    m.put(1, "x");
+    m.put(2, "y");
+    CHECK(m.eraseBefore(1000) == 2);
+    CHECK(m.size() == 0);
+    CHECK(m.empty());
+}
+
+TEST_CASE("eraseBefore - same call, second time nothing to do")
+{
+    TestMap m;
+    m.put(10, "a");
+    m.put(11, "b");
+    m.put(12, "c");
+    CHECK(m.eraseBefore(12) == 2);
+    CHECK(m.contains(12));
+    CHECK(m.eraseBefore(12) == 0);
+    CHECK(m.size() == 1);
+}
+
+TEST_CASE("eraseBefore - single entry removed")
+{
+    TestMap m;
+    m.put(10, "v1");
+    m.put(10, "v2");
+    m.put(10, "v3");
+    CHECK(m.size() == 1);
+    CHECK(m.eraseBefore(11) == 1);
+    CHECK(m.size() == 0);
+}
+
+TEST_CASE("eraseBefore - outlier still removed in one call")
+{
+    TestMap m;
+    m.put(10, "a");
+    m.put(12, "c");
+    m.put(11, "b");  // out-of-order insert
+
+    CHECK(m.eraseBefore(12) == 2);  // removes 10 and 11
+    CHECK_FALSE(m.contains(10));
+    CHECK_FALSE(m.contains(11));
+    CHECK(m.contains(12));
+    CHECK(m.size() == 1);
+}
+
+TEST_CASE("eraseBefore - erase in two steps (one first, then some more)")
+{
+    TestMap m;
+    for (int k : {10, 11, 12, 13})
+        m.put(k, std::to_string(k));
+
+    CHECK(m.eraseBefore(11) == 1);
+    CHECK_FALSE(m.contains(10));
+    CHECK(m.size() == 3);
+
+    CHECK(m.eraseBefore(13) == 2);
+    CHECK_FALSE(m.contains(11));
+    CHECK_FALSE(m.contains(12));
+    CHECK(m.contains(13));
+    CHECK(m.size() == 1);
+}
+
+TEST_CASE("rehash does not lose entries")
+{
+    TestMap m;
+    for (int k = 0; k < 16; ++k)
+        m.put(k, "v" + std::to_string(k));
+
+    m.reserve(64);
+    m.rehash(32);
+
+    for (int k = 0; k < 16; ++k)
+    {
+        auto* v = m.get(k);
+        REQUIRE(v != nullptr);
+        CHECK(*v == "v" + std::to_string(k));
+    }
+
+    CHECK(m.eraseBefore(8) == 8);
+    for (int k = 0; k < 8; ++k)
+        CHECK_FALSE(m.contains(k));
+    for (int k = 8; k < 16; ++k)
+        CHECK(m.contains(k));
+}
+
+TEST_SUITE_END();

src/tests/libxrpl/ledger/main.cpp

@@ -0,0 +1,2 @@
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include <doctest/doctest.h>

src/xrpld/app/ledger/LedgerHistory.cpp

@@ -8,8 +8,6 @@
 
 namespace ripple {
 
-// FIXME: Need to clean up ledgers by index at some point
-
 LedgerHistory::LedgerHistory(
     beast::insight::Collector::ptr const& collector,
     Application& app)
@@ -28,6 +26,7 @@ LedgerHistory::LedgerHistory(
           std::chrono::minutes{5},
           stopwatch(),
           app_.journal("TaggedCache"))
+    , mLedgersByIndex(512)
     , j_(app.journal("LedgerHistory"))
 {
 }
@@ -44,8 +43,6 @@ LedgerHistory::insert(
         ledger->stateMap().getHash().isNonZero(),
         "ripple::LedgerHistory::insert : nonzero hash");
 
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
-
     bool const alreadyHad = m_ledgers_by_hash.canonicalize_replace_cache(
         ledger->info().hash, ledger);
     if (validated)
@@ -57,25 +54,18 @@ LedgerHistory::insert(
 LedgerHash
 LedgerHistory::getLedgerHash(LedgerIndex index)
 {
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
-    if (auto it = mLedgersByIndex.find(index); it != mLedgersByIndex.end())
-        return it->second;
+    if (auto p = mLedgersByIndex.get(index))
+        return *p;
     return {};
 }
 
 std::shared_ptr<Ledger const>
 LedgerHistory::getLedgerBySeq(LedgerIndex index)
 {
+    if (auto p = mLedgersByIndex.get(index))
     {
-        std::unique_lock sl(m_ledgers_by_hash.peekMutex());
-        auto it = mLedgersByIndex.find(index);
-
-        if (it != mLedgersByIndex.end())
-        {
-            uint256 hash = it->second;
-            sl.unlock();
-            return getLedgerByHash(hash);
-        }
+        uint256 const hash = *p;
+        return getLedgerByHash(hash);
     }
 
     std::shared_ptr<Ledger const> ret = loadByIndex(index, app_);
@@ -89,8 +79,6 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index)
 
     {
         // Add this ledger to the local tracking by index
-        std::unique_lock sl(m_ledgers_by_hash.peekMutex());
-
         XRPL_ASSERT(
             ret->isImmutable(),
             "ripple::LedgerHistory::getLedgerBySeq : immutable result ledger");
@@ -439,8 +427,6 @@ LedgerHistory::builtLedger(
     XRPL_ASSERT(
         !hash.isZero(), "ripple::LedgerHistory::builtLedger : nonzero hash");
 
-    std::unique_lock sl(m_consensus_validated.peekMutex());
-
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
 
@@ -481,8 +467,6 @@ LedgerHistory::validatedLedger(
         !hash.isZero(),
         "ripple::LedgerHistory::validatedLedger : nonzero hash");
 
-    std::unique_lock sl(m_consensus_validated.peekMutex());
-
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
 
@@ -516,13 +500,13 @@ LedgerHistory::validatedLedger(
 bool
 LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 {
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
-    auto it = mLedgersByIndex.find(ledgerIndex);
-
-    if ((it != mLedgersByIndex.end()) && (it->second != ledgerHash))
+    if (auto cur = mLedgersByIndex.get(ledgerIndex))
     {
-        it->second = ledgerHash;
-        return false;
+        if (*cur != ledgerHash)
+        {
+            mLedgersByIndex.put(ledgerIndex, ledgerHash);
+            return false;
+        }
     }
     return true;
 }
@@ -530,12 +514,24 @@ LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 void
 LedgerHistory::clearLedgerCachePrior(LedgerIndex seq)
 {
+    std::size_t hashesCleared = 0;
     for (LedgerHash it : m_ledgers_by_hash.getKeys())
     {
         auto const ledger = getLedgerByHash(it);
         if (!ledger || ledger->info().seq < seq)
+        {
             m_ledgers_by_hash.del(it, false);
+            ++hashesCleared;
+        }
     }
+    JLOG(j_.debug()) << "LedgersByHash: cleared " << hashesCleared
+                     << " entries before seq " << seq << " (total now "
+                     << m_ledgers_by_hash.size() << ")";
+
+    std::size_t const indexesCleared = mLedgersByIndex.eraseBefore(seq);
+    JLOG(j_.debug()) << "LedgerIndexMap: cleared " << indexesCleared
+                     << " index entries before seq " << seq << " (total now "
+                     << mLedgersByIndex.size() << ")";
 }
 
 }  // namespace ripple

src/xrpld/app/ledger/LedgerHistory.h

@@ -5,6 +5,7 @@
 #include <xrpld/app/main/Application.h>
 
 #include <xrpl/beast/insight/Collector.h>
+#include <xrpl/ledger/LedgerIndexMap.h>
 #include <xrpl/protocol/RippleLedgerHash.h>
 
 #include <optional>
@@ -130,7 +131,8 @@ private:
     ConsensusValidated m_consensus_validated;
 
     // Maps ledger indexes to the corresponding hash.
-    std::map<LedgerIndex, LedgerHash> mLedgersByIndex;  // validated ledgers
+    ripple::LedgerIndexMap<LedgerIndex, LedgerHash>
+        mLedgersByIndex;  // validated ledgers
 
     beast::Journal j_;
 };

src/xrpld/app/tx/detail/VaultCreate.cpp

@@ -79,6 +79,13 @@ VaultCreate::preflight(PreflightContext const& ctx)
     return tesSUCCESS;
 }
 
+XRPAmount
+VaultCreate::calculateBaseFee(ReadView const& view, STTx const& tx)
+{
+    // One reserve increment is typically much greater than one base fee.
+    return calculateOwnerReserveFee(view, tx);
+}
+
 TER
 VaultCreate::preclaim(PreclaimContext const& ctx)
 {
@@ -135,9 +142,8 @@ VaultCreate::doApply()
 
     if (auto ter = dirLink(view(), account_, vault))
         return ter;
-    // We will create Vault and PseudoAccount, hence increase OwnerCount by 2
-    adjustOwnerCount(view(), owner, 2, j_);
-    auto const ownerCount = owner->at(sfOwnerCount);
+    adjustOwnerCount(view(), owner, 1, j_);
+    auto ownerCount = owner->at(sfOwnerCount);
     if (mPriorBalance < view().fees().accountReserve(ownerCount))
         return tecINSUFFICIENT_RESERVE;
 

src/xrpld/app/tx/detail/VaultCreate.h

@@ -23,6 +23,9 @@ public:
     static NotTEC
     preflight(PreflightContext const& ctx);
 
+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
     static TER
     preclaim(PreclaimContext const& ctx);
 

src/xrpld/app/tx/detail/VaultDelete.cpp

@@ -146,35 +146,7 @@ VaultDelete::doApply()
         return tecHAS_OBLIGATIONS;  // LCOV_EXCL_LINE
 
     // Destroy the pseudo-account.
-    auto vaultPseudoSLE = view().peek(keylet::account(pseudoID));
-    if (!vaultPseudoSLE || vaultPseudoSLE->at(~sfVaultID) != vault->key())
-        return tefBAD_LEDGER;  // LCOV_EXCL_LINE
-
-    // Making the payment and removing the empty holding should have deleted any
-    // obligations associated with the vault or vault pseudo-account.
-    if (*vaultPseudoSLE->at(sfBalance))
-    {
-        // LCOV_EXCL_START
-        JLOG(j_.error()) << "VaultDelete: pseudo-account has a balance";
-        return tecHAS_OBLIGATIONS;
-        // LCOV_EXCL_STOP
-    }
-    if (vaultPseudoSLE->at(sfOwnerCount) != 0)
-    {
-        // LCOV_EXCL_START
-        JLOG(j_.error()) << "VaultDelete: pseudo-account still owns objects";
-        return tecHAS_OBLIGATIONS;
-        // LCOV_EXCL_STOP
-    }
-    if (view().exists(keylet::ownerDir(pseudoID)))
-    {
-        // LCOV_EXCL_START
-        JLOG(j_.error()) << "VaultDelete: pseudo-account has a directory";
-        return tecHAS_OBLIGATIONS;
-        // LCOV_EXCL_STOP
-    }
-
-    view().erase(vaultPseudoSLE);
+    view().erase(view().peek(keylet::account(pseudoID)));
 
     // Remove the vault from its owner's directory.
     auto const ownerID = vault->at(sfOwner);
@@ -198,9 +170,7 @@ VaultDelete::doApply()
         return tefBAD_LEDGER;
         // LCOV_EXCL_STOP
     }
-
-    // We are destroying Vault and PseudoAccount, hence decrease by 2
-    adjustOwnerCount(view(), owner, -2, j_);
+    adjustOwnerCount(view(), owner, -1, j_);
 
     // Destroy the vault.
     view().erase(vault);

src/xrpld/rpc/handlers/LedgerEntry.cpp

@@ -20,32 +20,6 @@
 
 namespace ripple {
 
-using FunctionType = std::function<Expected<uint256, Json::Value>(
-    Json::Value const&,
-    Json::StaticString const,
-    unsigned apiVersion)>;
-
-static Expected<uint256, Json::Value>
-parseFixed(
-    Keylet const& keylet,
-    Json::Value const& params,
-    Json::StaticString const& fieldName,
-    unsigned apiVersion);
-
-// Helper function to return FunctionType for objects that have a fixed
-// location. That is, they don't take parameters to compute the index.
-// e.g. amendments, fees, negative UNL, etc.
-static FunctionType
-fixed(Keylet const& keylet)
-{
-    return [&keylet](
-               Json::Value const& params,
-               Json::StaticString const fieldName,
-               unsigned apiVersion) -> Expected<uint256, Json::Value> {
-        return parseFixed(keylet, params, fieldName, apiVersion);
-    };
-}
-
 static Expected<uint256, Json::Value>
 parseObjectID(
     Json::Value const& params,
@@ -61,33 +35,13 @@ parseObjectID(
 }
 
 static Expected<uint256, Json::Value>
-parseIndex(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseIndex(Json::Value const& params, Json::StaticString const fieldName)
 {
-    if (apiVersion > 2u && params.isString())
-    {
-        std::string const index = params.asString();
-        if (index == jss::amendments.c_str())
-            return keylet::amendments().key;
-        if (index == jss::fee.c_str())
-            return keylet::fees().key;
-        if (index == jss::nunl)
-            return keylet::negativeUNL().key;
-        if (index == jss::hashes)
-            // Note this only finds the "short" skip list. Use "hashes":index to
-            // get the long list.
-            return keylet::skip().key;
-    }
     return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseAccountRoot(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseAccountRoot(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (auto const account = LedgerEntryHelpers::parse<AccountID>(params))
     {
@@ -98,13 +52,14 @@ parseAccountRoot(
         "malformedAddress", fieldName, "AccountID");
 }
 
-auto const parseAmendments = fixed(keylet::amendments());
+static Expected<uint256, Json::Value>
+parseAmendments(Json::Value const& params, Json::StaticString const fieldName)
+{
+    return parseObjectID(params, fieldName, "hex string");
+}
 
 static Expected<uint256, Json::Value>
-parseAMM(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseAMM(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -131,10 +86,7 @@ parseAMM(
 }
 
 static Expected<uint256, Json::Value>
-parseBridge(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseBridge(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isMember(jss::bridge))
     {
@@ -165,19 +117,13 @@ parseBridge(
 }
 
 static Expected<uint256, Json::Value>
-parseCheck(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseCheck(Json::Value const& params, Json::StaticString const fieldName)
 {
     return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseCredential(
-    Json::Value const& cred,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseCredential(Json::Value const& cred, Json::StaticString const fieldName)
 {
     if (!cred.isObject())
     {
@@ -208,10 +154,7 @@ parseCredential(
 }
 
 static Expected<uint256, Json::Value>
-parseDelegate(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseDelegate(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -279,10 +222,7 @@ parseAuthorizeCredentials(Json::Value const& jv)
 }
 
 static Expected<uint256, Json::Value>
-parseDepositPreauth(
-    Json::Value const& dp,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseDepositPreauth(Json::Value const& dp, Json::StaticString const fieldName)
 {
     if (!dp.isObject())
     {
@@ -342,10 +282,7 @@ parseDepositPreauth(
 }
 
 static Expected<uint256, Json::Value>
-parseDID(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseDID(Json::Value const& params, Json::StaticString const fieldName)
 {
     auto const account = LedgerEntryHelpers::parse<AccountID>(params);
     if (!account)
@@ -360,8 +297,7 @@ parseDID(
 static Expected<uint256, Json::Value>
 parseDirectoryNode(
     Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -414,10 +350,7 @@ parseDirectoryNode(
 }
 
 static Expected<uint256, Json::Value>
-parseEscrow(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseEscrow(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -436,53 +369,20 @@ parseEscrow(
     return keylet::escrow(*id, *seq).key;
 }
 
-auto const parseFeeSettings = fixed(keylet::fees());
-
 static Expected<uint256, Json::Value>
-parseFixed(
-    Keylet const& keylet,
-    Json::Value const& params,
-    Json::StaticString const& fieldName,
-    unsigned apiVersion)
+parseFeeSettings(Json::Value const& params, Json::StaticString const fieldName)
 {
-    if (!params.isBool())
-    {
-        return parseObjectID(params, fieldName, "hex string");
-    }
-    if (!params.asBool())
-    {
-        return LedgerEntryHelpers::invalidFieldError(
-            "invalidParams", fieldName, "true");
-    }
-
-    return keylet.key;
+    return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseLedgerHashes(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseLedgerHashes(Json::Value const& params, Json::StaticString const fieldName)
 {
-    if (params.isUInt() || params.isInt())
-    {
-        // If the index doesn't parse as a UInt, throw
-        auto const index = params.asUInt();
-
-        // Return the "long" skip list for the given ledger index.
-        auto const keylet = keylet::skip(index);
-        return keylet.key;
-    }
-    // Return the key in `params` or the "short" skip list, which contains
-    // hashes since the last flag ledger.
-    return parseFixed(keylet::skip(), params, fieldName, apiVersion);
+    return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseMPToken(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseMPToken(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -505,8 +405,7 @@ parseMPToken(
 static Expected<uint256, Json::Value>
 parseMPTokenIssuance(
     Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     auto const mptIssuanceID = LedgerEntryHelpers::parse<uint192>(params);
     if (!mptIssuanceID)
@@ -517,30 +416,25 @@ parseMPTokenIssuance(
 }
 
 static Expected<uint256, Json::Value>
-parseNFTokenOffer(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseNFTokenOffer(Json::Value const& params, Json::StaticString const fieldName)
 {
     return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseNFTokenPage(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseNFTokenPage(Json::Value const& params, Json::StaticString const fieldName)
 {
     return parseObjectID(params, fieldName, "hex string");
 }
 
-auto const parseNegativeUNL = fixed(keylet::negativeUNL());
+static Expected<uint256, Json::Value>
+parseNegativeUNL(Json::Value const& params, Json::StaticString const fieldName)
+{
+    return parseObjectID(params, fieldName, "hex string");
+}
 
 static Expected<uint256, Json::Value>
-parseOffer(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseOffer(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -561,10 +455,7 @@ parseOffer(
 }
 
 static Expected<uint256, Json::Value>
-parseOracle(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseOracle(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -585,10 +476,7 @@ parseOracle(
 }
 
 static Expected<uint256, Json::Value>
-parsePayChannel(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parsePayChannel(Json::Value const& params, Json::StaticString const fieldName)
 {
     return parseObjectID(params, fieldName, "hex string");
 }
@@ -596,8 +484,7 @@ parsePayChannel(
 static Expected<uint256, Json::Value>
 parsePermissionedDomain(
     Json::Value const& pd,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     if (pd.isString())
     {
@@ -626,8 +513,7 @@ parsePermissionedDomain(
 static Expected<uint256, Json::Value>
 parseRippleState(
     Json::Value const& jvRippleState,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     Currency uCurrency;
 
@@ -677,19 +563,13 @@ parseRippleState(
 }
 
 static Expected<uint256, Json::Value>
-parseSignerList(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseSignerList(Json::Value const& params, Json::StaticString const fieldName)
 {
     return parseObjectID(params, fieldName, "hex string");
 }
 
 static Expected<uint256, Json::Value>
-parseTicket(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseTicket(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -710,10 +590,7 @@ parseTicket(
 }
 
 static Expected<uint256, Json::Value>
-parseVault(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseVault(Json::Value const& params, Json::StaticString const fieldName)
 {
     if (!params.isObject())
     {
@@ -736,8 +613,7 @@ parseVault(
 static Expected<uint256, Json::Value>
 parseXChainOwnedClaimID(
     Json::Value const& claim_id,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     if (!claim_id.isObject())
     {
@@ -762,8 +638,7 @@ parseXChainOwnedClaimID(
 static Expected<uint256, Json::Value>
 parseXChainOwnedCreateAccountClaimID(
     Json::Value const& claim_id,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
     if (!claim_id.isObject())
     {
@@ -787,6 +662,10 @@ parseXChainOwnedCreateAccountClaimID(
     return keylet.key;
 }
 
+using FunctionType = Expected<uint256, Json::Value> (*)(
+    Json::Value const&,
+    Json::StaticString const);
+
 struct LedgerEntry
 {
     Json::StaticString fieldName;
@@ -819,7 +698,7 @@ doLedgerEntry(RPC::JsonContext& context)
         {jss::ripple_state, parseRippleState, ltRIPPLE_STATE},
     });
 
-    auto const hasMoreThanOneMember = [&]() {
+    auto hasMoreThanOneMember = [&]() {
         int count = 0;
 
         for (auto const& ledgerEntry : ledgerEntryParsers)
@@ -863,8 +742,8 @@ doLedgerEntry(RPC::JsonContext& context)
                 Json::Value const& params = ledgerEntry.fieldName == jss::bridge
                     ? context.params
                     : context.params[ledgerEntry.fieldName];
-                auto const result = ledgerEntry.parseFunction(
-                    params, ledgerEntry.fieldName, context.apiVersion);
+                auto const result =
+                    ledgerEntry.parseFunction(params, ledgerEntry.fieldName);
                 if (!result)
                     return result.error();
 
@@ -895,13 +774,9 @@ doLedgerEntry(RPC::JsonContext& context)
             throw;
     }
 
-    // Return the computed index regardless of whether the node exists.
-    jvResult[jss::index] = to_string(uNodeIndex);
-
     if (uNodeIndex.isZero())
     {
-        RPC::inject_error(rpcENTRY_NOT_FOUND, jvResult);
-        return jvResult;
+        return RPC::make_error(rpcENTRY_NOT_FOUND);
     }
 
     auto const sleNode = lpLedger->read(keylet::unchecked(uNodeIndex));
@@ -913,14 +788,12 @@ doLedgerEntry(RPC::JsonContext& context)
     if (!sleNode)
     {
         // Not found.
-        RPC::inject_error(rpcENTRY_NOT_FOUND, jvResult);
-        return jvResult;
+        return RPC::make_error(rpcENTRY_NOT_FOUND);
     }
 
     if ((expectedType != ltANY) && (expectedType != sleNode->getType()))
     {
-        RPC::inject_error(rpcUNEXPECTED_LEDGER_TYPE, jvResult);
-        return jvResult;
+        return RPC::make_error(rpcUNEXPECTED_LEDGER_TYPE);
     }
 
     if (bNodeBinary)
@@ -930,10 +803,12 @@ doLedgerEntry(RPC::JsonContext& context)
         sleNode->add(s);
 
         jvResult[jss::node_binary] = strHex(s.peekData());
+        jvResult[jss::index] = to_string(uNodeIndex);
     }
     else
     {
         jvResult[jss::node] = sleNode->getJson(JsonOptions::none);
+        jvResult[jss::index] = to_string(uNodeIndex);
     }
 
     return jvResult;