fix: Add CTID to all RPC's that includes transactions (#2011)

fixes #1998
2025-12-06 17:27:58 +00:00 · 2025-04-25 09:55:39 -04:00
parent 79e6f07863
commit 593d7298b1
17 changed files with 238 additions and 92 deletions
--- a/tests/unit/rpc/RPCHelpersTests.cpp
+++ b/tests/unit/rpc/RPCHelpersTests.cpp
@@ -40,6 +40,7 @@
 #include <boost/json/array.hpp>
 #include <boost/json/object.hpp>
 #include <boost/json/parse.hpp>
+#include <boost/json/value_to.hpp>
 #include <fmt/core.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
--- a/tests/unit/rpc/handlers/AccountTxTests.cpp
+++ b/tests/unit/rpc/handlers/AccountTxTests.cpp
@@ -18,6 +18,7 @@
 //==============================================================================

 #include "data/Types.hpp"
+#include "etl/ETLState.hpp"
 #include "rpc/Errors.hpp"
 #include "rpc/common/AnyHandler.hpp"
 #include "rpc/common/Types.hpp"
@@ -419,7 +420,7 @@ TEST_P(AccountTxParameterTest, CheckParams)
        ASSERT_TRUE(testBundle.expectedErrorMessage.has_value());

        runSpawn([&, this](auto yield) {
-            auto const handler = AnyHandler{AccountTxHandler{backend_}};
+            auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
            auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
            ASSERT_FALSE(output);
            auto const err = rpc::makeError(output.result.error());
@@ -430,7 +431,7 @@ TEST_P(AccountTxParameterTest, CheckParams)
        EXPECT_CALL(*backend_, fetchAccountTransactions);

        runSpawn([&, this](auto yield) {
-            auto const handler = AnyHandler{AccountTxHandler{backend_}};
+            auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
            auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
            EXPECT_TRUE(output);
        });
@@ -505,11 +506,12 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue)
            testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -546,11 +548,12 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -587,11 +590,12 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue)
            testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ - 1, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -628,11 +632,12 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -669,11 +674,10 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -727,7 +731,7 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2)
        .WillOnce(Return(transCursor));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -776,8 +780,10 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
    )
        .WillOnce(Return(transCursor));

+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
+
    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -808,9 +814,10 @@ TEST_F(RPCAccountTxHandlerTest, LimitIsCapped)
    auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
    EXPECT_CALL(*backend_, fetchAccountTransactions(testing::_, testing::_, false, testing::_, testing::_))
        .WillOnce(Return(transCursor));
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -839,9 +846,10 @@ TEST_F(RPCAccountTxHandlerTest, LimitAllowedUpToCap)
    auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
    EXPECT_CALL(*backend_, fetchAccountTransactions(testing::_, testing::_, false, testing::_, testing::_))
        .WillOnce(Return(transCursor));
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -880,15 +888,16 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );

    auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1);
    EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
    ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(ledgerHeader));

+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
+
    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -914,7 +923,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex)
    ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -937,7 +946,7 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex)
    ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -976,8 +985,10 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash)
    EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1);
    ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader));

+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
+
    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1012,15 +1023,16 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );

    auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
    EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
    ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));

+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
+
    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1053,11 +1065,12 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1094,11 +1107,12 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq)
            testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 2, INT32_MAX})),
            testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1187,6 +1201,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                        "hash": "C74463F49CFDCBEF3E9902672719918CDE5042DC7E7660BEBD1D1105C4B6DFF4",
                        "ledger_index": 11,
                        "inLedger": 11,
+                        "ctid": "C000000B00000000",
                        "date": 1
                    },
                    "validated": true
@@ -1225,6 +1240,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                        "hash": "C85E486EE308C68D7E601FCEB4FC961BFA914C80ABBF7ECC7E6277B06692B490",
                        "ledger_index": 11,
                        "inLedger": 11,
+                        "ctid": "C000000B00000000",
                        "date": 2
                    },
                    "validated": true
@@ -1277,6 +1293,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                        "hash": "9F82743EEB30065FB9CB92C61F0F064B5859C5A590FA811FAAAD9C988E5B47DB",
                        "ledger_index": 11,
                        "inLedger": 11,
+                        "ctid": "C000000B00000000",
                        "date": 3
                    },
                    "validated": true
@@ -1310,6 +1327,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
                        "hash": "ECB1837EB7C7C0AC22ECDCCE59FDD4795C70E0B9D8F4E1C9A9408BB7EC75DA5C",
                        "ledger_index": 11,
                        "inLedger": 11,
