Suppress "parse failed" message in Batch tests

refactor: Remove unnecessary version number and options in cmake find_package (#6169 )
This change removes unnecessary version numbers in the OpenSSL and Boost `find_package` CMake statements. An unnecessary OpenSSL definition is removed, while Conan options for SSL are updated to disable insecure ciphers. Moreover, the statements are now ordered alphabetically and more logically.
2026-01-13 03:05:28 +00:00 · 2026-01-12 20:03:22 -05:00 · 2026-01-12 19:14:39 -05:00
8 changed files with 124 additions and 642 deletions
--- a/BUILD.md
+++ b/BUILD.md
@@ -148,7 +148,8 @@ function extract_version {
 }

 # Define which recipes to export.
-recipes=(ed25519 grpc secp256k1 snappy soci)
+recipes=('ed25519' 'grpc' 'openssl' 'secp256k1' 'snappy' 'soci')
+folders=('all'     'all'  '3.x.x'   'all'       'all'    'all')

 # Selectively check out the recipes from our CCI fork.
 cd external
@@ -157,20 +158,24 @@ cd conan-center-index
 git init
 git remote add origin git@github.com:XRPLF/conan-center-index.git
 git sparse-checkout init
-for recipe in ${recipes[@]}; do
-  echo "Checking out ${recipe}..."
-  git sparse-checkout add recipes/${recipe}/all
+for ((index = 1; index <= ${#recipes[@]}; index++)); do
+  recipe=${recipes[index]}
+  folder=${folders[index]}
+  echo "Checking out recipe '${recipe}' from folder '${folder}'..."
+  git sparse-checkout add recipes/${recipe}/${folder}
 done
 git fetch origin master
 git checkout master
 cd ../..

 # Export the recipes into the local cache.
-for recipe in ${recipes[@]}; do
+for ((index = 1; index <= ${#recipes[@]}; index++)); do
+  recipe=${recipes[index]}
+  folder=${folders[index]}
  version=$(extract_version ${recipe})
-  echo "Exporting ${recipe}/${version}..."
+  echo "Exporting '${recipe}/${version}' from '${recipe}/${folder}'..."
  conan export --version $(extract_version ${recipe}) \
-    external/conan-center-index/recipes/${recipe}/all
+    external/conan-center-index/recipes/${recipe}/${folder}
 done
 ```

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,34 +88,18 @@ endif()
 ###

 include(deps/Boost)
-find_package(OpenSSL 1.1.1 REQUIRED)
-set_target_properties(OpenSSL::SSL PROPERTIES
-  INTERFACE_COMPILE_DEFINITIONS OPENSSL_NO_SSL2
-)

 add_subdirectory(external/antithesis-sdk)
-find_package(gRPC REQUIRED)
-find_package(lz4 REQUIRED)
-# Target names with :: are not allowed in a generator expression.
-# We need to pull the include directories and imported location properties
-# from separate targets.
-find_package(LibArchive REQUIRED)
-find_package(SOCI REQUIRED)
-find_package(SQLite3 REQUIRED)
-
-option(rocksdb "Enable RocksDB" ON)
-if(rocksdb)
-  find_package(RocksDB REQUIRED)
-  set_target_properties(RocksDB::rocksdb PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
-  )
-  target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif()
-
 find_package(date REQUIRED)
 find_package(ed25519 REQUIRED)
+find_package(gRPC REQUIRED)
+find_package(LibArchive REQUIRED)
+find_package(lz4 REQUIRED)
 find_package(nudb REQUIRED)
+find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
+find_package(SOCI REQUIRED)
+find_package(SQLite3 REQUIRED)
 find_package(xxHash REQUIRED)

 target_link_libraries(xrpl_libs INTERFACE
@@ -128,6 +112,15 @@ target_link_libraries(xrpl_libs INTERFACE
  SQLite::SQLite3
 )

+option(rocksdb "Enable RocksDB" ON)
+if(rocksdb)
+    find_package(RocksDB REQUIRED)
+    set_target_properties(RocksDB::rocksdb PROPERTIES
+            INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
+    )
+    target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
+endif()
+
 # Work around changes to Conan recipe for now.
 if(TARGET nudb::core)
  set(nudb nudb::core)
--- a/cmake/deps/Boost.cmake
+++ b/cmake/deps/Boost.cmake
@@ -1,4 +1,4 @@
-find_package(Boost 1.82 REQUIRED
+find_package(Boost REQUIRED
  COMPONENTS
    chrono
    container
--- a/conan.lock
+++ b/conan.lock
@@ -1,44 +1,44 @@
 {
    "version": "0.5",
    "requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1756234289.683",
-        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1756234266.869",
-        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1756234262.318",
-        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246",
-        "secp256k1/0.7.0#9c4ab67bdc3860c16ea5b36aed8f74ea%1765202256.763",
-        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1762797952.535",
-        "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1764175362.029",
-        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1764863245.83",
-        "openssl/3.5.4#a1d5835cc6ed5c5b8f3cd5b9b5d24205%1760106486.594",
-        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1763150366.909",
-        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1756234228.999",
-        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1756223727.64",
-        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1756230911.03",
-        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1764175360.142",
+        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075",
+        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
+        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926",
+        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46",
+        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",
+        "secp256k1/0.7.0#9c4ab67bdc3860c16ea5b36aed8f74ea%1765850147.928",
+        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1765850186.86",
+        "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1765850148.103",
+        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1765850161.038",
+        "openssl/3.5.4#58f5173c2ee51d6fc0f0c61b4eddadbb%1768259092.666",
+        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1765850143.957",
+        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1765850143.914",
+        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1765842973.492",
+        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1765842973.03",
+        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1765850144.736",
        "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244",
-        "grpc/1.72.0#f244a57bff01e708c55a1100b12e1589%1763158050.628",
-        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1764270189.893",
-        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1762797941.757",
-        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1763584497.32",
-        "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1764175359.429",
-        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1764175359.429",
-        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1756223752.326",
-        "abseil/20250127.0#9e8e8cfc89a1324139fc0ee3bd4d8c8c%1753819045.301"
+        "grpc/1.72.0#f244a57bff01e708c55a1100b12e1589%1765850193.734",
+        "ed25519/2015.03#ae761bdc52730a843f0809bdf6c1b1f6%1765850143.772",
+        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1765850143.95",
+        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1765850143.772",
+        "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1765850144.336",
+        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1765850143.837",
+        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1765850172.862",
+        "abseil/20250127.0#99262a368bd01c0ccca8790dfced9719%1766517936.993"
    ],
    "build_requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "strawberryperl/5.32.1.1#707032463aa0620fa17ec0d887f5fe41%1756234281.733",
-        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1764863245.83",
-        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1756234232.901",
+        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075",
+        "strawberryperl/5.32.1.1#707032463aa0620fa17ec0d887f5fe41%1765850165.196",
+        "protobuf/6.32.1#f481fd276fc23a33b85a3ed1e898b693%1765850161.038",
+        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1765850144.707",
        "msys2/cci.latest#1996656c3c98e5765b25b60ff5cf77b4%1764840888.758",
        "m4/1.4.19#70dc8bbb33e981d119d2acc0175cf381%1763158052.846",
-        "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1764175359.44",
-        "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1764175359.429",
-        "b2/5.3.3#107c15377719889654eb9a162a673975%1756234226.28",
+        "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1765850153.937",
+        "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1765850153.479",
+        "b2/5.3.3#107c15377719889654eb9a162a673975%1765850144.355",
        "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
        "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86",
-        "abseil/20250127.0#9e8e8cfc89a1324139fc0ee3bd4d8c8c%1753819045.301"
+        "abseil/20250127.0#99262a368bd01c0ccca8790dfced9719%1766517936.993"
    ],
    "python_requires": [],
    "overrides": {
--- a/conanfile.py
+++ b/conanfile.py
@@ -87,7 +87,13 @@ class Xrpl(ConanFile):
        "libarchive/*:with_xattr": False,
        "libarchive/*:with_zlib": False,
        "lz4/*:shared": False,
+        "openssl/*:no_dtls": True,
+        "openssl/*:no_ssl": True,
+        "openssl/*:no_ssl3": True,
+        "openssl/*:no_tls1": True,
+        "openssl/*:no_tls1_1": True,
        "openssl/*:shared": False,
+        "openssl/*:tls_security_level": 2,
        "protobuf/*:shared": False,
        "protobuf/*:with_zlib": True,
        "rocksdb/*:enable_sse": False,
--- a/src/test/app/Batch_test.cpp
+++ b/src/test/app/Batch_test.cpp
@@ -427,6 +427,7 @@ class Batch_test : public beast::unit_test::suite
            auto const batchFee = batch::calcBatchFee(env, 0, 2);
            auto tx1 = batch::inner(pay(alice, bob, XRP(1)), seq + 1);
            tx1[jss::Fee] = "1.5";
+            env.set_parse_failure_expected(true);
            try
            {
                env(batch::outer(alice, seq, batchFee, tfAllOrNothing),
@@ -438,6 +439,7 @@ class Batch_test : public beast::unit_test::suite
            {
                BEAST_EXPECT(true);
            }
+            env.set_parse_failure_expected(false);
        }

        // temSEQ_AND_TICKET: Batch: inner txn cannot have both Sequence
--- a/src/test/rpc/LedgerEntry_test.cpp
+++ b/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>
@@ -32,7 +30,6 @@ enum class FieldType {
    CurrencyField,
    HashField,
    HashOrObjectField,
-    FixedHashField,
    IssueField,
    ObjectField,
    StringField,
@@ -89,7 +86,6 @@ getTypeName(FieldType typeID)
        case FieldType::CurrencyField:
            return "Currency";
        case FieldType::HashField:
-        case FieldType::FixedHashField:
            return "hex string";
        case FieldType::HashOrObjectField:
            return "hex string or object";
@@ -206,7 +202,6 @@ class LedgerEntry_test : public beast::unit_test::suite
        static auto const& badBlobValues = remove({3, 7, 8, 16});
        static auto const& badCurrencyValues = remove({14});
        static auto const& badHashValues = remove({2, 3, 7, 8, 16});
-        static auto const& badFixedHashValues = remove({1, 2, 3, 4, 7, 8, 16});
        static auto const& badIndexValues = remove({12, 16, 18, 19});
        static auto const& badUInt32Values = remove({2, 3});
        static auto const& badUInt64Values = remove({2, 3});
@@ -227,8 +222,6 @@ class LedgerEntry_test : public beast::unit_test::suite
                return badHashValues;
            case FieldType::HashOrObjectField:
                return badIndexValues;
-            case FieldType::FixedHashField:
-                return badFixedHashValues;
            case FieldType::IssueField:
                return badIssueValues;
            case FieldType::UInt32Field:
@@ -724,12 +717,7 @@ class LedgerEntry_test : public beast::unit_test::suite
        }

        // negative tests
-        testMalformedField(
-            env,
-            Json::Value{},
-            jss::amendments,
-            FieldType::FixedHashField,
-            "malformedRequest");
+        runLedgerEntryTest(env, jss::amendments);
    }

    void
@@ -1550,12 +1538,7 @@ class LedgerEntry_test : public beast::unit_test::suite
        }

        // negative tests
-        testMalformedField(
-            env,
-            Json::Value{},
-            jss::fee,
-            FieldType::FixedHashField,
-            "malformedRequest");
+        runLedgerEntryTest(env, jss::fee);
    }

    void
@@ -1578,12 +1561,7 @@ class LedgerEntry_test : public beast::unit_test::suite
        }

        // negative tests
-        testMalformedField(
-            env,
-            Json::Value{},
-            jss::hashes,
-            FieldType::FixedHashField,
-            "malformedRequest");
+        runLedgerEntryTest(env, jss::hashes);
    }

    void
@@ -1708,12 +1686,7 @@ class LedgerEntry_test : public beast::unit_test::suite
        }

        // negative tests
-        testMalformedField(
-            env,
-            Json::Value{},
-            jss::nunl,
-            FieldType::FixedHashField,
-            "malformedRequest");
+        runLedgerEntryTest(env, jss::nunl);
    }

    void
@@ -2370,370 +2343,6 @@ class LedgerEntry_test : public beast::unit_test::suite
        }
    }

-    /// Test the ledger entry types that don't take parameters
-    void
-    testFixed()
-    {
-        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 << 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
-    testHashes()
-    {
-        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 << "LedgerHashes: seq: "
-                     << env.current()->header().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
    testCLI()
    {
@@ -2791,8 +2400,6 @@ public:
        testOracleLedgerEntry();
        testMPT();
        testPermissionedDomain();
-        testFixed();
-        testHashes();
        testCLI();
    }
 };
--- a/src/xrpld/rpc/handlers/LedgerEntry.cpp
+++ b/src/xrpld/rpc/handlers/LedgerEntry.cpp
@@ -18,32 +18,6 @@

 namespace xrpl {

-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,
@@ -59,33 +33,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))
    {
@@ -96,13 +50,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())
    {
@@ -130,10 +85,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))
    {
@@ -164,19 +116,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())
    {
@@ -207,10 +153,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())
    {
@@ -301,10 +244,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())
    {
@@ -357,10 +297,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)
@@ -375,8 +312,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())
    {
@@ -429,10 +365,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())
    {
@@ -451,53 +384,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>
-parseLoanBroker(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseLoanBroker(Json::Value const& params, Json::StaticString const fieldName)
 {
    if (!params.isObject())
    {
@@ -517,10 +417,7 @@ parseLoanBroker(
 }

 static Expected<uint256, Json::Value>
-parseLoan(
-    Json::Value const& params,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+parseLoan(Json::Value const& params, Json::StaticString const fieldName)
 {
    if (!params.isObject())
    {
@@ -540,10 +437,7 @@ parseLoan(
 }

 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())
    {
@@ -566,8 +460,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)
@@ -578,30 +471,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())
    {
@@ -622,10 +510,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())
    {
@@ -646,10 +531,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");
 }
@@ -657,8 +539,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())
    {
@@ -687,8 +568,7 @@ parsePermissionedDomain(
 static Expected<uint256, Json::Value>
 parseRippleState(
    Json::Value const& jvRippleState,
-    Json::StaticString const fieldName,
-    unsigned apiVersion)
+    Json::StaticString const fieldName)
 {
    Currency uCurrency;

@@ -738,19 +618,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())
    {
@@ -771,10 +645,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())
    {
@@ -797,8 +668,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())
    {
@@ -823,8 +693,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())
    {
@@ -848,6 +717,10 @@ parseXChainOwnedCreateAccountClaimID(
    return keylet.key;
 }

+using FunctionType = Expected<uint256, Json::Value> (*)(
+    Json::Value const&,
+    Json::StaticString const);
+
 struct LedgerEntry
 {
    Json::StaticString fieldName;
@@ -880,7 +753,7 @@ doLedgerEntry(RPC::JsonContext& context)
        {jss::ripple_state, parseRippleState, ltRIPPLE_STATE},
    });

-    auto const hasMoreThanOneMember = [&]() {
+    auto hasMoreThanOneMember = [&]() {
        int count = 0;

        for (auto const& ledgerEntry : ledgerEntryParsers)
@@ -924,8 +797,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();

@@ -956,13 +829,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));
@@ -974,14 +843,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)
@@ -991,10 +858,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;