Added proof generation endpoints

SirTyson · SirTyson · commit 1dfeaf16883d · 2024-10-10T11:17:20.000-07:00
diff --git a/src/main/QueryServer.cpp b/src/main/QueryServer.cpp
@@ -8,6 +8,7 @@
 #include "ledger/LedgerTxnImpl.h"
 #include "ledger/LedgerTypeUtils.h"
 #include "main/Config.h"
+#include "util/ArchivalProofs.h"
 #include "util/Logging.h"
 #include "util/UnorderedSet.h"
 #include "util/XDRStream.h" // IWYU pragma: keep
@@ -77,6 +78,8 @@ QueryServer::QueryServer(const std::string& address, unsigned short port,
     mServer.add404(std::bind(&QueryServer::notFound, this, _1, _2, _3));
     addRoute("getledgerentryraw", &QueryServer::getLedgerEntryRaw);
     addRoute("getledgerentry", &QueryServer::getLedgerEntry);
+    addRoute("getrestoreproof", &QueryServer::getRestoreProof);
+    addRoute("getcreationproof", &QueryServer::getCreationProof);
 
     auto workerPids = mServer.start();
     for (auto pid : workerPids)
@@ -412,4 +415,92 @@ QueryServer::getLedgerEntry(std::string const& params, std::string const& body,
     retStr = Json::FastWriter().write(root);
     return true;
 }
+
+bool
+QueryServer::getRestoreProof(std::string const& params, std::string const& body,
+                             std::string& retStr)
+{
+    ZoneScoped;
+    Json::Value root;
+
+    std::map<std::string, std::vector<std::string>> paramMap;
+    httpThreaded::server::server::parsePostParams(body, paramMap);
+
+    auto keys = paramMap["key"];
+    auto snapshotLedger = parseOptionalParam<uint32_t>(paramMap, "ledgerSeq");
+    if (keys.empty())
+    {
+        throw std::invalid_argument(
+            "Must specify ledger key in POST body: key=<LedgerKey in base64 "
+            "XDR format>");
+    }
+
+    xdr::xvector<ArchivalProof> proof;
+    auto& hotBL = mHotArchiveBucketListSnapshots.at(std::this_thread::get_id());
+    for (auto const& key : keys)
+    {
+        LedgerKey lk;
+        fromOpaqueBase64(lk, key);
+        if (!isPersistentEntry(lk))
+        {
+            throw std::invalid_argument(
+                "Only persistent entries require restoration proofs");
+        }
+
+        if (!addRestorationProof(hotBL, lk, proof, snapshotLedger))
+        {
+            throw std::invalid_argument("No valid proof exists for key");
+        }
+    }
+
+    root["ledger"] = hotBL->getLedgerSeq();
+    root["proof"] = toOpaqueBase64(proof);
+
+    retStr = Json::FastWriter().write(root);
+    return true;
+}
+
+bool
+QueryServer::getCreationProof(std::string const& params,
+                              std::string const& body, std::string& retStr)
+{
+    ZoneScoped;
+    Json::Value root;
+
+    std::map<std::string, std::vector<std::string>> paramMap;
+    httpThreaded::server::server::parsePostParams(body, paramMap);
+
+    auto keys = paramMap["key"];
+    auto snapshotLedger = parseOptionalParam<uint32_t>(paramMap, "ledgerSeq");
+    if (keys.empty())
+    {
+        throw std::invalid_argument(
+            "Must specify ledger key in POST body: key=<LedgerKey in base64 "
+            "XDR format>");
+    }
+
+    auto& hotBL = mHotArchiveBucketListSnapshots.at(std::this_thread::get_id());
+    xdr::xvector<ArchivalProof> proof;
+    for (auto const& key : keys)
+    {
+        LedgerKey lk;
+        fromOpaqueBase64(lk, key);
+        if (!isPersistentEntry(lk) || lk.type() != CONTRACT_DATA)
+        {
+            throw std::invalid_argument("Only persistent contract data entries "
+                                        "require creation proofs");
+        }
+
+        if (!addCreationProof(mSimulateFilterMiss, lk, proof))
+        {
+            throw std::invalid_argument("No valid proof exists for key");
+        }
+    }
+
+    root["ledger"] = snapshotLedger ? *snapshotLedger : hotBL->getLedgerSeq();
+    root["proof"] = toOpaqueBase64(proof);
+
+    retStr = Json::FastWriter().write(root);
+    return true;
+}
 }
diff --git a/src/main/QueryServer.h b/src/main/QueryServer.h
@@ -59,6 +59,15 @@ class QueryServer
     bool getLedgerEntry(std::string const& params, std::string const& body,
                         std::string& retStr);
 
