Merge branch 'ripple/wasmi' into wasmi-host-functions

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

src/test/app/Vault_test.cpp

@@ -2076,7 +2076,7 @@ class Vault_test : public beast::unit_test::suite
                 PrettyAsset const& asset,
                 Vault& vault,
                 MPTTester& mptt) {
-                testcase("MPT failed reserve to re-create MPToken");
+                testcase("MPT fail reserve to re-create MPToken");
 
                 auto [tx, keylet] =
                     vault.create({.owner = owner, .asset = asset});

src/test/overlay/TMGetObjectByHash_test.cpp

@@ -0,0 +1,211 @@
+#include <test/jtx.h>
+#include <test/jtx/Env.h>
+
+#include <xrpld/overlay/Message.h>
+#include <xrpld/overlay/detail/OverlayImpl.h>
+#include <xrpld/overlay/detail/PeerImp.h>
+#include <xrpld/overlay/detail/Tuning.h>
+#include <xrpld/peerfinder/detail/SlotImp.h>
+
+#include <xrpl/basics/make_SSLContext.h>
+#include <xrpl/beast/unit_test.h>
+#include <xrpl/nodestore/NodeObject.h>
+#include <xrpl/protocol/digest.h>
+#include <xrpl/protocol/messages.h>
+
+namespace xrpl {
+namespace test {
+
+using namespace jtx;
+
+/**
+ * Test for TMGetObjectByHash reply size limiting.
+ *
+ * This verifies the fix that limits TMGetObjectByHash replies to
+ * Tuning::hardMaxReplyNodes to prevent excessive memory usage and
+ * potential DoS attacks from peers requesting large numbers of objects.
+ */
+class TMGetObjectByHash_test : public beast::unit_test::suite
+{
+    using middle_type = boost::beast::tcp_stream;
+    using stream_type = boost::beast::ssl_stream<middle_type>;
+    using socket_type = boost::asio::ip::tcp::socket;
+    using shared_context = std::shared_ptr<boost::asio::ssl::context>;
+    /**
+     * Test peer that captures sent messages for verification.
+     */
+    class PeerTest : public PeerImp
+    {
+    public:
+        PeerTest(
+            Application& app,
+            std::shared_ptr<PeerFinder::Slot> const& slot,
+            http_request_type&& request,
+            PublicKey const& publicKey,
+            ProtocolVersion protocol,
+            Resource::Consumer consumer,
+            std::unique_ptr<TMGetObjectByHash_test::stream_type>&& stream_ptr,
+            OverlayImpl& overlay)
+            : PeerImp(
+                  app,
+                  id_++,
+                  slot,
+                  std::move(request),
+                  publicKey,
+                  protocol,
+                  consumer,
+                  std::move(stream_ptr),
+                  overlay)
+        {
+        }
+
+        ~PeerTest() = default;
+
+        void
+        run() override
+        {
+        }
+
+        void
+        send(std::shared_ptr<Message> const& m) override
+        {
+            lastSentMessage_ = m;
+        }
+
+        std::shared_ptr<Message>
+        getLastSentMessage() const
+        {
+            return lastSentMessage_;
+        }
+
+        static void
+        resetId()
+        {
+            id_ = 0;
+        }
+
+    private:
+        inline static Peer::id_t id_ = 0;
+        std::shared_ptr<Message> lastSentMessage_;
+    };
+
+    shared_context context_{make_SSLContext("")};
+    ProtocolVersion protocolVersion_{1, 7};
+
+    std::shared_ptr<PeerTest>
+    createPeer(jtx::Env& env)
+    {
+        auto& overlay = dynamic_cast<OverlayImpl&>(env.app().overlay());
+        boost::beast::http::request<boost::beast::http::dynamic_body> request;
+        auto stream_ptr = std::make_unique<stream_type>(
+            socket_type(env.app().getIOContext()), *context_);
+
+        beast::IP::Endpoint local(
+            boost::asio::ip::make_address("172.1.1.1"), 51235);
+        beast::IP::Endpoint remote(
+            boost::asio::ip::make_address("172.1.1.2"), 51235);
+
+        PublicKey key(std::get<0>(randomKeyPair(KeyType::ed25519)));
+        auto consumer = overlay.resourceManager().newInboundEndpoint(remote);
+        auto [slot, _] = overlay.peerFinder().new_inbound_slot(local, remote);
+
+        auto peer = std::make_shared<PeerTest>(
+            env.app(),
+            slot,
+            std::move(request),
+            key,
+            protocolVersion_,
+            consumer,
+            std::move(stream_ptr),
+            overlay);
+
+        overlay.add_active(peer);
+        return peer;
+    }
+
+    std::shared_ptr<protocol::TMGetObjectByHash>
+    createRequest(size_t const numObjects, Env& env)
+    {
+        // Store objects in the NodeStore that will be found during the query
+        auto& nodeStore = env.app().getNodeStore();
+
+        // Create and store objects
+        std::vector<uint256> hashes;
+        hashes.reserve(numObjects);
+        for (int i = 0; i < numObjects; ++i)
+        {
+            uint256 hash(xrpl::sha512Half(i));
+            hashes.push_back(hash);
+
+            Blob data(100, static_cast<unsigned char>(i % 256));
+            nodeStore.store(
+                hotLEDGER,
+                std::move(data),
+                hash,
+                nodeStore.earliestLedgerSeq());
+        }
+
+        // Create a request with more objects than hardMaxReplyNodes
+        auto request = std::make_shared<protocol::TMGetObjectByHash>();
+        request->set_type(protocol::TMGetObjectByHash_ObjectType_otLEDGER);
+        request->set_query(true);
+
+        for (int i = 0; i < numObjects; ++i)
+        {
+            auto object = request->add_objects();
+            object->set_hash(hashes[i].data(), hashes[i].size());
+            object->set_ledgerseq(i);
+        }
+        return request;
+    }
+
+    /**
+     * Test that reply is limited to hardMaxReplyNodes when more objects
+     * are requested than the limit allows.
+     */
+    void
+    testReplyLimit(size_t const numObjects, int const expectedReplySize)
+    {
+        testcase("Reply Limit");
+
+        Env env(*this);
+        PeerTest::resetId();
+
+        auto peer = createPeer(env);
+
+        auto request = createRequest(numObjects, env);
+        // Call the onMessage handler
+        peer->onMessage(request);
+
+        // Verify that a reply was sent
+        auto sentMessage = peer->getLastSentMessage();
+        BEAST_EXPECT(sentMessage != nullptr);
+
+        // Parse the reply message
+        auto const& buffer =
+            sentMessage->getBuffer(compression::Compressed::Off);
+
+        BEAST_EXPECT(buffer.size() > 6);
+        // Skip the message header (6 bytes: 4 for size, 2 for type)
+        protocol::TMGetObjectByHash reply;
+        BEAST_EXPECT(
+            reply.ParseFromArray(buffer.data() + 6, buffer.size() - 6) == true);
+
+        // Verify the reply is limited to expectedReplySize
+        BEAST_EXPECT(reply.objects_size() == expectedReplySize);
+    }
+
+    void
+    run() override
+    {
+        int const limit = static_cast<int>(Tuning::hardMaxReplyNodes);
+        testReplyLimit(limit + 1, limit);
+        testReplyLimit(limit, limit);
+        testReplyLimit(limit - 1, limit - 1);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(TMGetObjectByHash, overlay, xrpl);
+
+}  // namespace test
+}  // namespace xrpl

src/test/rpc/LedgerEntry_test.cpp

@@ -5,6 +5,8 @@
 #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>
@@ -30,6 +32,7 @@ enum class FieldType {
     CurrencyField,
     HashField,
     HashOrObjectField,
+    FixedHashField,
     IssueField,
     ObjectField,
     StringField,
@@ -86,6 +89,7 @@ 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";
@@ -202,6 +206,7 @@ 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});
@@ -222,6 +227,8 @@ 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:
@@ -717,7 +724,12 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
 
         // negative tests
-        runLedgerEntryTest(env, jss::amendments);
+        testMalformedField(
+            env,
+            Json::Value{},
+            jss::amendments,
+            FieldType::FixedHashField,
+            "malformedRequest");
     }
 
     void
@@ -1538,7 +1550,12 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
 
         // negative tests
-        runLedgerEntryTest(env, jss::fee);
+        testMalformedField(
+            env,
+            Json::Value{},
+            jss::fee,
+            FieldType::FixedHashField,
+            "malformedRequest");
     }
 
     void