+                        "ctid": "C000000B00000000",
                        "date": 4
                    },
                    "validated": true
@@ -1331,11 +1349,12 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
        fetchAccountTransactions(
            testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1422,6 +1441,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                        "SigningPubKey": "74657374",
                        "TransactionType": "NFTokenMint",
                        "ledger_index": 11,
+                        "ctid": "C000000B00000000",
                        "date": 1
                    },
                    "validated": true
@@ -1461,6 +1481,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                        "SigningPubKey": "74657374",
                        "TransactionType": "NFTokenAcceptOffer",
                        "ledger_index": 11,
+                        "ctid": "C000000B00000000",
                        "date": 2
                    },
                    "validated": true
@@ -1515,6 +1536,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                        "SigningPubKey": "74657374",
                        "TransactionType": "NFTokenCancelOffer",
                        "ledger_index": 11,
+                        "ctid": "C000000B00000000",
                        "date": 3
                    },
                    "validated": true
@@ -1550,6 +1572,7 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
                        "SigningPubKey": "74657374",
                        "TransactionType": "NFTokenCreateOffer",
                        "ledger_index": 11,
+                        "ctid": "C000000B00000000",
                        "date": 4
                    },
                    "validated": true
@@ -1571,14 +1594,15 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
        fetchAccountTransactions(
            testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
        )
-    )
-        .Times(1);
+    );
+
+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));

    auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 11);
    EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(transactions.size()).WillRepeatedly(Return(ledgerHeader));

    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto static const kINPUT = json::parse(fmt::format(
            R"({{
                "account": "{}",
@@ -1873,6 +1897,7 @@ generateTransactionTypeTestValues()
                        "hash": "51D2AAA6B8E4E16EF22F6424854283D8391B56875858A711B8CE4D5B9A422CC2",
                        "ledger_index": 30,
                        "inLedger": 30,
+                        "ctid": "C000001E00000000",
                        "date": 1
                    },
                    "validated": true
@@ -1925,6 +1950,7 @@ generateTransactionTypeTestValues()
                        "hash": "51D2AAA6B8E4E16EF22F6424854283D8391B56875858A711B8CE4D5B9A422CC2",
                        "ledger_index": 30,
                        "inLedger": 30,
+                        "ctid": "C000001E00000000",
                        "date": 1
                    },
                    "validated": true
@@ -1978,6 +2004,7 @@ generateTransactionTypeTestValues()
                    "SigningPubKey": "74657374",
                    "TransactionType": "Payment",
                    "ledger_index": 30,
+                    "ctid": "C000001E00000000",
                    "date": 1
                },
                "validated": true
@@ -2091,16 +2118,17 @@ TEST_P(AccountTxTransactionTypeTest, SpecificTransactionType)
    ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
    EXPECT_CALL(
        *backend_, fetchAccountTransactions(_, _, false, Optional(Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), _)
-    )
-        .Times(1);
+    );

    auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
    ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));
    EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).Times(Between(1, 2));

+    ON_CALL(*mockETLServicePtr_, getETLState).WillByDefault(Return(etl::ETLState{}));
+
    auto const testBundle = GetParam();
    runSpawn([&, this](auto yield) {
-        auto const handler = AnyHandler{AccountTxHandler{backend_}};
+        auto const handler = AnyHandler{AccountTxHandler{backend_, mockETLServicePtr_}};
        auto const req = json::parse(testBundle.testJson);
        auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
        EXPECT_TRUE(output);
--- a/tests/unit/rpc/handlers/AllHandlerTests.cpp
+++ b/tests/unit/rpc/handlers/AllHandlerTests.cpp
@@ -142,6 +142,8 @@ private:
            return HandlerType{this->backend_, this->mockAmendmentCenterPtr_};
        } else if constexpr (std::is_same_v<HandlerType, SubscribeHandler>) {
            return HandlerType{this->backend_, this->mockAmendmentCenterPtr_, this->mockSubscriptionManagerPtr_};
+        } else if constexpr (std::is_same_v<HandlerType, AccountTxHandler>) {
+            return HandlerType{this->backend_, mockETLServicePtr_};
        } else if constexpr (std::is_same_v<HandlerType, TestServerInfoHandler>) {
            return HandlerType{
                this->backend_,
@@ -174,6 +176,15 @@ createInput<AccountInfoHandler>()
    return input;
 }

+template <>
+AccountTxHandler::Input
+createInput<AccountTxHandler>()
+{
+    AccountTxHandler::Input input{};
+    input.account = kACCOUNT;
+    return input;
+}
+
 template <>
 AMMInfoHandler::Input
 createInput<AMMInfoHandler>()