ctid for tx (#907)

Fix #898 and #917
2025-11-27 15:15:52 +00:00 · 2023-10-11 09:47:05 +01:00
parent 5e6682ddc7
commit 8d783ecd6a
24 changed files with 1038 additions and 219 deletions
--- a/unittests/rpc/handlers/TxTests.cpp
+++ b/unittests/rpc/handlers/TxTests.cpp
@@ -28,13 +28,16 @@ using namespace rpc;
 namespace json = boost::json;
 using namespace testing;

+using TestTxHandler = BaseTxHandler<MockETLService>;
+
 auto constexpr static TXNID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD";
 auto constexpr static NFTID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
 auto constexpr static NFTID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
 auto constexpr static ACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
 auto constexpr static ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
 auto constexpr static CURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
-
+constexpr static auto CTID = "C002807000010002";  // seq 163952 txindex 1 netid 2
+constexpr static auto SEQ_FROM_CTID = 163952;
 auto constexpr static DEFAULT_OUT = R"({
    "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
    "Fee": "2",
@@ -79,7 +82,7 @@ class RPCTxTest : public HandlerBaseTest
 TEST_F(RPCTxTest, ExcessiveLgrRange)
 {
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -100,7 +103,7 @@ TEST_F(RPCTxTest, ExcessiveLgrRange)
 TEST_F(RPCTxTest, InvalidLgrRange)
 {
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -122,11 +125,15 @@ TEST_F(RPCTxTest, TxnNotFound)
 {
    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
    ASSERT_NE(rawBackendPtr, nullptr);
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
-        .WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
+        .WillOnce(Return(std::optional<TransactionAndMetadata>{}));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -148,11 +155,15 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse)
    ASSERT_NE(rawBackendPtr, nullptr);
    mockBackendPtr->updateRange(10);  // min
    mockBackendPtr->updateRange(30);  // max
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
-        .WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
+        .WillOnce(Return(std::optional<TransactionAndMetadata>{}));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -177,11 +188,15 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue)
    ASSERT_NE(rawBackendPtr, nullptr);
    mockBackendPtr->updateRange(1);     // min
    mockBackendPtr->updateRange(1000);  // max
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
-        .WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
+        .WillOnce(Return(std::optional<TransactionAndMetadata>{}));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -200,6 +215,39 @@ TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue)
    });
 }

+// when ledger range and ctid are provided, searched_all should not be present, because the seq is specified in ctid
+TEST_F(RPCTxTest, CtidNotFoundSearchAllFalse)
+{
+    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
+    ASSERT_NE(rawBackendPtr, nullptr);
+    mockBackendPtr->updateRange(1);     // min
+    mockBackendPtr->updateRange(1000);  // max
+    EXPECT_CALL(*rawBackendPtr, fetchAllTransactionsInLedger(SEQ_FROM_CTID, _))
+        .WillOnce(Return(std::vector<TransactionAndMetadata>{}));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{2}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "ctid": "{}",
+                "min_ledger": 1,
+                "max_ledger": 1000
+            }})",
+            CTID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
+        EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
+        EXPECT_FALSE(err.contains("searched_all"));
+    });
+}
+
 TEST_F(RPCTxTest, DefaultParameter_API_v1)
 {
    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
@@ -212,11 +260,14 @@ TEST_F(RPCTxTest, DefaultParameter_API_v1)
    tx.date = 123456;
    tx.ledgerSequence = 100;

-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));

    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -244,11 +295,14 @@ TEST_F(RPCTxTest, DefaultParameter_API_v2)
    tx.date = 123456;
    tx.ledgerSequence = 100;

-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));

    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -267,7 +321,7 @@ TEST_F(RPCTxTest, ReturnBinary)
    auto constexpr static OUT = R"({
        "meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000",
        "tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9",
-        "hash": "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD",
+        "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
        "date": 123456,
        "ledger_index": 100,
        "inLedger": 100,
