src/spark/state.h (2)

240-241: Add thread-safety note for accessor.

GetSpendsMobile() exposes internal state; callers must hold cs_main while accessing/copying to avoid races. Please add a brief comment mirroring other getters.

---

267-269: Consider determinism and removal cost trade-offs.

Storing a second structure is fine for mobile, but be aware:

• Order depends on insertion sites; ensure upstream insertion order is deterministic network-wide.
• RemoveSpend is O(N). Acceptable for rare reorgs; otherwise consider an index map for O(1) removal.

src/rpc/misc.cpp (2)

1551-1559: Ordering semantics: ensure network-wide determinism.

startNumber assumes a stable, globally consistent order. With a vector this is insertion order; verify upstream insertion is deterministic across nodes, or sort by a canonical key (e.g., primitives::GetLTagHash). See suggestion on ConnectBlockSpark.

---

1590-1616: Unify with mobile ordering in tags+txids RPC.

getusedcoinstagstxhashes still uses GetSpends() (unordered_map) with startNumber filtering, which is non-deterministic. Use GetSpendsMobile() and guard with -mobile for consistency.

-    std::unordered_map<GroupElement, int, spark::CLTagHash>  tags;
+    std::vector<std::pair<GroupElement, int>>  tags;
     std::unordered_map<uint256, uint256> ltagTxhash;
     {
         LOCK(cs_main);
-        tags = sparkState->GetSpends();
+        if (!GetBoolArg("-mobile", false)) {
+            throw std::runtime_error(std::string("Please rerun Firo with -mobile "));
+        }
+        tags = sparkState->GetSpendsMobile();
         ltagTxhash = sparkState->GetSpendTxIds();
     }
-    int i = 0;
-    for ( auto it = tags.begin(); it != tags.end(); ++it, ++i) {
+    int i = 0;
+    for (auto it = tags.begin(); it != tags.end(); ++it, ++i) {
         if (cmp::less((tags.size() - i - 1), startNumber))
             continue;
         std::vector<unsigned char> serialized;
         serialized.resize(34);
-        it->first.serialize(serialized.data());
+        it->first.serialize(serialized.data());
         std::vector<UniValue> data;
         data.push_back(EncodeBase64(serialized.data(), 34));
         uint256 txid;
-        uint256 ltagHash = primitives::GetLTagHash(it->first);
+        uint256 ltagHash = primitives::GetLTagHash(it->first);
         if (ltagTxhash.count(ltagHash) > 0)
             txid = ltagTxhash[ltagHash];
         data.push_back(EncodeBase64(txid.begin(), txid.size()));
         UniValue entity(UniValue::VARR);
         entity.push_backV(data);
         serializedTagsTxIds.push_back(entity);
     }

src/spark/state.cpp (2)

1093-1101: Make insertion order deterministic across nodes.

mobileUsedLTags preserves insertion order, but AddSpend() is fed from pblock->sparkTxInfo->spentLTags, which is an unordered_map. Within a block with multiple spends, iteration order may differ by platform/build, breaking clients that rely on startNumber.

Sort the per-block spends in ConnectBlockSpark before calling AddSpend():

-            BOOST_FOREACH (auto& lTag, pblock->sparkTxInfo->spentLTags) {
-                pindexNew->spentLTags.insert(lTag);
-                sparkState.AddSpend(lTag.first, lTag.second);
-            }
+            // Ensure deterministic order for downstream mobile sync
+            std::vector<std::pair<GroupElement,int>> orderedSpends(
+                pblock->sparkTxInfo->spentLTags.begin(), pblock->sparkTxInfo->spentLTags.end());
+            std::sort(orderedSpends.begin(), orderedSpends.end(),
+                      [](auto const& a, auto const& b){
+                          return primitives::GetLTagHash(a.first) < primitives::GetLTagHash(b.first);
+                      });
+            for (auto const& lTag : orderedSpends) {
+                pindexNew->spentLTags.insert(lTag);
+                sparkState.AddSpend(lTag.first, lTag.second);
+            }

Add at file top if needed:

+#include <algorithm>

---

1108-1115: Prefer erase-remove to avoid iterator invalidation and remove duplicates if any.

Current loop erases the first match; use erase-remove for clarity and safety.

-    if (GetBoolArg("-mobile", false)) {
-        for (auto tag = mobileUsedLTags.begin(); tag != mobileUsedLTags.end(); tag++) {
-            if (tag->first == lTag) {
-                mobileUsedLTags.erase(tag);
-                break;
-            }
-        }
-    }
+    if (GetBoolArg("-mobile", false)) {
+        mobileUsedLTags.erase(
+            std::remove_if(mobileUsedLTags.begin(), mobileUsedLTags.end(),
+                           [&](const std::pair<GroupElement,int>& p){ return p.first == lTag; }),
+            mobileUsedLTags.end());
+    }

And include:

+#include <algorithm>

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro