Fix the rendering issues of some XDR fields

src/catchup/ApplyCheckpointWork.cpp

@@ -257,11 +257,12 @@ ApplyCheckpointWork::onRun()
             {
                 auto& lm = mApp.getLedgerManager();
 
-                CLOG_DEBUG(History, "LedgerManager LCL:\n{}",
-                           xdr_to_string(lm.getLastClosedLedgerHeader()));
+                CLOG_DEBUG(History, "{}",
+                           xdr_to_string(lm.getLastClosedLedgerHeader(),
+                                         "LedgerManager LCL"));
 
-                CLOG_DEBUG(History, "Replay header:\n{}",
-                           xdr_to_string(mHeaderHistoryEntry));
+                CLOG_DEBUG(History, "{}",
+                           xdr_to_string(mHeaderHistoryEntry, "Replay header"));
                 if (lm.getLastClosedLedgerHeader().hash !=
                     mHeaderHistoryEntry.hash)
                 {

src/catchup/simulation/TxSimApplyTransactionsWork.cpp

@@ -66,9 +66,9 @@ checkOperationResults(xdr::xvector<OperationResult> const& expected,
     {
         if (expected[i].code() != actual[i].code())
         {
-            CLOG_ERROR(History, "Expected operation result {} but got {}",
-                       xdr_to_string(expected[i].code()),
-                       xdr_to_string(actual[i].code()));
+            CLOG_ERROR(History, "Expected {} but got {}",
+                       xdr_to_string(expected[i].code(), "OperationResultCode"),
+                       xdr_to_string(actual[i].code(), "OperationResultCode"));
             continue;
         }
 
@@ -154,10 +154,10 @@ checkOperationResults(xdr::xvector<OperationResult> const& expected,
 
         if (!match)
         {
-            CLOG_ERROR(History, "Expected operation result: {}",
-                       xdr_to_string(expectedOpRes));
-            CLOG_ERROR(History, "Actual operation result: {}",
-                       xdr_to_string(actualOpRes));
+            CLOG_ERROR(History, "Expected {}",
+                       xdr_to_string(expectedOpRes, "OperationResult"));
+            CLOG_ERROR(History, "Actual {}",
+                       xdr_to_string(actualOpRes, "OperationResult"));
         }
     }
 }
@@ -179,9 +179,9 @@ checkResults(Application& app, uint32_t ledger,
         if (dbRes.code() != archiveRes.code())
         {
             CLOG_ERROR(
-                History,
-                "Expected result code {} does not agree with {} for tx {}",
-                xdr_to_string(archiveRes.code()), xdr_to_string(dbRes.code()),
+                History, "Expected {} does not agree with {} for tx {}",
+                xdr_to_string(archiveRes.code(), "TransactionResultCode"),
+                xdr_to_string(dbRes.code(), "TransactionResultCode"),
                 binToHex(results[i].transactionHash));
         }
         else if (dbRes.code() == txFEE_BUMP_INNER_FAILED ||
@@ -193,11 +193,13 @@ checkResults(Application& app, uint32_t ledger,
             {
                 CLOG_ERROR(
                     History,
-                    "Expected result code {} does not agree with {} for "
+                    "Expected {} does not agree with {} for "
                     "fee-bump inner tx {}",
                     xdr_to_string(
-                        archiveRes.innerResultPair().result.result.code()),
-                    xdr_to_string(dbRes.innerResultPair().result.result.code()),
+                        archiveRes.innerResultPair().result.result.code(),
+                        "TransactionResultCode"),
+                    xdr_to_string(dbRes.innerResultPair().result.result.code(),
+                                  "TransactionResultCode"),
                     binToHex(archiveRes.innerResultPair().transactionHash));
             }
             else if (dbRes.innerResultPair().result.result.code() == txFAILED ||

src/herder/TxSetFrame.cpp

@@ -298,12 +298,13 @@ TxSetFrame::checkOrTrim(Application& app,
             {
                 if (justCheck)
                 {
-                    CLOG_DEBUG(Herder,
-                               "Got bad txSet: {} tx invalid lastSeq:{} tx: {} "
-                               "result: {}",
-                               hexAbbrev(mPreviousLedgerHash), lastSeq,
-                               xdr_to_string(tx->getEnvelope()),
-                               tx->getResultCode());
+                    CLOG_DEBUG(
+                        Herder,
+                        "Got bad txSet: {} tx invalid lastSeq:{} tx: {} "
+                        "result: {}",
+                        hexAbbrev(mPreviousLedgerHash), lastSeq,
+                        xdr_to_string(tx->getEnvelope(), "TransactionEnvelope"),
+                        tx->getResultCode());
                     return false;
                 }
                 trimmed.emplace_back(tx);
@@ -343,7 +344,8 @@ TxSetFrame::checkOrTrim(Application& app,
                     CLOG_DEBUG(Herder,
                                "Got bad txSet: {} account can't pay fee tx: {}",
                                hexAbbrev(mPreviousLedgerHash),
-                               xdr_to_string(tx->getEnvelope()));
+                               xdr_to_string(tx->getEnvelope(),
+                                             "TransactionEnvelope"));
                     return false;
                 }
                 while (iter != kv.second.end())

src/invariant/InvariantManagerImpl.cpp

@@ -115,9 +115,10 @@ InvariantManagerImpl::checkOnOperationApply(Operation const& operation,
             continue;
         }
 
-        auto message = fmt::format(
-            R"(Invariant "{}" does not hold on operation: {}{}{})",
-            invariant->getName(), result, "\n", xdr_to_string(operation));
+        auto message =
+            fmt::format(R"(Invariant "{}" does not hold on operation: {}{}{})",
+                        invariant->getName(), result, "\n",
+                        xdr_to_string(operation, "Operation"));
         onInvariantFailure(invariant, message,
                            ltxDelta.header.current.ledgerSeq);
     }

src/invariant/LiabilitiesMatchOffers.cpp

@@ -100,7 +100,7 @@ checkAuthorized(LedgerEntry const* current, LedgerEntry const* previous)
                 {
                     return fmt::format(
                         "Liabilities increased on unauthorized trust line {}",
-                        xdr_to_string(trust));
+                        xdr_to_string(trust, "TrustLineEntry"));
                 }
             }
             else
@@ -110,7 +110,7 @@ checkAuthorized(LedgerEntry const* current, LedgerEntry const* previous)
                 {
                     return fmt::format(
                         "Unauthorized trust line has liabilities {}",
-                        xdr_to_string(trust));
+                        xdr_to_string(trust, "TrustLineEntry"));
                 }
             }
         }
@@ -256,8 +256,8 @@ checkBalanceAndLimit(LedgerHeader const& header, LedgerEntry const* current,
                 (INT64_MAX - account.balance < liabilities.buying))
             {
                 return fmt::format(
-                    "Balance not compatible with liabilities for account {}",
-                    xdr_to_string(account));
+                    "Balance not compatible with liabilities for {}",
+                    xdr_to_string(account, "AccountEntry"));
             }
         }
     }
