implement another layer of cache for query smart contract

Author: krypdkat

GlobalVar.h

@@ -87,6 +87,8 @@ struct GlobalState {
     bool allowCheckInQubicGlobal = true;
 
     std::atomic_bool gStopFlag;
+
+    TimedCacheMap<>* TCM;
 };
 
 // Safe, lazy singleton accessor avoids static init order issues.

RESTAPI/ApiHelpers.cpp

@@ -362,21 +362,70 @@ static bool parseHexInput(const std::string& inputDataHex, std::vector<uint8_t>&
     return true;
 }
 
-SmartContractQueryResult checkSmartContractResult(uint32_t nonce) {
+m256i makeHashQuerySC(uint32_t scIndex, uint32_t funcNumber, const std::string& inputDataHex)
+{
+    m256i digest{};
+    std::vector<uint8_t> nonceData;
+    nonceData.reserve(sizeof(uint32_t) * 2 + inputDataHex.size());
+
+    // Append scIndex and funcNumber
+    nonceData.insert(nonceData.end(),
+                     reinterpret_cast<uint8_t *>(&scIndex),
+                     reinterpret_cast<uint8_t *>(&scIndex) + sizeof(uint32_t));
+    nonceData.insert(nonceData.end(),
+                     reinterpret_cast<uint8_t *>(&funcNumber),
+                     reinterpret_cast<uint8_t *>(&funcNumber) + sizeof(uint32_t));
+
+    // Append input hex data
+    nonceData.insert(nonceData.end(), inputDataHex.begin(), inputDataHex.end());
+
+    // Calculate K12 hash
+    KangarooTwelve(nonceData.data(), nonceData.size(), digest.m256i_u8, 32);
+    return digest;
+}
+
+SmartContractQueryResult checkSmartContractResult(uint32_t nonce, uint32_t scIndex,
+                                                  uint32_t funcNumber, const std::string& inputDataHex)
+{
     SmartContractQueryResult result;
     result.nonce = nonce;
 
     std::vector<uint8_t> out;
     if (responseSCData.get(nonce, out)) {
         result.success = true;
         result.data = bytesToHex(out.data(), out.size());
+
+        m256i hash = ApiHelpers::makeHashQuerySC(scIndex, funcNumber, inputDataHex);
+        gTCM->add(hash, out);
     } else {
         result.pending = true;
     }
 
     return result;
 }
 
+// Non-blocking enqueue: send a SC query and return immediately
+bool enqueueSmartContractRequest(uint32_t nonce, uint32_t scIndex, uint32_t funcNumber, const uint8_t* data, uint32_t dataSize)
+{
+    std::vector<uint8_t> vdata(dataSize + sizeof(RequestContractFunction) + sizeof(RequestResponseHeader));
+    RequestContractFunction rcf{};
+    rcf.contractIndex = scIndex;
+    rcf.inputSize = dataSize;
+    rcf.inputType = funcNumber;
+
+    auto header = (RequestResponseHeader*)vdata.data();
+    header->setType(RequestContractFunction::type);
+    header->setSize(dataSize + sizeof(RequestResponseHeader) + sizeof(RequestContractFunction));
+    header->setDejavu(nonce);
+
+    memcpy(vdata.data() + sizeof(RequestResponseHeader), &rcf, sizeof(RequestResponseHeader));
+    if (dataSize)
+        memcpy(vdata.data() + sizeof(RequestResponseHeader) + sizeof(RequestContractFunction), data, dataSize);
+
+    // fire-and-forget to SC thread
+    return MRB_SC.EnqueuePacket(vdata.data());
+}
+
 SmartContractQueryResult querySmartContract(uint32_t nonce, uint32_t scIndex,
                                              uint32_t funcNumber, const std::string& inputDataHex) {
     SmartContractQueryResult result;
@@ -396,6 +445,18 @@ SmartContractQueryResult querySmartContract(uint32_t nonce, uint32_t scIndex,
         return result;
     }
 
+    // cache level 2
+    {
+        m256i digest{};
+        digest = makeHashQuerySC(scIndex, funcNumber, inputDataHex);
+        if (gTCM->tryGet(digest, out))
+        {
+            result.success = true;
+            result.data = bytesToHex(out.data(), out.size());
+            return result;
+        }
+    }
+
     // Parse input data
     std::vector<uint8_t> dataBytes;
     if (!parseHexInput(inputDataHex, dataBytes, result.error)) {

RESTAPI/ApiHelpers.h

@@ -135,8 +135,11 @@ SmartContractQueryResult querySmartContract(uint32_t nonce, uint32_t scIndex,
 // Check if a smart contract query result is available (by nonce)
 // @param nonce: unique identifier for the query
 // @return SmartContractQueryResult with response data if available
-SmartContractQueryResult checkSmartContractResult(uint32_t nonce);
+SmartContractQueryResult checkSmartContractResult(uint32_t nonce, uint32_t scIndex,
+                                                  uint32_t funcNumber, const std::string& inputDataHex);
 
+// @return K12 of scIndex funcNumber and inputDataHex
+m256i makeHashQuerySC(uint32_t scIndex, uint32_t funcNumber, const std::string& inputDataHex);
 // ============================================================================
 // Utility Functions
 // ============================================================================

RESTAPI/RESTServer.cpp

@@ -559,9 +559,9 @@ namespace {
         auto pollResultPtr = std::make_shared<std::function<void()>>();
         std::weak_ptr<std::function<void()>> pollResultWeak = pollResultPtr;
 
-        *pollResultPtr = [nonce, sharedCallback, attemptCount, startTime, loop, pollResultWeak]() {
+        *pollResultPtr = [nonce, sharedCallback, attemptCount, startTime, loop, pollResultWeak, scIndex, funcNumber, data]() {
             // Check for result using shared helper
-            SmartContractQueryResult result = ApiHelpers::checkSmartContractResult(nonce);
+            SmartContractQueryResult result = ApiHelpers::checkSmartContractResult(nonce, scIndex, funcNumber, data);
 
             if (result.success) {
                 Json::Value root;

RESTAPI/bobAPI.cpp

@@ -21,28 +21,6 @@ static std::string toHex(const std::vector<uint8_t>& data) {
     return ss.str();
 }
 
-// Non-blocking enqueue: send a SC query and return immediately
-bool enqueueSmartContractRequest(uint32_t nonce, uint32_t scIndex, uint32_t funcNumber, const uint8_t* data, uint32_t dataSize)
-{
-    std::vector<uint8_t> vdata(dataSize + sizeof(RequestContractFunction) + sizeof(RequestResponseHeader));
-    RequestContractFunction rcf{};
-    rcf.contractIndex = scIndex;
-    rcf.inputSize = dataSize;
-    rcf.inputType = funcNumber;
-
-    auto header = (RequestResponseHeader*)vdata.data();
-    header->setType(RequestContractFunction::type);
-    header->setSize(dataSize + sizeof(RequestResponseHeader) + sizeof(RequestContractFunction));
-    header->setDejavu(nonce);
-
-    memcpy(vdata.data() + sizeof(RequestResponseHeader), &rcf, sizeof(RequestResponseHeader));
-    if (dataSize)
-        memcpy(vdata.data() + sizeof(RequestResponseHeader) + sizeof(RequestContractFunction), data, dataSize);
-
-    // fire-and-forget to SC thread
-    return MRB_SC.EnqueuePacket(vdata.data());
-}
-
 std::string bobGetBalance(const char* identity)
 {
     if (!identity) return "{\"error\": \"Wrong identity format\"}";
@@ -543,49 +521,6 @@ std::string bobGetStatus()
            "}";
 }
 
-std::string querySmartContract(uint32_t nonce, uint32_t scIndex, uint32_t funcNumber, uint8_t* data, uint32_t dataSize)
-{
-    // Preserve existing sync API for backwards compatibility,
-    // but avoid blocking the thread for long: do a single immediate check, else enqueue and return pending.
-    std::vector<uint8_t> dataOut;
-    Json::Value root;
-
-    if (responseSCData.get(nonce, dataOut)) {
-        root["nonce"] = nonce;
-        root["data"] = toHex(dataOut);
-    } else {
-        enqueueSmartContractRequest(nonce, scIndex, funcNumber, data, dataSize);
-        root["error"] = "pending";
-        root["message"] = "Query enqueued; try again shortly with the same nonce";
-    }
-
-    Json::FastWriter writer;
-    return writer.write(root);
-}
-
-
-std::string broadcastTransaction(uint8_t* txDataWithHeader, int size)
-{
-    auto tx = (Transaction*)(txDataWithHeader+sizeof(RequestResponseHeader));
-    if (tx->inputSize + sizeof(Transaction) + sizeof(RequestResponseHeader) + SIGNATURE_SIZE != size)
-    {
-        return "{\"error\": \"Invalid size\"}";
-    }
-    m256i digest{};
-    uint8_t* signature = txDataWithHeader + sizeof(RequestResponseHeader) + sizeof(Transaction) + tx->inputSize;
-    KangarooTwelve(reinterpret_cast<const uint8_t *>(tx), size - sizeof(RequestResponseHeader) - SIGNATURE_SIZE, digest.m256i_u8, 32);
-    if (!verify(tx->sourcePublicKey, digest.m256i_u8, signature))
-    {
-        return "{\"error\": \"Invalid signature\"}";
-    }
-    MRB_SC.EnqueuePacket(txDataWithHeader);
-    KangarooTwelve(reinterpret_cast<const uint8_t *>(tx), size - sizeof(RequestResponseHeader), digest.m256i_u8, 32);
-    char hash[64]={0};
-    getIdentityFromPublicKey(digest.m256i_u8, hash, true);
-    std::string txHash(hash);
-    return "{\"txHash\": \"" + txHash + "\"}";
-}
-
 std::string bobGetEpochInfo(uint16_t epoch)
 {
     auto info = ApiHelpers::getEpochInfo(epoch);

SpecialBufferStructs.h

@@ -215,7 +215,11 @@ class TimedCacheMap {
      */
     void add(m256i key, std::vector<uint8_t> value) {
         std::lock_guard<std::mutex> lock(mtx_);
-
+        if (data_map_.find(key) != data_map_.end())
+        {
+            // already exist
+            return;
+        }
         // If at capacity and key doesn't exist, remove oldest
         if (data_map_.size() >= L && data_map_.find(key) == data_map_.end()) {
             remove_oldest();
@@ -255,7 +259,7 @@ class TimedCacheMap {
      * @param sz Reference to int that will contain the size (will be set to 0 if not found)
      * @return true if key was found and data copied, false otherwise
      */
-    bool tryGet(m256i key, uint8_t*& ptr, int& sz) {
+    bool tryGetRaw(m256i key, uint8_t*& ptr, int& sz) {
         std::lock_guard<std::mutex> lock(mtx_);
 
         auto it = data_map_.find(key);
@@ -281,6 +285,26 @@ class TimedCacheMap {
         return false;
     }
 
+    /**
+     * @brief Tries to retrieve a value from the cache into a vector.
+     * @param key The m256i key to search for
+     * @param value Reference to vector that will be populated with the data
+     * @return true if key was found and data copied, false otherwise
+     */
+    bool tryGet(m256i key, std::vector<uint8_t>& value) {
+        std::lock_guard<std::mutex> lock(mtx_);
+
+        auto it = data_map_.find(key);
+        if (it == data_map_.end()) {
+            value.clear();
+            return false;
+        }
+
+        value = it->second.data;
+        return true;
+    }
+
+
     /**
      * @brief Returns the current number of elements in the cache.
      */

bob.cpp

@@ -230,6 +230,7 @@ int runBob(int argc, char *argv[])
         set_this_thread_name("indexer");
         indexVerifiedTicks();
     });
+    gTCM = new TimedCacheMap<>();
     auto sc_thread = std::thread([&](){
         set_this_thread_name("sc");
         querySmartContractThread(connPool);
@@ -359,7 +360,11 @@ int runBob(int argc, char *argv[])
     Logger::get()->info("Exited LogEventRequestTrustedNodes thread");
     indexer_thread.join();
     Logger::get()->info("Exited indexer thread");
+
     sc_thread.join();
+    delete gTCM;
+    Logger::get()->info("Exited SC thread");
+
     if (log_event_verifier_thread.joinable())
     {
         log_event_verifier_thread.join();

shim.h

@@ -59,3 +59,4 @@
 #define gStopFlag (GS().gStopFlag)
 #define gStartTimeUnix (GS().startTimeUnix)
 #define gAllowCheckInQubicGlobal (GS().allowCheckInQubicGlobal)
+#define gTCM (GS().TCM)