Update mulDiv.cpp

invalid operands to binary expression ('basic_ostream<char, std::char_traits<char>>' and 'Json::Value')

Builds/CMake/RippledCore.cmake

@@ -433,13 +433,17 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/CancelOffer.cpp
   src/ripple/app/tx/impl/CashCheck.cpp
   src/ripple/app/tx/impl/Change.cpp
+  src/ripple/app/tx/impl/ClaimReward.cpp
   src/ripple/app/tx/impl/CreateCheck.cpp
   src/ripple/app/tx/impl/CreateOffer.cpp
   src/ripple/app/tx/impl/CreateTicket.cpp
   src/ripple/app/tx/impl/DeleteAccount.cpp
   src/ripple/app/tx/impl/DepositPreauth.cpp
   src/ripple/app/tx/impl/Escrow.cpp
+  src/ripple/app/tx/impl/GenesisMint.cpp
+  src/ripple/app/tx/impl/Import.cpp
   src/ripple/app/tx/impl/InvariantCheck.cpp
+  src/ripple/app/tx/impl/Invoke.cpp
   src/ripple/app/tx/impl/NFTokenAcceptOffer.cpp
   src/ripple/app/tx/impl/NFTokenBurn.cpp
   src/ripple/app/tx/impl/NFTokenCancelOffer.cpp
@@ -448,14 +452,10 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/OfferStream.cpp
   src/ripple/app/tx/impl/PayChan.cpp
   src/ripple/app/tx/impl/Payment.cpp
-  src/ripple/app/tx/impl/SetAccount.cpp
-  src/ripple/app/tx/impl/SetRegularKey.cpp
-  src/ripple/app/tx/impl/SetHook.cpp
-  src/ripple/app/tx/impl/ClaimReward.cpp
-  src/ripple/app/tx/impl/GenesisMint.cpp
-  src/ripple/app/tx/impl/Import.cpp
-  src/ripple/app/tx/impl/Invoke.cpp
   src/ripple/app/tx/impl/Remit.cpp
+  src/ripple/app/tx/impl/SetAccount.cpp
+  src/ripple/app/tx/impl/SetHook.cpp
+  src/ripple/app/tx/impl/SetRegularKey.cpp
   src/ripple/app/tx/impl/SetSignerList.cpp
   src/ripple/app/tx/impl/SetTrust.cpp
   src/ripple/app/tx/impl/SignerEntries.cpp

Builds/levelization/results/loops.txt

@@ -53,7 +53,7 @@ Loop: test.app test.jtx
   test.app > test.jtx
 
 Loop: test.app test.rpc
-  test.rpc == test.app
+  test.rpc ~= test.app
 
 Loop: test.jtx test.toplevel
   test.toplevel > test.jtx

src/ripple/app/hook/impl/applyHook.cpp

@@ -1,12 +1,17 @@
 #include <ripple/app/hook/applyHook.h>
 #include <ripple/app/ledger/OpenLedger.h>
 #include <ripple/app/ledger/TransactionMaster.h>
+#include <ripple/app/misc/HashRouter.h>
 #include <ripple/app/misc/NetworkOPs.h>
 #include <ripple/app/misc/Transaction.h>
 #include <ripple/app/misc/TxQ.h>
+#include <ripple/app/tx/impl/Import.h>
+#include <ripple/app/tx/impl/details/NFTokenUtils.h>
 #include <ripple/basics/Log.h>
 #include <ripple/basics/Slice.h>
 #include <ripple/protocol/ErrorCodes.h>
+#include <ripple/protocol/TxFlags.h>
+#include <ripple/protocol/st.h>
 #include <ripple/protocol/tokens.h>
 #include <boost/multiprecision/cpp_dec_float.hpp>
 #include <any>

src/ripple/app/ledger/LedgerHistory.cpp

@@ -58,15 +58,12 @@ LedgerHistory::insert(std::shared_ptr<Ledger const> ledger, bool validated)
 
     assert(ledger->stateMap().getHash().isNonZero());
 