@@ -273,9 +273,8 @@ checkBalanceAndLimit(LedgerHeader const& header, LedgerEntry const* current,
         if ((trust.balance < liabilities.selling) ||
             (trust.limit - trust.balance < liabilities.buying))
         {
-            return fmt::format(
-                "Balance not compatible with liabilities for trustline {}",
-                xdr_to_string(trust));
+            return fmt::format("Balance not compatible with liabilities for {}",
+                               xdr_to_string(trust, "TrustLineEntry"));
         }
     }
     return {};
@@ -346,20 +345,20 @@ LiabilitiesMatchOffers::checkOnOperationApply(Operation const& operation,
                     return fmt::format(
                         "Change in buying liabilities differed from "
                         "change in total buying liabilities of "
-                        "offers by {} for account {} in asset {}",
+                        "offers by {} for {} in {}",
                         assetLiabilities.second.buying,
-                        xdr_to_string(accLiabilities.first),
-                        xdr_to_string(assetLiabilities.first));
+                        xdr_to_string(accLiabilities.first, "account"),
+                        xdr_to_string(assetLiabilities.first, "asset"));
                 }
                 else if (assetLiabilities.second.selling != 0)
                 {
                     return fmt::format(
                         "Change in selling liabilities differed from "
                         "change in total selling liabilities of "
-                        "offers by {} for account {} in asset {}",
+                        "offers by {} for {} in {}",
                         assetLiabilities.second.selling,
-                        xdr_to_string(accLiabilities.first),
-                        xdr_to_string(assetLiabilities.first));
+                        xdr_to_string(accLiabilities.first, "account"),
+                        xdr_to_string(assetLiabilities.first, "asset"));
                 }
             }
         }

