WIP

Author: ThomasBrady

src/ledger/LedgerTxn.cpp

@@ -26,7 +26,89 @@
 
 namespace stellar
 {
-
+namespace
+{
+void
+enforcePreLoadInvariants(LedgerKey const& key, uint32_t ledgerVersion)
+{
+    switch (key.type())
+    {
+    case ACCOUNT:
+        break;
+    case DATA:
+        break;
+    case OFFER:
+        // Ensure offer is not XLM -- possibly?
+        // special case for offer loading from allow trust op frame?
+        // See LedgerTxnOfferSQL.cpp::loadOffersByAccountAndAsset
+        break;
+    case TRUSTLINE:
+        // Validate trustline.
+        validateTrustLineKey(ledgerVersion, key);
+        break;
+    case CLAIMABLE_BALANCE:
+        break;
+    case LIQUIDITY_POOL:
+        break;
+    case CONTRACT_DATA:
+        break;
+    case CONTRACT_CODE:
+        break;
+    case CONFIG_SETTING:
+        break;
+    case TTL:
+        break;
+    default:
+        throw std::runtime_error("Unknown key type");
+    }
+}
+void
+enforcePostLoadInvariants(LedgerKey const& key,
+                          std::shared_ptr<LedgerEntry const> const& entry)
+{
+    if (!entry)
+    {
+        return;
+    }
+    releaseAssert(key.type() == entry->data.type());
+    switch (key.type())
+    {
+    case ACCOUNT:
+        // LedgerTxnRoot::loadAccount SQL enforces
+        // invariants post-load.
+        // It decodes the result of the query and ensures
+        // the account signers are sorted in ascending order.
+        releaseAssert(
+            std::adjacent_find(entry->data.account().signers.begin(),
+                               entry->data.account().signers.end(),
+                               [](Signer const& lhs, Signer const& rhs) {
+                                   return !(lhs.key < rhs.key);
+                               }) == entry->data.account().signers.end());
+        break;
+    case DATA:
+        // No invariants.
+        break;
+    case OFFER:
+        break;
+    case TRUSTLINE:
+        break;
+    case CLAIMABLE_BALANCE:
+        break;
+    case LIQUIDITY_POOL:
+        break;
+    case CONTRACT_DATA:
+        break;
+    case CONTRACT_CODE:
+        break;
+    case CONFIG_SETTING:
+        break;
+    case TTL:
+        break;
+    default:
+        throw std::runtime_error("Unknown key type");
+    }
+};
+}
 LedgerEntryPtr
 LedgerEntryPtr::Init(std::shared_ptr<InternalLedgerEntry> const& lePtr)
 {
@@ -2986,9 +3068,17 @@ LedgerTxnRoot::Impl::prefetch(UnorderedSet<LedgerKey> const& keys)
         {
             insertIfNotLoaded(keysToSearch, key);
         }
-
+        for (auto key : keys)
+        {
+            enforcePreLoadInvariants(key, mHeader->ledgerVersion);
+        }
         auto blLoad = mApp.getBucketManager().loadKeys(keysToSearch);
-        cacheResult(populateLoadedEntries(keysToSearch, blLoad));
+        auto loadedEntries = populateLoadedEntries(keysToSearch, blLoad);
+        for (auto entry : loadedEntries)
+        {
+            enforcePostLoadInvariants(entry.first, entry.second);
+        }
+        cacheResult(loadedEntries);
     }
     else
     {
@@ -3620,86 +3710,10 @@ LedgerTxnRoot::Impl::getNewestVersion(InternalLedgerKey const& gkey) const
     }
 
     std::shared_ptr<LedgerEntry const> entry;
-    auto enforcePreLoadInvariants = [&](LedgerKey const& key) {
-        switch (key.type())
-        {
-        case ACCOUNT:
-            break;
-        case DATA:
-            break;
-        case OFFER:
-            // Ensure offer is not XLM -- possibly?
-            // special case for offer loading from allow trust op frame?
-            // See LedgerTxnOfferSQL.cpp::loadOffersByAccountAndAsset
-            break;
-        case TRUSTLINE:
-            // Validate trustline.
-            validateTrustLineKey(mHeader->ledgerVersion, key);
-            break;
-        case CLAIMABLE_BALANCE:
-            break;
-        case LIQUIDITY_POOL:
-            break;
-        case CONTRACT_DATA:
-            break;
-        case CONTRACT_CODE:
-            break;
-        case CONFIG_SETTING:
-            break;
-        case TTL:
-            break;
-        default:
-            throw std::runtime_error("Unknown key type");
-        }
-    };
-    auto enforcePostLoadInvariants =
-        [&](LedgerKey const& key,
-            std::shared_ptr<LedgerEntry const> const& entry) {
-            if (!entry)
-            {
-                return;
-            }
-            releaseAssert(key.type() == entry->data.type());
-            switch (key.type())
-            {
-            case ACCOUNT:
-                // LedgerTxnRoot::loadAccount SQL enforces
-                // invariants post-load.
-                // It decodes the result of the query and ensures
-                // the account signers are sorted in ascending order.
-                releaseAssert(std::adjacent_find(
-                                  entry->data.account().signers.begin(),
-                                  entry->data.account().signers.end(),
-                                  [](Signer const& lhs, Signer const& rhs) {
-                                      return !(lhs.key < rhs.key);
-                                  }) == entry->data.account().signers.end());
-                break;
-            case DATA:
-                // No invariants.
-                break;
-            case OFFER:
-                break;
-            case TRUSTLINE:
-                break;
-            case CLAIMABLE_BALANCE:
-                break;
-            case LIQUIDITY_POOL:
-                break;
-            case CONTRACT_DATA:
-                break;
-            case CONTRACT_CODE:
-                break;
-            case CONFIG_SETTING:
-                break;
-            case TTL:
-                break;
-            default:
-                throw std::runtime_error("Unknown key type");
-            }
-        };
+
     try
     {
-        enforcePreLoadInvariants(key);
+        enforcePreLoadInvariants(key, mHeader->ledgerVersion);
         if (mApp.getConfig().isUsingBucketListDB() && key.type() != OFFER)
         {
             entry = mApp.getBucketManager().getLedgerEntry(key);