-    std::unique_lock sl(m_ledgers_by_hash.peekMutex(ledger->info().hash));
+    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
 
     const bool alreadyHad = m_ledgers_by_hash.canonicalize_replace_cache(
         ledger->info().hash, ledger);
     if (validated)
-    {
-        std::unique_lock<std::shared_mutex> lock(mLedgersByIndexMutex);
         mLedgersByIndex[ledger->info().seq] = ledger->info().hash;
-    }
 
     return alreadyHad;
 }
@@ -74,7 +71,7 @@ LedgerHistory::insert(std::shared_ptr<Ledger const> ledger, bool validated)
 LedgerHash
 LedgerHistory::getLedgerHash(LedgerIndex index)
 {
-    std::unique_lock<std::shared_mutex> lock(mLedgersByIndexMutex);
+    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
     auto it = mLedgersByIndex.find(index);
 
     if (it != mLedgersByIndex.end())
@@ -87,13 +84,13 @@ std::shared_ptr<Ledger const>
 LedgerHistory::getLedgerBySeq(LedgerIndex index)
 {
     {
-        std::unique_lock<std::shared_mutex> lock(mLedgersByIndexMutex);
-
+        std::unique_lock sl(m_ledgers_by_hash.peekMutex());
         auto it = mLedgersByIndex.find(index);
 
         if (it != mLedgersByIndex.end())
         {
             uint256 hash = it->second;
+            sl.unlock();
             return getLedgerByHash(hash);
         }
     }
@@ -107,17 +104,11 @@ LedgerHistory::getLedgerBySeq(LedgerIndex index)
 
     {
         // Add this ledger to the local tracking by index
-        {
-            std::unique_lock sl(m_ledgers_by_hash.peekMutex(ret->info().hash));
-            assert(ret->isImmutable());
-            m_ledgers_by_hash.canonicalize_replace_client(
-                ret->info().hash, ret);
-        }
+        std::unique_lock sl(m_ledgers_by_hash.peekMutex());
 
-        {
-            std::unique_lock<std::shared_mutex> lock(mLedgersByIndexMutex);
-            mLedgersByIndex[ret->info().seq] = ret->info().hash;
-        }
+        assert(ret->isImmutable());
+        m_ledgers_by_hash.canonicalize_replace_client(ret->info().hash, ret);
+        mLedgersByIndex[ret->info().seq] = ret->info().hash;
         return (ret->info().seq == index) ? ret : nullptr;
     }
 }
@@ -449,7 +440,7 @@ LedgerHistory::builtLedger(
     LedgerHash hash = ledger->info().hash;
     assert(!hash.isZero());
 
-    std::unique_lock sl(m_consensus_validated.peekMutex(index));
+    std::unique_lock sl(m_consensus_validated.peekMutex());
 
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
@@ -489,7 +480,7 @@ LedgerHistory::validatedLedger(
     LedgerHash hash = ledger->info().hash;
     assert(!hash.isZero());
 
-    std::unique_lock sl(m_consensus_validated.peekMutex(index));
+    std::unique_lock sl(m_consensus_validated.peekMutex());
 
     auto entry = std::make_shared<cv_entry>();
     m_consensus_validated.canonicalize_replace_client(index, entry);
@@ -524,7 +515,7 @@ LedgerHistory::validatedLedger(
 bool
 LedgerHistory::fixIndex(LedgerIndex ledgerIndex, LedgerHash const& ledgerHash)
 {
-    std::unique_lock<std::shared_mutex> lock(mLedgersByIndexMutex);
+    std::unique_lock sl(m_ledgers_by_hash.peekMutex());
     auto it = mLedgersByIndex.find(ledgerIndex);
 
     if ((it != mLedgersByIndex.end()) && (it->second != ledgerHash))

src/ripple/app/ledger/LedgerHistory.h

@@ -27,7 +27,6 @@
 #include <ripple/protocol/RippleLedgerHash.h>
 
 #include <optional>
-#include <shared_mutex>
 
 namespace ripple {
 
@@ -151,7 +150,6 @@ private:
 
     // Maps ledger indexes to the corresponding hash.
     std::map<LedgerIndex, LedgerHash> mLedgersByIndex;  // validated ledgers
-    std::shared_mutex mLedgersByIndexMutex;
 
     beast::Journal j_;
 };

src/ripple/app/misc/NegativeUNLVote.cpp

@@ -19,7 +19,9 @@
 
 #include <ripple/app/consensus/RCLValidations.h>
 #include <ripple/app/ledger/Ledger.h>
+#include <ripple/app/main/Application.h>
 #include <ripple/app/misc/NegativeUNLVote.h>
+#include <ripple/json/to_string.h>
 
 namespace ripple {
 

src/ripple/app/misc/TxQ.h

@@ -111,7 +111,7 @@ public:
         std::uint32_t minimumTxnInLedgerSA = 1000;
         /// Number of transactions per ledger that fee escalation "works
         /// towards".
-        std::uint32_t targetTxnInLedger = 1000;
+        std::uint32_t targetTxnInLedger = 256;
         /** Optional maximum allowed value of transactions per ledger before
             fee escalation kicks in. By default, the maximum is an emergent
             property of network, validator, and consensus performance. This

src/ripple/app/tx/impl/GenesisMint.cpp

@@ -23,6 +23,7 @@
 #include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/st.h>
 
 namespace ripple {
 

src/ripple/app/tx/impl/Import.cpp

@@ -24,12 +24,15 @@
 #include <ripple/basics/base64.h>
 #include <ripple/json/json_reader.h>
 #include <ripple/json/json_value.h>
+#include <ripple/json/to_string.h>
 #include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Import.h>
 #include <ripple/protocol/Indexes.h>
 #include <ripple/protocol/PublicKey.h>
 #include <ripple/protocol/STTx.h>
+#include <ripple/protocol/STValidation.h>
+#include <ripple/protocol/st.h>
 #include <algorithm>
 #include <charconv>
 #include <iostream>

src/ripple/app/tx/impl/Invoke.cpp

@@ -22,6 +22,7 @@
 #include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/st.h>
 
 namespace ripple {
 

src/ripple/app/tx/impl/Remit.cpp

@@ -23,6 +23,9 @@
 #include <ripple/ledger/View.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Indexes.h>
+#include <ripple/protocol/TxFlags.h>
+#include <ripple/protocol/st.h>
+
 namespace ripple {
 
 TxConsequences

src/ripple/app/tx/impl/SetSignerList.cpp

@@ -153,8 +153,10 @@ SetSignerList::preCompute()
 // NOTE: This way of computing the OwnerCount associated with a SignerList
 // is valid until the featureMultiSignReserve amendment passes.  Once it
 // passes then just 1 OwnerCount is associated with a SignerList.
-static int
-signerCountBasedOwnerCountDelta(std::size_t entryCount, Rules const& rules)
+int
+SetSignerList::signerCountBasedOwnerCountDelta(
+    std::size_t entryCount,
+    Rules const& rules)
 {
     // We always compute the full change in OwnerCount, taking into account:
     //  o The fact that we're adding/removing a SignerList and
@@ -176,8 +178,8 @@ signerCountBasedOwnerCountDelta(std::size_t entryCount, Rules const& rules)
     return 2 + static_cast<int>(entryCount);
 }
 
-static TER
-removeSignersFromLedger(
+TER
+SetSignerList::removeSignersFromLedger(
     Application& app,
     ApplyView& view,
     Keylet const& accountKeylet,

src/ripple/app/tx/impl/SetSignerList.h

@@ -71,6 +71,18 @@ public:
         AccountID const& account,
         beast::Journal j);
 
+    static TER
+    removeSignersFromLedger(
+        Application& app,
+        ApplyView& view,
+        Keylet const& accountKeylet,
+        Keylet const& ownerDirKeylet,
+        Keylet const& signerListKeylet,
+        beast::Journal j);
+
+    static int
+    signerCountBasedOwnerCountDelta(std::size_t entryCount, Rules const& rules);
+
 private:
     static void
     writeSignersToSLE(

src/ripple/app/tx/impl/applySteps.cpp

@@ -23,6 +23,7 @@
 #include <ripple/app/tx/impl/CancelOffer.h>
 #include <ripple/app/tx/impl/CashCheck.h>
 #include <ripple/app/tx/impl/Change.h>
+#include <ripple/app/tx/impl/ClaimReward.h>
 #include <ripple/app/tx/impl/CreateCheck.h>
 #include <ripple/app/tx/impl/CreateOffer.h>
 #include <ripple/app/tx/impl/CreateTicket.h>
@@ -39,12 +40,14 @@
 #include <ripple/app/tx/impl/NFTokenMint.h>
 #include <ripple/app/tx/impl/PayChan.h>
 #include <ripple/app/tx/impl/Payment.h>
+#include <ripple/app/tx/impl/Remit.h>
 #include <ripple/app/tx/impl/SetAccount.h>
 #include <ripple/app/tx/impl/SetHook.h>
 #include <ripple/app/tx/impl/SetRegularKey.h>
 #include <ripple/app/tx/impl/SetSignerList.h>
 #include <ripple/app/tx/impl/SetTrust.h>
 #include <ripple/app/tx/impl/URIToken.h>
+#include <ripple/app/tx/impl/XahauGenesis.h>
 
 namespace ripple {
 

src/ripple/basics/TaggedCache.h

@@ -53,7 +53,7 @@ template <
     class Hash = hardened_hash<>,
     class KeyEqual = std::equal_to<Key>,
     class Mutex = std::recursive_mutex>
-class TaggedCacheSingle
+class TaggedCache
 {
 public:
     using mutex_type = Mutex;
@@ -62,7 +62,7 @@ public:
     using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
 
 public:
-    TaggedCacheSingle(
+    TaggedCache(
         std::string const& name,
         int size,
         clock_type::duration expiration,
@@ -74,7 +74,7 @@ public:
         , m_clock(clock)
         , m_stats(
               name,
-              std::bind(&TaggedCacheSingle::collect_metrics, this),
+              std::bind(&TaggedCache::collect_metrics, this),
               collector)
         , m_name(name)
         , m_target_size(size)
@@ -258,7 +258,7 @@ public:
         // At this point allStuffToSweep will go out of scope outside the lock
         // and decrement the reference count on each strong pointer.
         JLOG(m_journal.debug())
-            << m_name << " TaggedCacheSingle sweep lock duration "
+            << m_name << " TaggedCache sweep lock duration "
             << std::chrono::duration_cast<std::chrono::milliseconds>(
                    std::chrono::steady_clock::now() - start)
                    .count()
@@ -715,7 +715,7 @@ private:
             if (mapRemovals || cacheRemovals)
             {
                 JLOG(m_journal.debug())
-                    << "TaggedCacheSingle partition sweep " << m_name
+                    << "TaggedCache partition sweep " << m_name
                     << ": cache = " << partition.size() << "-" << cacheRemovals
                     << ", map-=" << mapRemovals;
             }
@@ -762,7 +762,7 @@ private:
             if (mapRemovals || cacheRemovals)
             {
                 JLOG(m_journal.debug())
-                    << "TaggedCacheSingle partition sweep " << m_name
+                    << "TaggedCache partition sweep " << m_name
                     << ": cache = " << partition.size() << "-" << cacheRemovals
                     << ", map-=" << mapRemovals;
             }
@@ -793,253 +793,6 @@ private:
     std::uint64_t m_misses;
 };
 
-#include <array>
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <type_traits>
-
-template <
-    class Key,
-    class T,
-    bool IsKeyCache = false,
-    class Hash = hardened_hash<>,
-    class KeyEqual = std::equal_to<Key>,
-    class Mutex = std::recursive_mutex>
-class TaggedCache
-{
-private:
-    static constexpr size_t NUM_CACHES = 16;
-
-    using CacheType =
-        TaggedCacheSingle<Key, T, IsKeyCache, Hash, KeyEqual, Mutex>;
-    std::array<std::unique_ptr<CacheType>, NUM_CACHES> caches;
-
-    // Helper function to get the index of the cache based on the key
-    size_t
-    getCacheIndex(const Key& key) const
-    {
-        // Assuming Key can be hashed
-        size_t hash = Hash{}(key);
-        return hash & 0xF;  // Use the least significant nibble
-    }
-
-public:
-    using mutex_type = Mutex;
-    using key_type = Key;
-    using mapped_type = T;
-    using clock_type = beast::abstract_clock<std::chrono::steady_clock>;
-
-    TaggedCache(
-        std::string const& name,
-        int size,
-        clock_type::duration expiration,
-        clock_type& clock,
-        beast::Journal journal,
-        beast::insight::Collector::ptr const& collector =
-            beast::insight::NullCollector::New())
-    {
-        for (size_t i = 0; i < NUM_CACHES; ++i)
-        {
-            caches[i] = std::make_unique<CacheType>(
-                name + "_" + std::to_string(i),
-                size / NUM_CACHES,  // Distribute size across caches
-                expiration,
-                clock,
-                journal,
-                collector);
-        }
-    }
-
-    // Implement all public methods of TaggedCache, delegating to the
-    // appropriate cache instance
-
-    clock_type&
-    clock()
-    {
-        return caches[0]->clock();  // All caches share the same clock
-    }
-
-    std::size_t
-    size() const
-    {
-        std::size_t total = 0;
-        for (const auto& cache : caches)
-            total += cache->size();
-        return total;
-    }
-
-    void
-    setTargetSize(int s)
-    {
-        int sizePerCache = s / NUM_CACHES;
-        for (auto& cache : caches)
-            cache->setTargetSize(sizePerCache);
-    }
-
-    clock_type::duration
-    getTargetAge() const
-    {
-        return caches[0]
-            ->getTargetAge();  // All caches share the same target age
-    }
-
-    void
-    setTargetAge(clock_type::duration s)
-    {
-        for (auto& cache : caches)
-            cache->setTargetAge(s);
-    }
-
-    int
-    getCacheSize() const
-    {
-        int total = 0;
-        for (const auto& cache : caches)
-            total += cache->getCacheSize();
-        return total;
-    }
-
-    int
-    getTrackSize() const
-    {
-        int total = 0;
-        for (const auto& cache : caches)
-            total += cache->getTrackSize();
-        return total;
-    }
-
-    float
-    getHitRate()
-    {
-        float totalHitRate = 0;
-        for (const auto& cache : caches)
-            totalHitRate += cache->getHitRate();
-        return totalHitRate / NUM_CACHES;
-    }
-
-    void
-    clear()
-    {
-        for (auto& cache : caches)
-            cache->clear();
-    }
-
-    void
-    reset()
-    {
-        for (auto& cache : caches)
-            cache->reset();
-    }
-
-    template <class KeyComparable>
-    bool
-    touch_if_exists(KeyComparable const& key)
-    {
-        return caches[getCacheIndex(key)]->touch_if_exists(key);
-    }
-
-    void
-    sweep()
-    {
-        for (auto& cache : caches)
-            cache->sweep();
-    }
-
-    bool
-    del(const key_type& key, bool valid)
-    {
-        return caches[getCacheIndex(key)]->del(key, valid);
-    }
-
-    bool
-    canonicalize(
-        const key_type& key,
-        std::shared_ptr<T>& data,
-        std::function<bool(std::shared_ptr<T> const&)>&& replace)
-    {
-        return caches[getCacheIndex(key)]->canonicalize(
-            key, data, std::move(replace));
-    }
-
-    bool
-    canonicalize_replace_cache(
-        const key_type& key,
-        std::shared_ptr<T> const& data)
-    {
-        return caches[getCacheIndex(key)]->canonicalize_replace_cache(
-            key, data);
-    }
-
-    bool
-    canonicalize_replace_client(const key_type& key, std::shared_ptr<T>& data)
-    {
-        return caches[getCacheIndex(key)]->canonicalize_replace_client(
-            key, data);
-    }
-
-    std::shared_ptr<T>
-    fetch(const key_type& key)
-    {
-        return caches[getCacheIndex(key)]->fetch(key);
-    }
-
-    template <class ReturnType = bool>
-    auto
-    insert(key_type const& key, T const& value)
-        -> std::enable_if_t<!IsKeyCache, ReturnType>
-    {
-        return caches[getCacheIndex(key)]->insert(key, value);
-    }
-
-    template <class ReturnType = bool>
-    auto
-    insert(key_type const& key) -> std::enable_if_t<IsKeyCache, ReturnType>
-    {
-        return caches[getCacheIndex(key)]->insert(key);
-    }
-
-    bool
-    retrieve(const key_type& key, T& data)
-    {
-        return caches[getCacheIndex(key)]->retrieve(key, data);
-    }
-
-    mutex_type&
-    peekMutex(key_type const& key)
-    {
-        return caches[getCacheIndex(key)]->peekMutex();
-    }
-
-    std::vector<key_type>
-    getKeys() const
-    {
-        std::vector<key_type> allKeys;
-        for (const auto& cache : caches)
-        {
-            auto keys = cache->getKeys();
-            allKeys.insert(allKeys.end(), keys.begin(), keys.end());
-        }
-        return allKeys;
-    }
-
-    double
-    rate() const
-    {
-        double totalRate = 0;
-        for (const auto& cache : caches)
-            totalRate += cache->rate();
-        return totalRate / NUM_CACHES;
-    }
-
-    template <class Handler>
-    std::shared_ptr<T>
-    fetch(key_type const& digest, Handler const& h)
-    {
-        return caches[getCacheIndex(digest)]->fetch(digest, h);
-    }
-};
-
 }  // namespace ripple
 
 #endif

src/ripple/basics/impl/mulDiv.cpp

@@ -30,7 +30,7 @@ mulDiv(std::uint64_t value, std::uint64_t mul, std::uint64_t div)
 {
     using namespace boost::multiprecision;
 
-    uint128_t result;
+    boost::multiprecision::uint128_t result;
     result = multiply(result, value, mul);
 
     result /= div;

src/ripple/core/Config.h

@@ -240,7 +240,7 @@ public:
     bool LEDGER_REPLAY = false;
 
     // Work queue limits
-    int MAX_TRANSACTIONS = 1000;
+    int MAX_TRANSACTIONS = 250;
     static constexpr int MAX_JOB_QUEUE_TX = 1000;
     static constexpr int MIN_JOB_QUEUE_TX = 100;
 

src/ripple/ledger/impl/ApplyViewBase.cpp

@@ -19,6 +19,7 @@
 
 #include <ripple/basics/contract.h>
 #include <ripple/ledger/detail/ApplyViewBase.h>
+#include <ripple/protocol/STAccount.h>
 
 namespace ripple {
 namespace detail {

src/ripple/rpc/handlers/ServerInfo.cpp

@@ -19,6 +19,7 @@
 
 #include <ripple/app/main/Application.h>
 #include <ripple/app/misc/NetworkOPs.h>
+#include <ripple/app/reporting/P2pProxy.h>
 #include <ripple/protocol/jss.h>
 #include <ripple/rpc/Context.h>
 #include <ripple/rpc/Role.h>

src/test/app/ClaimReward_test.cpp

@@ -17,7 +17,9 @@
 */
 //==============================================================================
 
+#include <ripple/app/ledger/LedgerMaster.h>
 #include <ripple/protocol/Feature.h>
+#include <ripple/protocol/jss.h>
 #include <test/jtx.h>
 
 namespace ripple {

src/test/app/GenesisMint_test.cpp

@@ -15,8 +15,8 @@
 */
 //==============================================================================
 
-#include <ripple/app/tx/impl/XahauGenesis.h>
 #include <ripple/protocol/Feature.h>
+#include <ripple/protocol/jss.h>
 #include <optional>
 #include <test/jtx.h>
 
@@ -94,7 +94,7 @@ struct GenesisMint_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace std::literals::chrono_literals;
 
-        Env env{*this, envconfig(), features, nullptr};
+        Env env{*this, envconfig(), features};
         auto const alice = Account("alice");
         auto const bob = Account("bob");
         auto const invoker = Account("invoker");
@@ -133,11 +133,7 @@ struct GenesisMint_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace std::literals::chrono_literals;
 
-        Env env{*this, envconfig(), features, nullptr};
-        // Env env{*this, envconfig(), features, nullptr,
-        //     // beast::severities::kWarning
-        //     beast::severities::kTrace
-        // };
+        Env env{*this, envconfig(), features};
         auto const alice = Account("alice");
         auto const bob = Account("bob");
         auto const invoker = Account("invoker");
@@ -639,7 +635,7 @@ struct GenesisMint_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace std::literals::chrono_literals;
 
-        Env env{*this, envconfig(), features, nullptr};
+        Env env{*this, envconfig(), features};
         auto const alice = Account("alice");
         auto const bob = Account("bob");
         env.fund(XRP(10000), alice, bob);
@@ -661,7 +657,7 @@ struct GenesisMint_test : public beast::unit_test::suite
         using namespace jtx;
         using namespace std::literals::chrono_literals;
 
-        Env env{*this, envconfig(), features, nullptr};
+        Env env{*this, envconfig(), features};
         auto const alice = Account("alice");
         auto const bob = Account("bob");
         env.fund(XRP(10000), alice, bob);

src/test/app/Invoke_test.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/protocol/jss.h>
 #include <test/jtx.h>
 
 namespace ripple {

src/test/app/Remit_test.cpp

@@ -2132,7 +2132,6 @@ struct Remit_test : public beast::unit_test::suite
             auto const delta = USD(100);
             env(remit::remit(alice, bob), remit::amts({delta}));
             env.close();
-            auto xferRate = transferRate(*env.current(), gw);
             auto const postAlice = env.balance(alice, USD.issue());
             BEAST_EXPECT(env.balance(bob, USD.issue()) == preBob + delta);
             BEAST_EXPECT(to_string(postAlice.value()) == tc.result);

src/test/app/SetHookTSH_test.cpp

@@ -18,6 +18,7 @@
 */
 //==============================================================================
 
+#include <ripple/app/hook/Enum.h>
 #include <ripple/app/misc/HashRouter.h>
 #include <ripple/app/misc/TxQ.h>
 #include <ripple/app/tx/apply.h>
@@ -31,6 +32,13 @@
 namespace ripple {
 namespace test {
 
+#define BEAST_REQUIRE(x)     \
+    {                        \
+        BEAST_EXPECT(!!(x)); \
+        if (!(x))            \
+            return;          \
+    }
+
 struct SetHookTSH_test : public beast::unit_test::suite
 {
 private:

src/test/jtx/impl/acctdelete.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/protocol/jss.h>
 #include <test/jtx/Env.h>
 #include <test/jtx/acctdelete.h>
 

src/test/jtx/impl/escrow.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/jss.h>
 #include <test/jtx/escrow.h>
 

src/test/jtx/impl/network.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/basics/StringUtilities.h>
 #include <ripple/json/json_reader.h>
 #include <ripple/json/json_writer.h>
 #include <ripple/protocol/Feature.h>

src/test/jtx/impl/paychan.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/jss.h>
 #include <test/jtx/paychan.h>
 

src/test/jtx/offer.h

@@ -23,6 +23,7 @@
 #include <ripple/json/json_value.h>
 #include <ripple/protocol/STAmount.h>
 #include <test/jtx/Account.h>
+#include <test/jtx/Env.h>
 
 namespace ripple {
 namespace test {

src/test/rpc/LedgerRPC_test.cpp

@@ -24,6 +24,7 @@
 #include <ripple/beast/unit_test.h>
 #include <ripple/protocol/ErrorCodes.h>
 #include <ripple/protocol/jss.h>
+#include <test/app/Import_json.h>
 #include <test/jtx.h>
 
 namespace ripple {

src/test/rpc/ServerDefinitions_test.cpp

@@ -19,6 +19,7 @@
 
 #include <ripple/app/misc/AmendmentTable.h>
 #include <ripple/beast/unit_test.h>
+#include <ripple/json/json_reader.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/jss.h>
 #include <test/jtx.h>