@@ -281,10 +335,57 @@ TEST_F(RPCTxTest, ReturnBinary)
        CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
    tx.date = 123456;
    tx.ledgerSequence = 100;
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "command": "tx",
+                "transaction": "{}",
+                "binary": true
+            }})",
+            TXNID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(*output, json::parse(OUT));
+    });
+}
+
+// mimic 1.12 rippled, return ctid when binary is true. This will be changed on rippled.
+TEST_F(RPCTxTest, ReturnBinaryWithCTID)
+{
+    // Note: `inLedger` is API v1 only. See DefaultOutput_*
+    auto constexpr static OUT = R"({
+        "meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000",
+        "tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9",
+        "hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
+        "date": 123456,
+        "ledger_index": 100,
+        "inLedger": 100,
+        "ctid": "C000006400640002",
+        "validated": true
+    })";
+    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
+    ASSERT_NE(rawBackendPtr, nullptr);
+    TransactionAndMetadata tx;
+    tx.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 100, 200, 300).getSerializer().peekData();
+    tx.transaction =
+        CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
+    tx.date = 123456;
+    tx.ledgerSequence = 100;
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -363,10 +464,14 @@ TEST_F(RPCTxTest, MintNFT)
    ASSERT_NE(rawBackendPtr, nullptr);
    tx.date = 123456;
    tx.ledgerSequence = 100;
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -386,10 +491,14 @@ TEST_F(RPCTxTest, NFTAcceptOffer)
    ASSERT_NE(rawBackendPtr, nullptr);
    tx.date = 123456;
    tx.ledgerSequence = 100;
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -410,10 +519,14 @@ TEST_F(RPCTxTest, NFTCancelOffer)
    ASSERT_NE(rawBackendPtr, nullptr);
    tx.date = 123456;
    tx.ledgerSequence = 100;
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this, &ids](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -442,10 +555,14 @@ TEST_F(RPCTxTest, NFTCreateOffer)
    ASSERT_NE(rawBackendPtr, nullptr);
    tx.date = 123456;
    tx.ledgerSequence = 100;
-    ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
-    EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
+
    runSpawn([this](auto yield) {
-        auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
        auto const req = json::parse(fmt::format(
            R"({{ 
                "command": "tx",
@@ -457,3 +574,251 @@ TEST_F(RPCTxTest, NFTCreateOffer)
        EXPECT_TRUE(output->at("meta").at("offer_id").as_string() == NFTID2);
    });
 }
+
+TEST_F(RPCTxTest, CTIDAndTransactionBothProvided)
+{
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "command": "tx",
+                "transaction": "{}",
+                "ctid": "{}"
+            }})",
+            TXNID,
+            CTID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
+    });
+}
+
+TEST_F(RPCTxTest, CTIDAndTransactionBothNotProvided)
+{
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(R"({ "command": "tx"})");
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
+    });
+}
+
+TEST_F(RPCTxTest, CTIDInvalidType)
+{
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(R"({ "command": "tx", "ctid": 123})");
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
+    });
+}
+
+TEST_F(RPCTxTest, CTIDInvalidString)
+{
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 5}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(R"({ "command": "tx", "ctid": "B002807000010002"})");
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error").as_string(), "invalidParams");
+        EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
+    });
+}
+
+TEST_F(RPCTxTest, CTIDNotMatch)
+{
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 5}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "command": "tx",
+                "ctid": "{}"
+            }})",
+            CTID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_FALSE(output);
+
+        auto const err = rpc::makeError(output.error());
+        EXPECT_EQ(err.at("error_code").as_uint64(), 4);
+        EXPECT_EQ(
+            err.at("error_message").as_string(),
+            "Wrong network. You should submit this request to a node running on NetworkID: 2");
+    });
+}
+
+TEST_F(RPCTxTest, ReturnCTIDForTxInput)
+{
+    auto constexpr static OUT = R"({
+            "Account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+            "Fee":"2",
+            "Sequence":100,
+            "SigningPubKey":"74657374",
+            "TakerGets":
+            {
+                "currency":"0158415500000000C1F76FF6ECB0BAC600000000",
+                "issuer":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
+                "value":"200"
+            },
+            "ctid":"C000006400640002",
+            "TakerPays":"300",
+            "TransactionType":"OfferCreate",
+            "hash":"2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
+            "meta":
+            {
+                "AffectedNodes":
+                [
+                    {
+                        "CreatedNode":
+                        {
+                            "LedgerEntryType":"Offer",
+                            "NewFields":
+                            {
+                                "TakerGets":"200",
+                                "TakerPays":
+                                {
+                                    "currency":"0158415500000000C1F76FF6ECB0BAC600000000",
+                                    "issuer":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+                                    "value":"300"
+                                }
+                            }
+                        }
+                    }
+                ],
+                "TransactionIndex":100,
+                "TransactionResult":"tesSUCCESS"
+            },
+            "date":123456,
+            "ledger_index":100,
+            "inLedger":100,
+            "validated": true
+    })";
+    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
+    TransactionAndMetadata tx;
+    tx.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 100, 200, 300).getSerializer().peekData();
+    tx.transaction =
+        CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
+    tx.date = 123456;
+    tx.ledgerSequence = 100;
+    EXPECT_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillOnce(Return(tx));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "command": "tx",
+                "transaction": "{}"
+            }})",
+            TXNID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(*output, json::parse(OUT));
+    });
+}
+
+TEST_F(RPCTxTest, ViaCTID)
+{
+    auto const static OUT = fmt::format(
+        R"({{
+            "Account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+            "Fee":"2",
+            "Sequence":100,
+            "SigningPubKey":"74657374",
+            "TakerGets":
+            {{
+                "currency":"0158415500000000C1F76FF6ECB0BAC600000000",
+                "issuer":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
+                "value":"200"
+            }},
+            "ctid":"{}",
+            "TakerPays":"300",
+            "TransactionType":"OfferCreate",
+            "hash":"2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
+            "meta":
+            {{
+                "AffectedNodes":
+                [
+                    {{
+                        "CreatedNode":
+                        {{
+                            "LedgerEntryType":"Offer",
+                            "NewFields":
+                            {{
+                                "TakerGets":"200",
+                                "TakerPays":
+                                {{
+                                    "currency":"0158415500000000C1F76FF6ECB0BAC600000000",
+                                    "issuer":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+                                    "value":"300"
+                                }}
+                            }}
+                        }}
+                    }}
+                ],
+                "TransactionIndex":1,
+                "TransactionResult":"tesSUCCESS"
+            }},
+            "date":123456,
+            "ledger_index":{},
+            "inLedger":{},
+            "validated": true
+    }})",
+        CTID,
+        SEQ_FROM_CTID,
+        SEQ_FROM_CTID);
+    auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
+    TransactionAndMetadata tx1;
+    tx1.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 1, 200, 300).getSerializer().peekData();
+    tx1.transaction =
+        CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
+    tx1.date = 123456;
+    tx1.ledgerSequence = SEQ_FROM_CTID;
+
+    TransactionAndMetadata tx2;
+    tx2.transaction = CreatePaymentTransactionObject(ACCOUNT, ACCOUNT2, 2, 3, 300).getSerializer().peekData();
+    tx2.metadata = CreatePaymentTransactionMetaObject(ACCOUNT, ACCOUNT2, 110, 30).getSerializer().peekData();
+    tx2.ledgerSequence = SEQ_FROM_CTID;
+
+    EXPECT_CALL(*rawBackendPtr, fetchAllTransactionsInLedger(SEQ_FROM_CTID, _)).WillOnce(Return(std::vector{tx1, tx2}));
+
+    auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr.get());
+    ASSERT_NE(rawETLPtr, nullptr);
+    EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
+
+    runSpawn([this](auto yield) {
+        auto const handler = AnyHandler{TestTxHandler{mockBackendPtr, mockETLServicePtr}};
+        auto const req = json::parse(fmt::format(
+            R"({{ 
+                "command": "tx",
+                "ctid": "{}"
+            }})",
+            CTID));
+        auto const output = handler.process(req, Context{yield});
+        ASSERT_TRUE(output);
+        EXPECT_EQ(*output, json::parse(OUT));
+    });
+}