src/ledger/InternalLedgerEntry.cpp

@@ -282,13 +282,16 @@ InternalLedgerKey::toString() const
     switch (mType)
     {
     case InternalLedgerEntryType::LEDGER_ENTRY:
-        return xdr_to_string(ledgerKey());
+        return xdr_to_string(ledgerKey(), "LedgerKey");
+
     case InternalLedgerEntryType::SPONSORSHIP:
-        return fmt::format("{{\n  sponsoredID = {}\n}}\n",
-                           xdr_to_string(sponsorshipKey().sponsoredID));
+        return fmt::format(
+            "{{\n  {}\n}}\n",
+            xdr_to_string(sponsorshipKey().sponsoredID, "sponsoredID"));
     case InternalLedgerEntryType::SPONSORSHIP_COUNTER:
-        return fmt::format("{{\n  sponsoringID = {}\n}}\n",
-                           xdr_to_string(sponsorshipCounterKey().sponsoringID));
+        return fmt::format("{{\n  {}\n}}\n",
+                           xdr_to_string(sponsorshipCounterKey().sponsoringID,
+                                         "sponsoringID"));
     default:
         abort();
     }
@@ -558,16 +561,17 @@ InternalLedgerEntry::toString() const
     switch (mType)
     {
     case InternalLedgerEntryType::LEDGER_ENTRY:
-        return xdr_to_string(ledgerEntry());
+        return xdr_to_string(ledgerEntry(), "LedgerEntry");
     case InternalLedgerEntryType::SPONSORSHIP:
-        return fmt::format("{{\n  sponsoredID = {},\n  sponsoringID = {}\n}}\n",
-                           xdr_to_string(sponsorshipEntry().sponsoredID),
-                           xdr_to_string(sponsorshipEntry().sponsoringID));
-    case InternalLedgerEntryType::SPONSORSHIP_COUNTER:
         return fmt::format(
-            "{{\n  sponsoringID = {},\n  numSponsoring = {}\n}}\n",
-            xdr_to_string(sponsorshipCounterEntry().sponsoringID),
-            sponsorshipCounterEntry().numSponsoring);
+            "{{\n  {},\n  {}\n}}\n",
+            xdr_to_string(sponsorshipEntry().sponsoredID, "sponsoredID"),
+            xdr_to_string(sponsorshipEntry().sponsoringID, "sponsoringID"));
+    case InternalLedgerEntryType::SPONSORSHIP_COUNTER:
+        return fmt::format("{{\n  {},\n  numSponsoring = {}\n}}\n",
+                           xdr_to_string(sponsorshipCounterEntry().sponsoringID,
+                                         "sponsoringID"),
+                           sponsorshipCounterEntry().numSponsoring);
     default:
         abort();
     }

src/ledger/LedgerManagerImpl.cpp