+    // Returns restoration/creation proofs for the given set of keys.
+    bool getRestoreProof(std::string const& params, std::string const& body,
+                         std::string& retStr);
+
+    // Test string for artificial miss:
+    // AAAABgAAAAEBuCkP1Jtb0TMPDqcYvepnKTIGIPZc4adjZXxXY4xYCwAAAA8AAAAEbWlzcwAAAAE=
+    bool getCreationProof(std::string const& params, std::string const& body,
+                          std::string& retStr);
+
   public:
     QueryServer(const std::string& address, unsigned short port, int maxClient,
                 size_t threadPoolSize,
diff --git a/src/transactions/test/InvokeHostFunctionTests.cpp b/src/transactions/test/InvokeHostFunctionTests.cpp
@@ -2993,7 +2993,7 @@ TEST_CASE("evicted persistent entries"
             xdr::xvector<ArchivalProof> proofs;
             auto wrongLk = client.getContract().getDataKey(
                 makeSymbolSCVal("null"), ContractDataDurability::PERSISTENT);
-            REQUIRE(!addRestorationProof(test.getApp(), wrongLk, proofs));
+            REQUIRE(!addRestorationProof(hotArchive, wrongLk, proofs));
 
             // RestoreOp should fail with no proof/ empty proof
             SorobanResources restoreResources;
@@ -3015,7 +3015,7 @@ TEST_CASE("evicted persistent entries"
                         .restoreFootprintResult()
                         .code() == RESTORE_FOOTPRINT_MALFORMED);
 
-            REQUIRE(addRestorationProof(test.getApp(), lk, proofs));
+            REQUIRE(addRestorationProof(hotArchive, lk, proofs));
 
             // Should succeed after adding proper proofs
             test.invokeRestoreOp({lk}, expectedRefundableFeeCharged, proofs);
@@ -3084,7 +3084,7 @@ TEST_CASE("persistent entry archival filters", "[soroban][archival]")
 
     xdr::xvector<ArchivalProof> proofs;
     addCreationProof(
-        test.getApp(),
+        cfg.ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS,
         client.getContract().getDataKey(makeSymbolSCVal("miss"),
                                         ContractDataDurability::PERSISTENT),
         proofs);
diff --git a/src/util/ArchivalProofs.cpp b/src/util/ArchivalProofs.cpp
@@ -12,6 +12,9 @@
 #include "util/UnorderedSet.h"
 #include "xdr/Stellar-ledger-entries.h"
 #include "xdr/Stellar-transaction.h"
+#include <memory>
+#include <optional>
+#include <stdexcept>
 
 namespace stellar
 {
@@ -100,43 +103,43 @@ isCreatedKeyProven(Application& app, LedgerKey const& lk,
 }
 
 bool
-addCreationProof(Application& app, LedgerKey const& lk,
+addCreationProof(bool simulateBloomMiss, LedgerKey const& lk,
                  xdr::xvector<ArchivalProof>& proofs)
 {
 #ifdef BUILD_TESTS
-    // For now only support proof generation for testing
-    releaseAssertOrThrow(
-        app.getConfig().ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS);
-
-    // Only persistent contract data entries need creation proofs
-    if (lk.type() != CONTRACT_DATA ||
-        lk.contractData().durability != PERSISTENT)
+    if (simulateBloomMiss)
     {
-        return true;
-    }
+        // Only persistent contract data entries need creation proofs
+        if (lk.type() != CONTRACT_DATA ||
+            lk.contractData().durability != PERSISTENT)
+        {
+            return true;
+        }
 
-    for (auto& proof : proofs)
-    {
-        if (proof.body.t() == NONEXISTENCE)
+        for (auto& proof : proofs)
         {
-            for (auto const& key : proof.body.nonexistenceProof().keysToProve)
+            if (proof.body.t() == NONEXISTENCE)
             {
-                if (key == lk)
+                for (auto const& key :
+                     proof.body.nonexistenceProof().keysToProve)
                 {
-                    // Proof already exists
-                    return true;
+                    if (key == lk)
+                    {
+                        // Proof already exists
+                        return true;
+                    }
                 }
-            }
 
-            proof.body.nonexistenceProof().keysToProve.push_back(lk);
-            return true;
+                proof.body.nonexistenceProof().keysToProve.push_back(lk);
+                return true;
+            }
         }
-    }
 
-    proofs.emplace_back();
-    auto& nonexistenceProof = proofs.back();
-    nonexistenceProof.body.t(NONEXISTENCE);
-    nonexistenceProof.body.nonexistenceProof().keysToProve.push_back(lk);
+        proofs.emplace_back();
+        auto& nonexistenceProof = proofs.back();
+        nonexistenceProof.body.t(NONEXISTENCE);
+        nonexistenceProof.body.nonexistenceProof().keysToProve.push_back(lk);
+    }
 #endif
 
     return true;
@@ -238,18 +241,32 @@ getRestoredEntryFromProof(Application& app, LedgerKey const& lk,
 }
 
 bool
-addRestorationProof(Application& app, LedgerKey const& lk,
-                    xdr::xvector<ArchivalProof>& proofs)
+addRestorationProof(
+    std::shared_ptr<SearchableHotArchiveBucketListSnapshot> hotArchive,
+    LedgerKey const& lk, xdr::xvector<ArchivalProof>& proofs,
+    std::optional<uint32_t> ledgerSeq)
 {
 #ifdef BUILD_TESTS
     // For now only support proof generation for testing
-    releaseAssertOrThrow(
-        app.getConfig().REQUIRE_PROOFS_FOR_ALL_EVICTED_ENTRIES);
     releaseAssertOrThrow(isPersistentEntry(lk));
 
-    auto hotBL =
-        app.getBucketManager().getSearchableHotArchiveBucketListSnapshot();
-    auto entry = hotBL->load(lk);
+    std::shared_ptr<HotArchiveBucketEntry> entry = nullptr;
+    if (ledgerSeq)
+    {
+        auto entryOp = hotArchive->loadKeysFromLedger({lk}, *ledgerSeq);
+        if (!entryOp)
+        {
+            throw std::invalid_argument("LedgerSeq not found");
+        }
+
+        entry =
+            std::make_shared<HotArchiveBucketEntry>(std::move(entryOp->at(0)));
+    }
+    else
+    {
+        entry = hotArchive->load(lk);
+    }
+
     if (!entry ||
         entry->type() != HotArchiveBucketEntryType::HOT_ARCHIVE_ARCHIVED)
     {
diff --git a/src/util/ArchivalProofs.h b/src/util/ArchivalProofs.h
@@ -7,10 +7,13 @@
 #include "xdr/Stellar-transaction.h"
 #include <xdrpp/types.h>
 
+#include <optional>
+
 namespace stellar
 {
 
 class Application;
+class SearchableHotArchiveBucketListSnapshot;
 
 // Returns true if the proof structure is valid. This function does not check
 // the validity of the proof itself, just that the structure is correct (i.e. no
@@ -26,7 +29,7 @@ bool isCreatedKeyProven(Application& app, LedgerKey const& lk,
 
 // Adds a creation proof for lk to proofs. Returns true if a proof was added or
 // is not necessary. Returns false if no valid proof exists.
-bool addCreationProof(Application& app, LedgerKey const& lk,
+bool addCreationProof(bool simulateBloomMiss, LedgerKey const& lk,
                       xdr::xvector<ArchivalProof>& proofs);
 
 // Returns true if the proof structure is valid. This function does not check
@@ -47,6 +50,11 @@ getRestoredEntryFromProof(Application& app, LedgerKey const& lk,
 
 // Adds a restoration proof for lk to proofs. Returns true if a proof was added
 // or is not necessary. Returns false if no valid proof exists.
-bool addRestorationProof(Application& app, LedgerKey const& lk,
-                         xdr::xvector<ArchivalProof>& proofs);
+// If ledgerSeq is specified, the entry will be restored based on the snapshot
+// at that ledger. TODO: Fix race condition when ledgerSeq is populated by
+// loading keys in batches.
+bool addRestorationProof(
+    std::shared_ptr<SearchableHotArchiveBucketListSnapshot> hotArchive,
+    LedgerKey const& lk, xdr::xvector<ArchivalProof>& proofs,
+    std::optional<uint32_t> ledgerSeq = std::nullopt);
 }
diff --git a/src/util/test/ArchivalProofsTests.cpp b/src/util/test/ArchivalProofsTests.cpp
@@ -51,7 +51,9 @@ TEST_CASE("creation proofs", "[archival][soroban]")
         // Empty proof fails
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(!isCreatedKeyProven(*app, LedgerEntryKey(entries[0]), proofs));
-        REQUIRE(addCreationProof(*app, LedgerEntryKey(entries[0]), proofs));
+        REQUIRE(addCreationProof(
+            app->getConfig().ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS,
+            LedgerEntryKey(entries[0]), proofs));
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(isCreatedKeyProven(*app, LedgerEntryKey(entries[0]), proofs));
 
@@ -63,7 +65,9 @@ TEST_CASE("creation proofs", "[archival][soroban]")
         REQUIRE(!isCreatedKeyProven(*app, LedgerEntryKey(entries[1]), proofs));
 
         // Proofs work for multiple keys
-        REQUIRE(addCreationProof(*app, LedgerEntryKey(entries[1]), proofs));
+        REQUIRE(addCreationProof(
+            app->getConfig().ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS,
+            LedgerEntryKey(entries[1]), proofs));
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(isCreatedKeyProven(*app, LedgerEntryKey(entries[1]), proofs));
         REQUIRE(isCreatedKeyProven(*app, LedgerEntryKey(entries[0]), proofs));
@@ -84,12 +88,16 @@ TEST_CASE("creation proofs", "[archival][soroban]")
 
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(isCreatedKeyProven(*app, LedgerEntryKey(temp), proofs));
-        REQUIRE(addCreationProof(*app, LedgerEntryKey(temp), proofs));
+        REQUIRE(addCreationProof(
+            app->getConfig().ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS,
+            LedgerEntryKey(temp), proofs));
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(proofs.size() == 0);
 
         REQUIRE(isCreatedKeyProven(*app, LedgerEntryKey(code), proofs));
-        REQUIRE(addCreationProof(*app, LedgerEntryKey(code), proofs));
+        REQUIRE(addCreationProof(
+            app->getConfig().ARTIFICIALLY_SIMULATE_ARCHIVE_FILTER_MISS,
+            LedgerEntryKey(code), proofs));
         REQUIRE(checkCreationProofValidity(proofs));
         REQUIRE(proofs.size() == 0);
     }
