DRAFT: [WIP] Find everywhere Json is written to the log

include/xrpl/json/json_writer.h

@@ -191,8 +191,8 @@ valueToQuotedString(char const* value);
 
 /// \brief Output using the StyledStreamWriter.
 /// \see Json::operator>>()
-std::ostream&
-operator<<(std::ostream&, Value const& root);
+// std::ostream&
+// operator<<(std::ostream&, Value const& root);
 
 //------------------------------------------------------------------------------
 

include/xrpl/json/to_string.h

@@ -15,8 +15,8 @@ to_string(Value const&);
 std::string
 pretty(Value const&);
 
-/** Output using the StyledStreamWriter. @see Json::operator>>(). */
-std::ostream&
-operator<<(std::ostream&, Value const& root);
+// /** Output using the StyledStreamWriter. @see Json::operator>>(). */
+// std::ostream&
+// operator<<(std::ostream&, Value const& root);
 
 }  // namespace Json

include/xrpl/protocol/STValidation.h

@@ -2,6 +2,7 @@
 
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/json/to_string.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
@@ -161,7 +162,7 @@ STValidation::STValidation(SerialIter& sit, LookupNodeID&& lookupNodeID, bool ch
     if (checkSignature && !isValid())
     {
         JLOG(debugLog().error()) << "Invalid signature in validation: "
-                                 << getJson(JsonOptions::none);
+                                 << to_string(getJson(JsonOptions::none));
         Throw<std::runtime_error>("Invalid signature in validation");
     }
 

src/libxrpl/ledger/ApplyStateTable.cpp

@@ -245,7 +245,7 @@ ApplyStateTable::apply(
 
         // VFALCO For diagnostics do we want to show
         //        metadata even when the base view is open?
-        JLOG(j.trace()) << "metadata " << meta.getJson(JsonOptions::none);
+        JLOG(j.trace()) << "metadata " << to_string(meta.getJson(JsonOptions::none));
 
         metadata = meta;
     }

src/libxrpl/tx/Transactor.cpp

@@ -1114,8 +1114,8 @@ Transactor::operator()()
         {
             // LCOV_EXCL_START
             JLOG(j_.fatal()) << "Transaction serdes mismatch";
-            JLOG(j_.fatal()) << ctx_.tx.getJson(JsonOptions::none);
-            JLOG(j_.fatal()) << s2.getJson(JsonOptions::none);
+            JLOG(j_.fatal()) << to_string(ctx_.tx.getJson(JsonOptions::none));
+            JLOG(j_.fatal()) << to_string(s2.getJson(JsonOptions::none));
             UNREACHABLE("xrpl::Transactor::operator() : transaction serdes mismatch");
             // LCOV_EXCL_STOP
         }

src/libxrpl/tx/paths/PaySteps.cpp

@@ -1,6 +1,8 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/json/json_writer.h>
+#include <xrpl/json/to_string.h>
 #include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/paths/detail/Steps.h>
@@ -642,7 +644,7 @@ toStrands(
         {
             lastFailTer = ter;
             JLOG(j.trace()) << "failed to add path: ter: " << ter
-                            << "path: " << p.getJson(JsonOptions::none);
+                            << "path: " << to_string(p.getJson(JsonOptions::none));
             if (isTemMalformed(ter))
                 return {ter, std::vector<Strand>{}};
         }

src/test/app/Oracle_test.cpp

@@ -1,5 +1,6 @@
 #include <test/jtx/Oracle.h>
 
+#include <xrpl/json/to_string.h>
 #include <xrpl/protocol/jss.h>
 
 namespace xrpl {

src/test/jtx/TestSuite.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <xrpl/beast/unit_test.h>
+#include <xrpl/json/to_string.h>
 
 #include <string>
 

src/test/protocol/STObject_test.cpp

@@ -77,8 +77,8 @@ class STObject_test : public beast::unit_test::suite
 
         if (object1.getSerializer() == object2.getSerializer())
         {
-            log << "O1: " << object1.getJson(JsonOptions::none) << '\n'
-                << "O2: " << object2.getJson(JsonOptions::none) << std::endl;
+            log << "O1: " << to_string(object1.getJson(JsonOptions::none)) << '\n'
+                << "O2: " << to_string(object2.getJson(JsonOptions::none)) << std::endl;
             fail("STObject error 4");
         }
         else

src/test/protocol/STTx_test.cpp

@@ -1333,8 +1333,8 @@ class STTx_test : public beast::unit_test::suite
 
         if (copy != j)
         {
-            log << "j=" << j.getJson(JsonOptions::none) << '\n'
-                << "copy=" << copy.getJson(JsonOptions::none) << std::endl;
+            log << "j=" << to_string(j.getJson(JsonOptions::none)) << '\n'
+                << "copy=" << to_string(copy.getJson(JsonOptions::none)) << std::endl;
             fail("Transaction fails serialize/deserialize test");
         }
         else
@@ -1349,8 +1349,8 @@ class STTx_test : public beast::unit_test::suite
         }
         else if (STObject(j) != parsed.object)
         {
-            log << "ORIG: " << j.getJson(JsonOptions::none) << '\n'
-                << "BUILT " << parsed.object->getJson(JsonOptions::none) << std::endl;
+            log << "ORIG: " << to_string(j.getJson(JsonOptions::none)) << '\n'
+                << "BUILT " << to_string(parsed.object->getJson(JsonOptions::none)) << std::endl;
             fail("Built a different transaction");
         }
         else

src/test/rpc/KeyGeneration_test.cpp

@@ -94,8 +94,8 @@ class WalletPropose_test : public xrpl::TestSuite
         BEAST_EXPECT(result.isMember(jss::key_type));
 
         expectEquals(
-            result[jss::key_type],
-            params.isMember(jss::key_type) ? params[jss::key_type] : "secp256k1");
+            to_string(result[jss::key_type]),
+            params.isMember(jss::key_type) ? to_string(params[jss::key_type]) : "secp256k1");
         BEAST_EXPECT(!result.isMember(jss::warning));
 
         std::string const seed = result[jss::master_seed].asString();
@@ -112,14 +112,14 @@ class WalletPropose_test : public xrpl::TestSuite
         Json::Value result = walletPropose(params);
 
         BEAST_EXPECT(!contains_error(result));
-        expectEquals(result[jss::account_id], s.account_id);
-        expectEquals(result[jss::master_seed], s.master_seed);
-        expectEquals(result[jss::master_seed_hex], s.master_seed_hex);
-        expectEquals(result[jss::public_key], s.public_key);
-        expectEquals(result[jss::public_key_hex], s.public_key_hex);
+        expectEquals(to_string(result[jss::account_id]), s.account_id);
+        expectEquals(to_string(result[jss::master_seed]), s.master_seed);
+        expectEquals(to_string(result[jss::master_seed_hex]), s.master_seed_hex);
+        expectEquals(to_string(result[jss::public_key]), s.public_key);
+        expectEquals(to_string(result[jss::public_key_hex]), s.public_key_hex);
         expectEquals(
-            result[jss::key_type],
-            params.isMember(jss::key_type) ? params[jss::key_type] : "secp256k1");
+            to_string(result[jss::key_type]),
+            params.isMember(jss::key_type) ? to_string(params[jss::key_type]) : "secp256k1");
         return result;
     }
 