@@ -555,8 +555,8 @@ LedgerManagerImpl::closeLedger(LedgerCloseData const& ledgerData)
                                 txSet->previousLedgerHash()),
                    ledgerAbbrev(getLastClosedLedgerHeader()));
 
-        CLOG_ERROR(Ledger, "Full LCL: {}",
-                   xdr_to_string(getLastClosedLedgerHeader()));
+        CLOG_ERROR(Ledger, "{}",
+                   xdr_to_string(getLastClosedLedgerHeader(), "Full LCL"));
         CLOG_ERROR(Ledger, "{}", POSSIBLY_CORRUPTED_LOCAL_DATA);
 
         throw std::runtime_error("txset mismatch");
@@ -623,7 +623,7 @@ LedgerManagerImpl::closeLedger(LedgerCloseData const& ledgerData)
         case Upgrades::UpgradeValidity::INVALID:
             throw std::runtime_error(
                 fmt::format(FMT_STRING("Invalid upgrade at index {}: {}"), i,
-                            xdr_to_string(lupgrade)));
+                            xdr_to_string(lupgrade, "LedgerUpgrade")));
         }
 
         try

src/main/CommandHandler.cpp

@@ -951,7 +951,8 @@ CommandHandler::testTx(std::string const& params, std::string& retStr)
         root["status"] = TX_STATUS_STRING[static_cast<int>(status)];
         if (status == TransactionQueue::AddResult::ADD_STATUS_ERROR)
         {
-            root["detail"] = xdr_to_string(txFrame->getResult().result.code());
+            root["detail"] = xdr_to_string(txFrame->getResult().result.code(),
+                                           "TransactionResultCode");
         }
     }
     else

src/simulation/LoadGenerator.cpp

@@ -647,8 +647,8 @@ LoadGenerator::TxInfo::execute(Application& app, bool isCreate,
     {
         CLOG_INFO(LoadGen, "tx rejected '{}': {} ===> {}",
                   TX_STATUS_STRING[static_cast<int>(status)],
-                  xdr_to_string(txf->getEnvelope()),
-                  xdr_to_string(txf->getResult()));
+                  xdr_to_string(txf->getEnvelope(), "TransactionEnvelope"),
+                  xdr_to_string(txf->getResult(), "TransactionResult"));
         if (status == TransactionQueue::AddResult::ADD_STATUS_ERROR)
         {
             code = txf->getResultCode();

src/test/FuzzerImpl.cpp

@@ -789,11 +789,11 @@ applySetupOperations(LedgerTxn& ltx, PublicKey const& sourceAccount,
 
         if (txFramePtr->getResultCode() != txSUCCESS)
         {
-            auto const msg =
-                fmt::format(FMT_STRING("Error {} while setting up fuzzing -- "
-                                       "transaction result {}"),
-                            txFramePtr->getResultCode(),
-                            xdr_to_string(txFramePtr->getResult()));
+            auto const msg = fmt::format(
+                FMT_STRING("Error {} while setting up fuzzing -- "
+                           "{}"),
+                txFramePtr->getResultCode(),
+                xdr_to_string(txFramePtr->getResult(), "TransactionResult"));
             LOG_FATAL(DEFAULT_LOG, "{}", msg);
             throw std::runtime_error(msg);
         }
@@ -816,8 +816,9 @@ applySetupOperations(LedgerTxn& ltx, PublicKey const& sourceAccount,
             {
                 auto const msg = fmt::format(
                     FMT_STRING("Manage offer result {} while setting "
-                               "up fuzzing -- operation is {}"),
-                    xdr_to_string(tr), xdr_to_string(op));
+                               "up fuzzing -- {}"),
+                    xdr_to_string(tr, "Operation"),
+                    xdr_to_string(op, "Operation"));
                 LOG_FATAL(DEFAULT_LOG, "{}", msg);
                 throw std::runtime_error(msg);
             }
@@ -1280,7 +1281,9 @@ TransactionFuzzer::inject(std::string const& filename)
     }
 
     resetTxInternalState(*mApp);
-    LOG_TRACE(DEFAULT_LOG, "Fuzz ops ({}): {}", ops.size(), xdr_to_string(ops));
+    LOG_TRACE(DEFAULT_LOG, "{}",
+              xdr_to_string(ops, fmt::format("Fuzz ops ({})", ops.size())));
+
     LedgerTxn ltx(mApp->getLedgerTxnRoot());
     applyFuzzOperations(ltx, mSourceAccountID, ops.begin(), ops.end(), *mApp);
 }

