swiftsync: Add hintfile reading

Author: rustaceanrob

src/swiftsync.cpp

@@ -1,8 +1,13 @@
 #include <array>
+#include <cstddef>
+#include <cstdint>
 #include <primitives/transaction.h>
 #include <random.h>
+#include <serialize.h>
+#include <streams.h>
 #include <swiftsync.h>
 #include <uint256.h>
+#include <vector>
 
 Aggregate::Aggregate() : m_limb0(0), m_limb1(0), m_limb2(0), m_limb3(0)
 {
@@ -23,3 +28,59 @@ void Aggregate::Spend(const COutPoint& outpoint)
     auto a0 = (HashWriter(m_salted_hasher) << outpoint).GetSHA256().GetUint64(0);
     m_limb0 -= a0;
 }
+
+Hintfile::Hintfile(AutoFile file) : m_file(file.release())
+{
+    uint256 m_stop_hash;
+    uint32_t m_stop_height;
+    m_file >> m_stop_height;
+    m_file >> m_stop_hash;
+    m_curr_height = 0;
+}
+
+Hintfile::Hintfile(AutoFile file, const uint256& stop_hash, const uint32_t& stop_height) : m_file(file.release())
+{
+    m_file << stop_height;
+    m_file << stop_hash;
+    m_curr_height = 0;
+}
+
+BlockUnspentHints::BlockUnspentHints(const std::vector<uint64_t> offsets)
+{
+    // Assuming a vector of ordered offsets is given, unpack into the literal indexes.
+    std::vector<uint64_t> m_unspent_indexes;
+    uint64_t prev = 0;
+    for (const auto& offset : offsets) {
+        auto next = prev + offset;
+        m_unspent_indexes.push_back(next);
+        prev = next;
+    }
+}
+
+bool BlockUnspentHints::IsUnspent(const uint64_t index)
+{
+    auto found = std::find(m_unspent_indexes.begin(), m_unspent_indexes.end(), index);
+    return found != m_unspent_indexes.end();
+}
+
+BlockUnspentHints Hintfile::ReadNextBlock()
+{
+    m_curr_height++;
+    uint64_t num_unspent = ReadCompactSize(m_file);
+    std::vector<uint64_t> offsets;
+    offsets.reserve(num_unspent);
+    for (uint64_t i = 0; i < num_unspent; i++) {
+        offsets.push_back(ReadCompactSize(m_file));
+    }
+    return BlockUnspentHints(offsets);
+}
+
+bool Hintfile::WriteNextBlock(const std::vector<uint64_t>& unspent_offsets)
+{
+    m_curr_height++;
+    WriteCompactSize(m_file, unspent_offsets.size());
+    for (const auto& offset : unspent_offsets) {
+        WriteCompactSize(m_file, offset);
+    }
+    return m_file.Commit();
+}

src/swiftsync.h

@@ -1,6 +1,9 @@
 #include <cstdint>
 #include <hash.h>
 #include <primitives/transaction.h>
+#include <streams.h>
+#include <uint256.h>
+#include <vector>
 
 /** An aggregate for the SwiftSync protocol.
  * This class is intentionally left opaque, as internal changes may occur,
@@ -23,3 +26,40 @@ class Aggregate
     void Add(const COutPoint& outpoint);
     void Spend(const COutPoint& outpoint);
 };
+
+/**
+ * The unspent indexes of a block, assuming the list of block
+ * outputs has been flattened.
+ * */
+class BlockUnspentHints
+{
+private:
+    std::vector<uint64_t> m_unspent_indexes;
+
+public:
+    BlockUnspentHints(const std::vector<uint64_t> offsets);
+    bool IsUnspent(const uint64_t index);
+};
+
+/**
+ * A file that encodes the UTXO set state at a particular block hash.
+ */
+class Hintfile
+{
+private:
+    AutoFile m_file;
+    uint256 m_stop_hash;
+    uint32_t m_stop_height;
+    uint32_t m_curr_height;
+
+public:
+    // Construct a hint file and immediately read the stop hash and height.
+    Hintfile(AutoFile file);
+    // Construct a hint file and write the stop hash and height.
+    Hintfile(AutoFile file, const uint256& stop_hash, const uint32_t& stop_height);
+    BlockUnspentHints ReadNextBlock();
+    bool WriteNextBlock(const std::vector<uint64_t>& unspent_offsets);
+    uint256 StopHash() { return m_stop_hash; };
+    uint32_t StopHeight() { return m_stop_height; };
+    uint32_t CurrentHeight() { return m_curr_height; };
+};