@@ -1561,7 +1578,12 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
 
         // negative tests
-        runLedgerEntryTest(env, jss::hashes);
+        testMalformedField(
+            env,
+            Json::Value{},
+            jss::hashes,
+            FieldType::FixedHashField,
+            "malformedRequest");
     }
 
     void
@@ -1686,7 +1708,12 @@ class LedgerEntry_test : public beast::unit_test::suite
         }
 
         // negative tests
-        runLedgerEntryTest(env, jss::nunl);
+        testMalformedField(
+            env,
+            Json::Value{},
+            jss::nunl,
+            FieldType::FixedHashField,
+            "malformedRequest");
     }
 
     void
@@ -2343,6 +2370,438 @@ 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 const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, expectedType, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // "field":"string"
+                params[jss::ledger_index] = jss::validated;
+                params[field] = "arbitrary string";
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, expectedType, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // "field":false
+                params[jss::ledger_index] = jss::validated;
+                params[field] = false;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, expectedType, "invalidParams");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+
+                // "field":[incorrect index hash]
+                auto const badKey = strHex(expectedKey.key + uint256{1});
+                params[jss::ledger_index] = jss::validated;
+                params[field] = badKey;
+                auto const 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));
+            }
+
+            {
+                Json::Value params;
+                // "index":"field" using API 2
+                params[jss::ledger_index] = jss::validated;
+                params[jss::index] = field;
+                params[jss::api_version] = 2;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, expectedType, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            std::string const pdIdx = [&]() {
+                {
+                    Json::Value params;
+                    // Test good values
+                    // Use the "field":true notation
+                    params[jss::ledger_index] = jss::validated;
+                    params[field] = true;
+                    auto const 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);
+
+                    return pdIdx;
+                }
+            }();
+
+            {
+                Json::Value params;
+                // "field":"[index hash]"
+                params[jss::ledger_index] = jss::validated;
+                params[field] = hexKey;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(good, jv, expectedType);
+                BEAST_EXPECT(jv[jss::result][jss::index].asString() == hexKey);
+            }
+
+            {
+                // Bad value
+                // Use the "index":"field" notation with API 2
+                Json::Value params;
+                params[jss::ledger_index] = jss::validated;
+                params[jss::index] = field;
+                params[jss::api_version] = 2;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, expectedType, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // Use the "index":"field" notation with API 3
+                params[jss::ledger_index] = jss::validated;
+                params[jss::index] = field;
+                params[jss::api_version] = 3;
+                auto const 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);
+            }
+
+            {
+                Json::Value params;
+                // Use the "index":"[index hash]" notation
+                params[jss::ledger_index] = jss::validated;
+                params[jss::index] = pdIdx;
+                auto const 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));
+            }
+
+            {
+                Json::Value params;
+                // "hashes":"non-uint string"
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = "arbitrary string";
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, 0, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // "hashes":"uint string" is invalid, too
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = "10";
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, 0, "malformedRequest");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // "hashes":false
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = false;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, 0, "invalidParams");
+                BEAST_EXPECT(!jv[jss::result].isMember(jss::index));
+            }
+
+            {
+                Json::Value params;
+                // "hashes":-1
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = -1;
+                auto const 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]
+            {
+                Json::Value params;
+                auto const badKey = strHex(expectedKey.key + uint256{1});
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = badKey;
+                auto const jv =
+                    env.rpc("json", "ledger_entry", to_string(params));
+                checkResult(false, jv, 0, "entryNotFound");
+                BEAST_EXPECT(jv[jss::result][jss::index] == badKey);
+            }
+
+            {
+                Json::Value params;
+                // Test good values
+                // Use the "hashes":ledger notation
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = ledger;
+                auto const 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));
+            }
+
+            {
+                Json::Value params;
+                // "hashes":"[index hash]"
+                params[jss::ledger_index] = jss::validated;
+                params[jss::hashes] = hexKey;
+                auto const 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()));
+            }
+
+            {
+                Json::Value params;
+                // Use the "index":"[index hash]" notation
+                params[jss::ledger_index] = jss::validated;
+                params[jss::index] = hexKey;
+                auto const 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()
     {
@@ -2400,6 +2859,8 @@ public:
         testOracleLedgerEntry();
         testMPT();
         testPermissionedDomain();
+        testFixed();
+        testHashes();
         testCLI();
     }
 };