Fix some Lint/CI-related things

Signed-off-by: Sam Stuewe <[email protected]>

src/uhs/atomizer/sentinel/controller.hpp

@@ -8,15 +8,14 @@
 
 #include "server.hpp"
 #include "uhs/sentinel/interface.hpp"
+#include "uhs/transaction/transaction.hpp"
 #include "util/common/config.hpp"
 #include "util/network/connection_manager.hpp"
-#include "uhs/transaction/transaction.hpp"
 
+#include <memory>
 #include <secp256k1.h>
 #include <secp256k1_bulletproofs.h>
 
-#include <memory>
-
 namespace cbdc::sentinel {
     /// Sentinel implementation.
     class controller : public interface {

src/uhs/atomizer/shard/shard.cpp

@@ -67,24 +67,30 @@ namespace cbdc::shard {
             for(const auto& out : tx.m_outputs) {
                 if(is_output_on_shard(out.m_id)) {
                     std::array<char, sizeof(out.m_id)> out_arr{};
-                    std::memcpy(out_arr.data(), out.m_id.data(), out.m_id.size());
-                    leveldb::Slice OutPointKey(out_arr.data(), out.m_id.size());
-
-                    std::array<char, sizeof(out.m_auxiliary) +
-                                     sizeof(out.m_range) +
-                                     sizeof(out.m_consistency)> proofs_arr{};
-                    auto pptr = proofs_arr.data();
-
-                    std::memcpy(pptr, out.m_auxiliary.data(),
-                        out.m_auxiliary.size());
-                    pptr += out.m_auxiliary.size();
-                    std::memcpy(pptr, out.m_range.data(), out.m_range.size());
-                    pptr += out.m_range.size();
-                    std::memcpy(pptr, out.m_consistency.data(),
-                        out.m_consistency.size());
+                    std::memcpy(out_arr.data(),
+                                out.m_id.data(),
+                                out.m_id.size());
+                    leveldb::Slice OutPointKey(out_arr.data(),
+                                               out.m_id.size());
+
+                    static constexpr auto aux_size = sizeof(out.m_auxiliary);
+                    static constexpr auto rng_size = sizeof(out.m_range);
+                    static constexpr auto cst_size = sizeof(out.m_consistency);
+
+                    std::array<char, aux_size + rng_size + cst_size>
+                        proofs_arr{};
+                    std::memcpy(proofs_arr.data(),
+                                out.m_auxiliary.data(),
+                                aux_size);
+                    std::memcpy(proofs_arr.data() + aux_size,
+                                out.m_range.data(),
+                                out.m_range.size());
+                    std::memcpy(proofs_arr.data() + aux_size + rng_size,
+                                out.m_consistency.data(),
+                                cst_size);
 
                     leveldb::Slice ProofVal(proofs_arr.data(),
-                        proofs_arr.size());
+                                            proofs_arr.size());
                     batch.Put(OutPointKey, ProofVal);
                 }
             }

src/uhs/client/atomizer_client.cpp

@@ -52,7 +52,7 @@ namespace cbdc {
                            ctx.m_outputs.end(),
                            std::back_inserter(uhs_ids),
                            [](transaction::compact_output p) -> hash_t {
-                            return p.m_id;
+                               return p.m_id;
                            });
             it->second.insert(it->second.end(),
                               uhs_ids.begin(),

src/uhs/client/client.hpp

@@ -310,18 +310,25 @@ namespace cbdc {
                    &secp256k1_context_destroy};
 
         struct GensDeleter {
-            GensDeleter(secp256k1_context* ctx) : m_ctx(ctx) {}
+            explicit GensDeleter(secp256k1_context* ctx) : m_ctx(ctx) {}
 
-            void operator()(secp256k1_bulletproofs_generators* gens) {
+            void operator()(secp256k1_bulletproofs_generators* gens) const {
                 secp256k1_bulletproofs_generators_destroy(m_ctx, gens);
             }
 
             secp256k1_context* m_ctx;
         };
 
+        /// should be twice the bitcount of the range-proof's upper bound
+        ///
+        /// e.g., if proving things in the range [0, 2^64-1], it should be 128.
+        static const inline auto generator_count = 129;
+
         std::unique_ptr<secp256k1_bulletproofs_generators, GensDeleter>
-            m_generators{secp256k1_bulletproofs_generators_create(m_secp.get(),
-                128), GensDeleter(m_secp.get())};
+            m_generators{
+                secp256k1_bulletproofs_generators_create(m_secp.get(),
+                                                         generator_count),
+                GensDeleter(m_secp.get())};
     };
 }
 

src/uhs/transaction/messages.cpp

@@ -23,8 +23,8 @@ namespace cbdc {
     auto operator<<(serializer& packet, const transaction::output& out)
         -> serializer& {
         return packet << out.m_witness_program_commitment << out.m_id
-            << out.m_nonce << out.m_auxiliary << out.m_range
-            << out.m_consistency;
+                      << out.m_nonce << out.m_auxiliary << out.m_range
+                      << out.m_consistency;
     }
 
     auto operator>>(serializer& packet, transaction::output& out)
@@ -37,7 +37,7 @@ namespace cbdc {
     auto operator<<(serializer& packet, const transaction::compact_output& out)
         -> serializer& {
         return packet << out.m_id << out.m_auxiliary << out.m_range
-            << out.m_consistency;
+                      << out.m_consistency;
     }
 
     auto operator>>(serializer& packet, transaction::compact_output& out)
@@ -59,7 +59,7 @@ namespace cbdc {
     auto operator<<(serializer& packet, const transaction::input& inp)
         -> serializer& {
         return packet << inp.m_prevout << inp.m_prevout_data
-            << inp.m_spend_data;
+                      << inp.m_spend_data;
     }
 
     auto operator>>(serializer& packet, transaction::input& inp)
@@ -71,7 +71,7 @@ namespace cbdc {
     auto operator<<(serializer& packet, const transaction::full_tx& tx)
         -> serializer& {
         return packet << tx.m_inputs << tx.m_outputs << tx.m_witness
-            << tx.m_tx_proofs << tx.m_out_spend_data;
+                      << tx.m_tx_proofs << tx.m_out_spend_data;
     }
 
     auto operator>>(serializer& packet, transaction::full_tx& tx)
@@ -81,12 +81,13 @@ namespace cbdc {
     }
 
     auto operator<<(serializer& packet,
-        const transaction::transaction_proof& proof) -> serializer& {
+                    const transaction::transaction_proof& proof)
+        -> serializer& {
         return packet << proof.m_noncesigs;
     }
 
-    auto operator>>(serializer& packet,
-        transaction::transaction_proof& proof) -> serializer& {
+    auto operator>>(serializer& packet, transaction::transaction_proof& proof)
+        -> serializer& {
         return packet >> proof.m_noncesigs;
     }
 

src/uhs/transaction/messages.hpp

@@ -102,14 +102,15 @@ namespace cbdc {
     /// \see \ref cbdc::operator<<(serializer&, const std::array<T, len>&)
     /// \see \ref cbdc::operator<<(serializer&, const std::vector<T>&)
     auto operator<<(serializer& packet,
-        const transaction::transaction_proof& proof) -> serializer&;
+                    const transaction::transaction_proof& proof)
+        -> serializer&;
 
     /// \brief Deserializes transaction-wide cryptographic proofs
     ///
     /// Deserializes the vector of signatures on the UHS-ID compression nonces.
     /// \see \ref cbdc::operator<<(serializer&, const transaction::transaction_proof&)
-    auto operator>>(serializer& packet,
-        transaction::transaction_proof& proof) -> serializer&;
+    auto operator>>(serializer& packet, transaction::transaction_proof& proof)
+        -> serializer&;
 
     /// \brief Serializes a compact transaction.
     ///