Formatting

Author: Doy-lee

src/config/groups/keys.cpp

@@ -24,7 +24,6 @@
 #include "session/multi_encrypt.hpp"
 #include "session/session_encrypt.hpp"
 #include "session/xed25519.hpp"
-#include "session/session_encrypt.hpp"
 
 using namespace std::literals;
 

src/config/internal.cpp

@@ -127,7 +127,8 @@ std::optional<std::chrono::sys_seconds> maybe_ts(const session::config::dict& d,
     return result;
 }
 
-std::optional<std::chrono::sys_time<std::chrono::milliseconds>> maybe_ts_ms(const session::config::dict& d, const char* key) {
+std::optional<std::chrono::sys_time<std::chrono::milliseconds>> maybe_ts_ms(
+        const session::config::dict& d, const char* key) {
     std::optional<std::chrono::sys_time<std::chrono::milliseconds>> result;
     if (auto* i = maybe_scalar<int64_t>(d, key))
         result.emplace(std::chrono::milliseconds{*i});

src/config/internal.hpp

@@ -185,7 +185,8 @@ std::optional<std::chrono::sys_seconds> maybe_ts(const session::config::dict& d,
 // Digs into a config `dict` to get out an int64_t containing unix timestamp milliseconds, returns
 // it wrapped in a std::chrono::sys_time<std::chrono::milliseconds>.  Returns nullopt if not there
 // (or not int).
-std::optional<std::chrono::sys_time<std::chrono::milliseconds>> maybe_ts_ms(const session::config::dict& d, const char* key);
+std::optional<std::chrono::sys_time<std::chrono::milliseconds>> maybe_ts_ms(
+        const session::config::dict& d, const char* key);
 
 // Works like maybe_ts, except that if the value isn't present it returns a default-constructed
 // sys_seconds (i.e. unix timestamp 0).  Equivalent to `maybe_ts(d,

src/config/pro.cpp

@@ -93,7 +93,9 @@ LIBSESSION_C_API bool pro_config_verify_signature(
 
     session::config::ProConfig config = {};
     std::memcpy(
-            config.rotating_privkey.data(), pro->rotating_privkey.data, sizeof pro->rotating_privkey.data);
+            config.rotating_privkey.data(),
+            pro->rotating_privkey.data,
+            sizeof pro->rotating_privkey.data);
     config.proof.version = pro->proof.version;
     std::memcpy(
             config.proof.gen_index_hash.data(),

src/pro_backend.cpp

@@ -8,9 +8,10 @@
 #include <chrono>
 #include <nlohmann/json.hpp>
 #include <session/pro_backend.hpp>
+#include <session/session_encrypt.hpp>
 #include <session/sodium_array.hpp>
 #include <session/types.hpp>
-#include <session/session_encrypt.hpp>
+
 #include "SessionProtos.pb.h"
 
 namespace {
@@ -447,13 +448,16 @@ GetProStatusResponse GetProStatusResponse::parse(std::string_view json) {
     // Parse payload
     uint32_t user_status = json_require<uint32_t>(result_obj, "status", result.errors);
     if (user_status >= SESSION_PRO_BACKEND_USER_PRO_STATUS_COUNT) {
-        result.errors.push_back(fmt::format("User pro status value was out-of-bounds: {}", user_status));
+        result.errors.push_back(
+                fmt::format("User pro status value was out-of-bounds: {}", user_status));
         return result;
     }
     result.user_status = static_cast<SESSION_PRO_BACKEND_USER_PRO_STATUS>(user_status);
 
-    uint64_t latest_grace_ts = json_require<uint64_t>(result_obj, "latest_grace_unix_ts_ms", result.errors);
-    uint64_t latest_expiry_ts = json_require<uint64_t>(result_obj, "latest_expiry_unix_ts_ms", result.errors);
+    uint64_t latest_grace_ts =
+            json_require<uint64_t>(result_obj, "latest_grace_unix_ts_ms", result.errors);
+    uint64_t latest_expiry_ts =
+            json_require<uint64_t>(result_obj, "latest_expiry_unix_ts_ms", result.errors);
     result.latest_grace_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
             std::chrono::milliseconds(latest_grace_ts));
     result.latest_expiry_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
@@ -489,12 +493,12 @@ GetProStatusResponse GetProStatusResponse::parse(std::string_view json) {
 
         item.grace_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
                 std::chrono::milliseconds(grace_ts));
-        item.expiry_unix_ts =
-                std::chrono::sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(expiry_ts));
-        item.redeemed_unix_ts =
-                std::chrono::sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(redeemed_ts));
-        item.refunded_unix_ts =
-                std::chrono::sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(refunded_ts));
+        item.expiry_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
+                std::chrono::milliseconds(expiry_ts));
+        item.redeemed_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
+                std::chrono::milliseconds(redeemed_ts));
+        item.refunded_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
+                std::chrono::milliseconds(refunded_ts));
         item.subscription_duration = std::chrono::seconds(sub_duration_s);
         if (payment_provider > SESSION_PRO_BACKEND_PAYMENT_PROVIDER_NIL &&
             payment_provider < SESSION_PRO_BACKEND_PAYMENT_PROVIDER_COUNT) {
@@ -637,8 +641,7 @@ session_pro_backend_get_pro_proof_request_build_sigs(
     return result;
 }
 
-LIBSESSION_C_API session_pro_backend_signature
-session_pro_backend_get_pro_status_request_build_sig(
+LIBSESSION_C_API session_pro_backend_signature session_pro_backend_get_pro_status_request_build_sig(
         uint8_t request_version,
         const uint8_t* master_privkey,
         size_t master_privkey_len,
@@ -946,8 +949,8 @@ session_pro_backend_get_pro_status_response_parse(const char* json, size_t json_
         dest.subscription_duration_s =
                 std::chrono::duration_cast<std::chrono::seconds>(src.subscription_duration).count();
         dest.grace_unix_ts_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                                            src.grace_unix_ts.time_since_epoch())
-                                            .count();
+                                        src.grace_unix_ts.time_since_epoch())
+                                        .count();
         dest.expiry_unix_ts_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                                          src.expiry_unix_ts.time_since_epoch())
                                          .count();

src/session_protocol.cpp

@@ -1,14 +1,14 @@
 #include <fmt/core.h>
 #include <oxenc/hex.h>
-#include <sodium/crypto_generichash_blake2b.h>
 #include <session/config/groups/keys.h>
 #include <simdutf.h>
+#include <sodium/crypto_generichash_blake2b.h>
 #include <sodium/crypto_sign_ed25519.h>
 #include <sodium/randombytes.h>
 
+#include <session/pro_backend.hpp>
 #include <session/session_encrypt.hpp>
 #include <session/session_protocol.hpp>
-#include <session/pro_backend.hpp>
 #include <session/util.hpp>
 
 #include "SessionProtos.pb.h"
@@ -163,7 +163,7 @@ session::ProFeaturesForMsg pro_features_for_utf8_or_16(
     }
     return result;
 }
-};  // namespace
+};  // namespace session
 
 namespace session {
 

src/util.cpp

@@ -3,7 +3,6 @@
 #include <charconv>
 #include <memory>
 #include <session/util.hpp>
-#include <zstd.h>
 
 namespace session {
 

tests/test_session_protocol.cpp

@@ -59,10 +59,9 @@ static SerialisedProtobufContentWithProForTesting build_protobuf_content_with_se
             result.proof.gen_index_hash.data(), result.proof.gen_index_hash.size());
     proto_proof->set_rotatingpublickey(
             result.proof.rotating_pubkey.data(), result.proof.rotating_pubkey.size());
-    proto_proof->set_expiryunixts(
-            std::chrono::duration_cast<std::chrono::seconds>(
-                    result.proof.expiry_unix_ts.time_since_epoch())
-                    .count());
+    proto_proof->set_expiryunixts(std::chrono::duration_cast<std::chrono::seconds>(
+                                          result.proof.expiry_unix_ts.time_since_epoch())
+                                          .count());
     proto_proof->set_sig(result.proof.sig.data(), result.proof.sig.size());
 
     // Generate the plaintext