src/test/rpc/LedgerData_test.cpp

@@ -419,6 +419,43 @@ class LedgerData_test : public beast::unit_test::suite
                     BEAST_EXPECT(j["LedgerEntryType"] == jss::DepositPreauth);
             }
 
+            {  // jvParams[jss::type] = "misspelling";
+                Json::Value jvParams;
+                jvParams[jss::ledger_index] = "current";
+                jvParams[jss::type] = "misspelling";
+                auto const jrr = env.rpc("json", "ledger_data", to_string(jvParams))[jss::result];
+                BEAST_EXPECT(jrr.isMember("error"));
+                BEAST_EXPECT(jrr["error"] == "invalidParams");
+                BEAST_EXPECT(jrr["error_message"] == "Invalid field 'type'.");
+            }
+            {  // jvParams[jss::type] = "ticket";
+                auto const jrr = makeRequest(jss::ticket);
+                BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
+                for (auto const& j : jrr[jss::state])
+                    BEAST_EXPECT(j["LedgerEntryType"] == jss::Ticket);
+            }
+
+            {  // jvParams[jss::type] = "escrow";
+                auto const jrr = makeRequest(jss::escrow);
+                BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
+                for (auto const& j : jrr[jss::state])
+                    BEAST_EXPECT(j["LedgerEntryType"] == jss::Escrow);
+            }
+
+            {  // jvParams[jss::type] = "payment_channel";
+                auto const jrr = makeRequest(jss::payment_channel);
+                BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
+                for (auto const& j : jrr[jss::state])
+                    BEAST_EXPECT(j["LedgerEntryType"] == jss::PayChannel);
+            }
+
+            {  // jvParams[jss::type] = "deposit_preauth";
+                auto const jrr = makeRequest(jss::deposit_preauth);
+                BEAST_EXPECT(checkArraySize(jrr[jss::state], 2));
+                for (auto const& j : jrr[jss::state])
+                    BEAST_EXPECT(j["LedgerEntryType"] == jss::DepositPreauth);
+            }
+
             {  // jvParams[jss::type] = "misspelling";
                 Json::Value jvParams;
                 jvParams[jss::ledger_index] = "current";

src/tests/libxrpl/json/Value.cpp

@@ -3,6 +3,7 @@
 #include <xrpl/json/json_reader.h>
 #include <xrpl/json/json_value.h>
 #include <xrpl/json/json_writer.h>
+#include <xrpl/json/to_string.h>
 
 #include <gtest/gtest.h>
 
@@ -841,7 +842,8 @@ TEST(json_value, compact)
     EXPECT_TRUE(r.parse(s, j));
     {
         std::stringstream ss;
-        ss << j;
+        // UNDO
+        ss << pretty(j);
         EXPECT_GT(countLines(ss.str()), 1);
     }
     {

src/xrpld/app/ledger/LedgerHistory.cpp

@@ -142,7 +142,7 @@ log_one(ReadView const& ledger, uint256 const& tx, char const* msg, beast::Journ
     {
         JLOG(j.debug()) << "MISMATCH on TX " << tx << ": " << msg
                         << " is missing this transaction:\n"
-                        << metaData->getJson(JsonOptions::none);
+                        << to_string(metaData->getJson(JsonOptions::none));
     }
     else
     {
@@ -223,38 +223,40 @@ log_metadata_difference(
             {
                 JLOG(j.debug()) << "MISMATCH on TX " << tx
                                 << ": Different result, index and nodes!";
-                JLOG(j.debug()) << " Built:\n" << builtMetaData->getJson(JsonOptions::none);
-                JLOG(j.debug()) << " Valid:\n" << validMetaData->getJson(JsonOptions::none);
+                JLOG(j.debug()) << " Built:\n"
+                                << to_string(builtMetaData->getJson(JsonOptions::none));
+                JLOG(j.debug()) << " Valid:\n"
+                                << to_string(validMetaData->getJson(JsonOptions::none));
             }
             else if (result_diff)
             {
                 JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different result and nodes!";
                 JLOG(j.debug()) << " Built:"
                                 << " Result: " << builtMetaData->getResult() << " Nodes:\n"
-                                << builtNodes.getJson(JsonOptions::none);
+                                << to_string(builtNodes.getJson(JsonOptions::none));
                 JLOG(j.debug()) << " Valid:"
                                 << " Result: " << validMetaData->getResult() << " Nodes:\n"
-                                << validNodes.getJson(JsonOptions::none);
+                                << to_string(validNodes.getJson(JsonOptions::none));
             }
             else if (index_diff)
             {
                 JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different index and nodes!";
                 JLOG(j.debug()) << " Built:"
                                 << " Index: " << builtMetaData->getIndex() << " Nodes:\n"
-                                << builtNodes.getJson(JsonOptions::none);
+                                << to_string(builtNodes.getJson(JsonOptions::none));
                 JLOG(j.debug()) << " Valid:"
                                 << " Index: " << validMetaData->getIndex() << " Nodes:\n"
-                                << validNodes.getJson(JsonOptions::none);
+                                << to_string(validNodes.getJson(JsonOptions::none));
             }
             else  // nodes_diff
             {
                 JLOG(j.debug()) << "MISMATCH on TX " << tx << ": Different nodes!";
                 JLOG(j.debug()) << " Built:"
                                 << " Nodes:\n"
-                                << builtNodes.getJson(JsonOptions::none);
+                                << to_string(builtNodes.getJson(JsonOptions::none));
                 JLOG(j.debug()) << " Valid:"
                                 << " Nodes:\n"
-                                << validNodes.getJson(JsonOptions::none);
+                                << to_string(validNodes.getJson(JsonOptions::none));
             }
         }
 
@@ -264,13 +266,13 @@ log_metadata_difference(
     if (validMetaData)
     {
         JLOG(j.error()) << "MISMATCH on TX " << tx << ": Metadata Difference. Valid=\n"
-                        << validMetaData->getJson(JsonOptions::none);
+                        << to_string(validMetaData->getJson(JsonOptions::none));
     }
 
     if (builtMetaData)
     {
         JLOG(j.error()) << "MISMATCH on TX " << tx << ": Metadata Difference. Built=\n"
-                        << builtMetaData->getJson(JsonOptions::none);
+                        << to_string(builtMetaData->getJson(JsonOptions::none));
     }
 }
 
@@ -317,9 +319,9 @@ LedgerHistory::handleMismatch(
 
     if (auto stream = j_.debug())
     {
-        stream << "Built: " << getJson({*builtLedger, {}});
-        stream << "Valid: " << getJson({*validLedger, {}});
-        stream << "Consensus: " << consensus;
+        stream << "Built: " << to_string(getJson({*builtLedger, {}}));
+        stream << "Valid: " << to_string(getJson({*validLedger, {}}));
+        stream << "Consensus: " << to_string(consensus);
     }
 
     // Determine the mismatch reason, distinguishing Byzantine
@@ -364,8 +366,8 @@ LedgerHistory::handleMismatch(
         JLOG(j_.error()) << "MISMATCH with " << builtTx.size() << " built and " << validTx.size()
                          << " valid transactions.";
 
-    JLOG(j_.error()) << "built\n" << getJson({*builtLedger, {}});
-    JLOG(j_.error()) << "valid\n" << getJson({*validLedger, {}});
+    JLOG(j_.error()) << "built\n" << to_string(getJson({*builtLedger, {}}));
+    JLOG(j_.error()) << "valid\n" << to_string(getJson({*validLedger, {}}));
 
     // Log all differences between built and valid ledgers
     auto b = builtTx.begin();

src/xrpld/app/main/Application.cpp

@@ -41,6 +41,7 @@
 #include <xrpl/core/PerfLog.h>
 #include <xrpl/crypto/csprng.h>
 #include <xrpl/json/json_reader.h>
+#include <xrpl/json/to_string.h>
 #include <xrpl/ledger/AmendmentTable.h>
 #include <xrpl/ledger/PendingSaves.h>
 #include <xrpl/nodestore/DummyScheduler.h>
@@ -1424,7 +1425,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline)
 
         if (!config_->quiet())
         {
-            JLOG(m_journal.fatal()) << "Startup RPC: " << jvCommand << std::endl;
+            JLOG(m_journal.fatal()) << "Startup RPC: " << to_string(jvCommand) << std::endl;
         }
 
         Resource::Charge loadType = Resource::feeReferenceRPC;
@@ -1447,7 +1448,7 @@ ApplicationImp::setup(boost::program_options::variables_map const& cmdline)
 
         if (!config_->quiet())
         {
-            JLOG(m_journal.fatal()) << "Result: " << jvResult << std::endl;
+            JLOG(m_journal.fatal()) << "Result: " << to_string(jvResult) << std::endl;
         }
     }
 
@@ -1690,7 +1691,7 @@ ApplicationImp::getLastFullLedger()
             stream << "Failed on ledger";
             Json::Value p;
             addJson(p, {*ledger, nullptr, LedgerFill::full});
-            stream << p;
+            stream << to_string(p);
         }
 
         return {};

src/xrpld/app/main/LoadManager.cpp

@@ -120,14 +120,16 @@ LoadManager::run()
 
                     if (app_.getJobQueue().isOverloaded())
                     {
-                        JLOG(journal_.warn()) << "JobQueue: " << app_.getJobQueue().getJson(0);
+                        JLOG(journal_.warn())
+                            << "JobQueue: " << to_string(app_.getJobQueue().getJson(0));
                     }
                 }
                 else
                 {
                     JLOG(journal_.fatal())
                         << "Server stalled for " << timeSpentStalled.count() << " seconds.";
-                    JLOG(journal_.fatal()) << "JobQueue: " << app_.getJobQueue().getJson(0);
+                    JLOG(journal_.fatal())
+                        << "JobQueue: " << to_string(app_.getJobQueue().getJson(0));
                 }
             }
 
@@ -138,7 +140,7 @@ LoadManager::run()
             {
                 JLOG(journal_.fatal()) << "LogicError: Fatal server stall detected. Stalled time: "
                                        << timeSpentStalled.count() << "s";
-                JLOG(journal_.fatal()) << "JobQueue: " << app_.getJobQueue().getJson(0);
+                JLOG(journal_.fatal()) << "JobQueue: " << to_string(app_.getJobQueue().getJson(0));
                 LogicError("Fatal server stall detected");
             }
         }
@@ -148,7 +150,7 @@ LoadManager::run()
     if (app_.getJobQueue().isOverloaded())
     {
         JLOG(journal_.info()) << "Raising local fee (JQ overload): "
-                              << app_.getJobQueue().getJson(0);
+                              << to_string(app_.getJobQueue().getJson(0));
         change = app_.getFeeTrack().raiseLocalFee();
     }
     else