Linting pass

src/blockchain_db/sqlite/db_sqlite.cpp

@@ -645,11 +645,11 @@ std::vector<cryptonote::batch_sn_payment> BlockchainSQLite::get_sn_payments(uint
         const auto& address = pair.first;
         const auto& amount = pair.second;
         const uint64_t truncated_db_amount =
-                amount / BATCH_REWARD_FACTOR * BATCH_REWARD_FACTOR; // truncate to atomic OXEN
+                amount / BATCH_REWARD_FACTOR * BATCH_REWARD_FACTOR;  // truncate to atomic OXEN
 
         if (pre_hf21_final_payout) {
             log::debug(logcat, "address {} has amount {}", address, amount);
-            if (sent_addr_map.contains(std::string{address})) // Registered for transition
+            if (sent_addr_map.contains(std::string{address}))  // Registered for transition
                 continue;
 
             if (truncated_db_amount > 0) {

src/common/exception.cpp

@@ -2,6 +2,7 @@
 #include "exception.h"
 
 #include <fmt/core.h>
+
 #include <cstdio>
 #include <sstream>
 

src/crypto/crypto.cpp

@@ -755,8 +755,7 @@ bool check_key_image_signature(
     return sc_isnonzero(h.data()) == 0;
 }
 
-secret_key ed25519_to_monero_secret_key(const ed25519_secret_key& skey)
-{
+secret_key ed25519_to_monero_secret_key(const ed25519_secret_key& skey) {
     epee::wipeable_string privkey_signhash;
     privkey_signhash.resize(crypto_hash_sha512_BYTES);
     unsigned char* pk_sh_data = reinterpret_cast<unsigned char*>(privkey_signhash.data());

src/cryptonote_basic/cryptonote_format_utils.h

@@ -298,10 +298,16 @@ constexpr std::string_view get_unit() {
     return "OXEN"sv;
 }
 // Returns a monetary value with a decimal point; optionally strips insignificant trailing 0s.
-std::string print_money(uint64_t amount, size_t decimal_places = oxen::DISPLAY_DECIMAL_POINT, bool strip_zeros = false);
+std::string print_money(
+        uint64_t amount,
+        size_t decimal_places = oxen::DISPLAY_DECIMAL_POINT,
+        bool strip_zeros = false);
 // Returns a formatted monetary value including the unit, e.g. "1.234567 OXEN"; strips
 // insignificant trailing 0s by default (unlike the above) but can be overridden to not do that.
-std::string format_money(uint64_t amount, size_t decimal_places = oxen::DISPLAY_DECIMAL_POINT, bool strip_zeros = true);
+std::string format_money(
+        uint64_t amount,
+        size_t decimal_places = oxen::DISPLAY_DECIMAL_POINT,
+        bool strip_zeros = true);
 
 std::string print_tx_verification_context(
         tx_verification_context const& tvc, transaction const* tx = nullptr);

src/cryptonote_core/blockchain.h

@@ -182,12 +182,7 @@ class Blockchain {
             const cryptonote::test_options& test_options,
             cryptonote::BlockchainSQLite* sqlite_db = nullptr) {
         return init(
-                std::move(db),
-                network_type::FAKECHAIN,
-                nullptr,
-                sqlite_db,
-                nullptr,
-                &test_options);
+                std::move(db), network_type::FAKECHAIN, nullptr, sqlite_db, nullptr, &test_options);
     }
 
     /**

src/cryptonote_core/cryptonote_core.cpp

@@ -66,11 +66,11 @@ extern "C" {
 #include "epee/string_tools.h"
 #include "epee/warnings.h"
 #include "logging/oxen_logger.h"
+#include "network_config/mocknet.h"
 #include "ringct/rctSigs.h"
 #include "ringct/rctTypes.h"
 #include "uptime_proof.h"
 #include "version.h"
-#include "network_config/mocknet.h"
 
 DISABLE_VS_WARNINGS(4355)
 

src/cryptonote_core/pulse.cpp

@@ -8,12 +8,11 @@
 #include "epee/memwipe.h"
 #include "epee/wipeable_string.h"
 #include "ethereum_transactions.h"
+#include "network_config/mocknet.h"
 #include "service_node_list.h"
 #include "service_node_quorum_cop.h"
 #include "service_node_rules.h"
 
-#include "network_config/mocknet.h"
-
 extern "C" {
 #include <sodium/crypto_generichash.h>
 };
@@ -239,7 +238,7 @@ namespace {
     }
 
     std::bitset<sizeof(uint16_t) * 8> bitset_view16(uint16_t val) {
-        std::bitset<sizeof(uint16_t)* 8> result = val;
+        std::bitset<sizeof(uint16_t) * 8> result = val;
         return result;
     }
 

src/cryptonote_core/service_node_list.cpp

@@ -65,19 +65,19 @@
 #include "epee/net/local_ip.h"
 #include "ethereum_transactions.h"
 #include "l2_tracker/events.h"
+#include "network_config/mocknet.h"
 #include "oxen/log.hpp"
 #include "oxen_economy.h"
 #include "pulse.h"
 #include "ringct/rctSigs.h"
 #include "ringct/rctTypes.h"
+#include "sent_transition/sent_transition.h"
 #include "serialization/deque.h"
 #include "serialization/string.h"
-#include "sent_transition/sent_transition.h"
 #include "service_node_quorum_cop.h"
 #include "service_node_rules.h"
 #include "service_node_swarm.h"
 #include "uptime_proof.h"
-#include "network_config/mocknet.h"
 
 using cryptonote::hf;
 namespace feature = cryptonote::feature;
@@ -2559,8 +2559,7 @@ static std::string dump_pulse_block_data(
     return s;
 }
 
-static bool check_pulse_timestamps(cryptonote::network_type nettype, uint64_t height)
-{
+static bool check_pulse_timestamps(cryptonote::network_type nettype, uint64_t height) {
     // TODO(doyle): Core tests don't generate proper timestamps for detecting
     // timeout yet. So we don't do a timeout check and assume all blocks
     // incoming from Pulse are valid if they have the correct signatures
@@ -3787,7 +3786,8 @@ block_add_result service_node_list::state_t::update_from_block(
                 (uint8_t)nettype);
         print_sns();
         auto& sqlite_db = *sqlite_db_ptr;
-        oxen::sent::transition_context context = oxen::sent::get_transition_context(nettype, height);
+        oxen::sent::transition_context context =
+                oxen::sent::get_transition_context(nettype, height);
         oxen::sent::transition(context, *this, sqlite_db, nettype);
         print_sns();
     }
@@ -6719,7 +6719,8 @@ service_node_list::hf21_transition_result service_node_list::hf21_dry_run(
         insert_payment->reset();
     }
 
-    oxen::sent::transition_context context = oxen::sent::get_transition_context(nettype, state_copy.height);
+    oxen::sent::transition_context context =
+            oxen::sent::get_transition_context(nettype, state_copy.height);
     oxen::sent::transition(context, state_copy, db_copy, nettype);
 
     return {state_copy.service_nodes_infos, db_copy.get_all_accrued_rewards()};

src/l2_tracker/l2_tracker.cpp

@@ -639,8 +639,10 @@ void L2Tracker::update_purge_list(bool curr_height_fallback) {
                         // validator) even if we don't have it in our mempool as long as the
                         // purgeable conditions are met when we vote on it.
                         std::vector<std::pair<crypto::public_key, bls_public_key>> to_purge;
-                        if (mocknet_has_forked(core.blockchain.get_current_blockchain_height() - 1) ||
-                            mocknet_is_forking(core.blockchain.get_current_blockchain_height() - 1)) {
+                        if (mocknet_has_forked(
+                                    core.blockchain.get_current_blockchain_height() - 1) ||
+                            mocknet_is_forking(
+                                    core.blockchain.get_current_blockchain_height() - 1)) {
                         } else {
                             core.service_node_list.for_each_service_node(
                                     [this, &to_purge](

src/network_config/mocknet.cpp

@@ -256,7 +256,8 @@ void mocknet_inject_nodes(uint8_t nettype_u8, void* snl_state_ptr, uint8_t hf_ve
 
     // NOTE: Log that we hit the mocknet pre-conditions
     cryptonote::account_public_address zero_cn_address = {};
-    std::string zero_cn_address_str = cryptonote::get_account_address_as_str(nettype, false, zero_cn_address);
+    std::string zero_cn_address_str =
+            cryptonote::get_account_address_as_str(nettype, false, zero_cn_address);
 
     fmt::memory_buffer debug_log;
     fmt::format_to(
@@ -343,7 +344,8 @@ void mocknet_push_mock_pulse_block(cryptonote::core& core) {
     std::memcpy(mock_producer.data(), MOCKNET_KEYS[0].ed25519_pubkey.data(), sizeof(mock_producer));
 
     [[maybe_unused]] crypto::public_key mock_validator0;
-    std::memcpy(mock_validator0.data(), MOCKNET_KEYS[1].ed25519_pubkey.data(), sizeof(mock_validator0));
+    std::memcpy(
+            mock_validator0.data(), MOCKNET_KEYS[1].ed25519_pubkey.data(), sizeof(mock_validator0));
 
     assert(quorum.workers.size());
     assert(mock_producer == quorum.workers[0]);
@@ -369,7 +371,7 @@ void mocknet_push_mock_pulse_block(cryptonote::core& core) {
                 /*pulse round*/ 0,
                 /*validator handshake bitset*/ 0b0111'1111'1111,  // Full participation
                 generated_height);
-    } catch(const std::exception& e) {
+    } catch (const std::exception& e) {
         oxen::log::error(logcat, "Failed to generate block: {}", e.what());
     }
 
@@ -432,7 +434,8 @@ void mocknet_push_mock_pulse_block(cryptonote::core& core) {
     auto hf20_begins =
             cryptonote::hard_fork_begins(net, cryptonote::hf::hf20_eth_transition).value_or(0);
     if (block.get_height() == hf20_begins) {
-        std::vector<service_nodes::service_node_pubkey_info> snl_list = core.service_node_list.get_service_node_list_state();
+        std::vector<service_nodes::service_node_pubkey_info> snl_list =
+                core.service_node_list.get_service_node_list_state();
 
         oxen::log::info(
                 globallogcat,
@@ -453,9 +456,8 @@ void mocknet_push_mock_pulse_block(cryptonote::core& core) {
     }
 }
 
-void mocknet_get_transition_context(oxen::sent::transition_context& context)
-{
-    context.conv_ratio = {1, 120}; // X SESH per Y OXEN
+void mocknet_get_transition_context(oxen::sent::transition_context& context) {
+    context.conv_ratio = {1, 120};  // X SESH per Y OXEN
     context.addresses = &globals.transition_addr_map;
     context.bls_keys = &globals.transition_bls_keys;
     context.transition_bonus = &globals.transition_bonus_map;

src/sent_transition/sent_transition.cpp

@@ -93,8 +93,7 @@ static void dump_transition_outcome_csv(
         network_type net,
         std::span<node_transition> node_list,
         const std::unordered_map<eth::address, uint64_t>& final_allocation_before_distrib,
-        const std::unordered_map<eth::address, uint64_t>& final_unlocked_tokens)
-{
+        const std::unordered_map<eth::address, uint64_t>& final_unlocked_tokens) {
     uint64_t now = time(nullptr);
     oxen::log::debug(logcat, "Writing SESH->ETH allocation to disk");
     uint64_t total_bonus_sesh = 0;
@@ -109,12 +108,12 @@ static void dump_transition_outcome_csv(
 
     const size_t decimal_places = oxen::DISPLAY_DECIMAL_POINT;
     {
-        auto file = fmt::output_file("{:%Y%m%d_%H%M%S}_sesh_transition_result_stake_req_{}_conv_ratio_{}_oxen_per_{}_sesh_eth_addr_allocation.csv"_format(
-                    fmt::localtime(now),
-                    cryptonote::print_money(context.staking_requirement, decimal_places, true),
-                    cryptonote::print_money(context.conv_ratio.second),
-                    cryptonote::print_money(context.conv_ratio.first))
-                );
+        auto file = fmt::output_file(
+                "{:%Y%m%d_%H%M%S}_sesh_transition_result_stake_req_{}_conv_ratio_{}_oxen_per_{}_sesh_eth_addr_allocation.csv"_format(
+                        fmt::localtime(now),
+                        cryptonote::print_money(context.staking_requirement, decimal_places, true),
+                        cryptonote::print_money(context.conv_ratio.second),
+                        cryptonote::print_money(context.conv_ratio.first)));
         file.print("height,{}\n", snl_state.height);
         file.print("rewards_program_snapshot_date,2025-02-27\n");
         file.print(
@@ -146,17 +145,15 @@ static void dump_transition_outcome_csv(
             for (auto it : final_unlocked_tokens) {
                 total_unlocked_sesh += it.second;
             }
-            file.print(
-                    "total_unlocked_sesh,{}\n", cryptonote::print_money(total_unlocked_sesh));
+            file.print("total_unlocked_sesh,{}\n", cryptonote::print_money(total_unlocked_sesh));
         }
 
         // NOTE: Calculate the amount of tokens generated
         {
             uint64_t total_generated_sesh = 0;
             for (auto it : final_allocation_before_distrib)
                 total_generated_sesh += it.second;
-            file.print(
-                    "total_generated_sesh,{}\n", cryptonote::print_money(total_generated_sesh));
+            file.print("total_generated_sesh,{}\n", cryptonote::print_money(total_generated_sesh));
         }
 
         // NOTE: Sort the final token allocations, highest to lowest
@@ -218,7 +215,6 @@ static void dump_transition_outcome_csv(
                     }
                 }
             }
-
         }
         std::sort(
                 sorted.begin(),
@@ -234,7 +230,9 @@ static void dump_transition_outcome_csv(
                 cryptonote::print_money(context.conv_ratio.first));
 
         // NOTE: Print out the allocation for each address
-        file.print("eth_addr,pre_transition_sn_count,post_transition_sn_count,bonus_sesh,staked_sesh,unlocked_sesh,total_sesh (staked+unlocked)\n");
+        file.print(
+                "eth_addr,pre_transition_sn_count,post_transition_sn_count,bonus_sesh,staked_sesh,"
+                "unlocked_sesh,total_sesh (staked+unlocked)\n");
         size_t index = 0;
         for (auto sorted_it : sorted) {