src/test/TestPrinter.cpp

@@ -13,11 +13,12 @@ namespace Catch
 std::string
 StringMaker<stellar::OfferState>::convert(stellar::OfferState const& os)
 {
-    return fmt::format(
-        "selling: {}, buying: {}, price: {}, amount: {}, type: {}",
-        xdr_to_string(os.selling), xdr_to_string(os.buying),
-        xdr_to_string(os.price), os.amount,
-        os.type == stellar::OfferType::PASSIVE ? "passive" : "active");
+    return fmt::format("{}, {}, {}, amount: {}, type: {}",
+                       xdr_to_string(os.selling, "selling"),
+                       xdr_to_string(os.buying, "buying"),
+                       xdr_to_string(os.price, "price"), os.amount,
+                       os.type == stellar::OfferType::PASSIVE ? "passive"
+                                                              : "active");
 }
 
 std::string

src/test/TestPrinter.h

@@ -23,7 +23,7 @@ struct StringMaker<T, typename std::enable_if<xdr::xdr_traits<T>::valid>::type>
     static std::string
     convert(T const& val)
     {
-        return xdr_to_string(val);
+        return xdr_to_string(val, "value");
     }
 };
 

src/transactions/OperationFrame.cpp

@@ -122,15 +122,15 @@ OperationFrame::apply(SignatureChecker& signatureChecker,
     bool res;
     if (Logging::logTrace("Tx"))
     {
-        CLOG_TRACE(Tx, "Operation: {}", xdr_to_string(mOperation));
+        CLOG_TRACE(Tx, "{}", xdr_to_string(mOperation, "Operation"));
     }
     res = checkValid(signatureChecker, ltx, true);
     if (res)
     {
         res = doApply(ltx);
         if (Logging::logTrace("Tx"))
         {
-            CLOG_TRACE(Tx, "Operation result: {}", xdr_to_string(mResult));
+            CLOG_TRACE(Tx, "{}", xdr_to_string(mResult, "OperationResult"));
         }
     }
 

src/transactions/TransactionFrame.cpp

@@ -817,19 +817,15 @@ TransactionFrame::applyOperations(SignatureChecker& signatureChecker,
     }
     catch (std::exception& e)
     {
-        CLOG_ERROR(Tx,
-                   "Exception while applying operations (fullHash= {}, "
-                   "contentsHash= {}): {}",
-                   xdr_to_string(getFullHash()),
-                   xdr_to_string(getContentsHash()), e.what());
+        CLOG_ERROR(Tx, "Exception while applying operations ({}, {}): {}",
+                   xdr_to_string(getFullHash(), "fullHash"),
+                   xdr_to_string(getContentsHash(), "contentsHash"), e.what());
     }
     catch (...)
     {
-        CLOG_ERROR(Tx,
-                   "Unknown exception while applying operations (fullHash= {}, "
-                   "contentsHash= {})",
-                   xdr_to_string(getFullHash()),
-                   xdr_to_string(getContentsHash()));
+        CLOG_ERROR(Tx, "Unknown exception while applying operations ({}, {})",
+                   xdr_to_string(getFullHash(), "fullHash"),
+                   xdr_to_string(getContentsHash(), "contentsHash"));
     }
     // This is only reachable if an exception is thrown
     getResult().result.code(txINTERNAL_ERROR);