Removed 'legacy_blinding' flag from convo info volatile functions

mpretty-cyro · mpretty-cyro · commit 921d28254990 · 2025-07-31T09:25:03.000+10:00
diff --git a/include/session/config/convo_info_volatile.h b/include/session/config/convo_info_volatile.h
@@ -368,23 +368,20 @@ LIBSESSION_EXPORT bool convo_info_volatile_get_or_construct_legacy_group(
 ///     [in]    config_object*                      conf,
 ///     [out]   convo_info_volatile_blinded_1to1*   convo,
 ///     [in]    const char*                         blinded_session_id
-///     [in]    bool                                legacy_blinding
 /// );
 /// ```
 ///
 /// Inputs:
 /// - `conf` -- [in] Pointer to the config object
 /// - `convo` -- [out] Pointer to conversation info
 /// - `blinded_session_id` -- [in] Null terminated hex string of the session_id
-/// - `legacy_blinding` -- flag indicating whether this blinded contact should use legacy blinding
 ///
 /// Outputs:
 /// - `bool` - Returns true if the conversation exists
 LIBSESSION_EXPORT bool convo_info_volatile_get_blinded_1to1(
         config_object* conf,
         convo_info_volatile_blinded_1to1* convo,
-        const char* blinded_session_id,
-        bool legacy_blinding) LIBSESSION_WARN_UNUSED;
+        const char* blinded_session_id) LIBSESSION_WARN_UNUSED;
 
 /// API: convo_info_volatile/convo_info_volatile_get_or_construct_blinded_1to1
 ///
@@ -405,23 +402,20 @@ LIBSESSION_EXPORT bool convo_info_volatile_get_blinded_1to1(
 ///     [in]    config_object*                      conf,
 ///     [out]   convo_info_volatile_blinded_1to1*   convo,
 ///     [in]    const char*                         blinded_session_id
-///     [in]    bool                                legacy_blinding
 /// );
 /// ```
 ///
 /// Inputs:
 /// - `conf` -- [in] Pointer to the config object
 /// - `convo` -- [out] Pointer to conversation info
 /// - `blinded_session_id` -- [in] Null terminated hex string of the blinded session id
-/// - `legacy_blinding` -- flag indicating whether this blinded contact should use legacy blinding
 ///
 /// Outputs:
 /// - `bool` - Returns true if the conversation exists
 LIBSESSION_EXPORT bool convo_info_volatile_get_or_construct_blinded_1to1(
         config_object* conf,
         convo_info_volatile_blinded_1to1* convo,
-        const char* blinded_session_id,
-        bool legacy_blinding) LIBSESSION_WARN_UNUSED;
+        const char* blinded_session_id) LIBSESSION_WARN_UNUSED;
 
 /// API: convo_info_volatile/convo_info_volatile_set_1to1
 ///
@@ -630,19 +624,17 @@ LIBSESSION_EXPORT bool convo_info_volatile_erase_legacy_group(
 /// BOOL convo_info_volatile_erase_blinded_1to1(
 ///     [in]    config_object*  conf,
 ///     [in]    const char*     blinded_session_id
-///     [in]    bool            legacy_blinding
 /// );
 /// ```
 ///
 /// Inputs:
 /// - `conf` -- [in] Pointer to the config object
 /// - `blinded_session_id` -- [in] Null terminated hex string
-/// - `legacy_blinding` -- flag indicating whether the blinded contact used legacy blinding
 ///
 /// Outputs:
 /// - `bool` - Returns true if conversation was found and removed
 LIBSESSION_EXPORT bool convo_info_volatile_erase_blinded_1to1(
-        config_object* conf, const char* blinded_session_id, bool legacy_blinding);
+        config_object* conf, const char* blinded_session_id);
 
 /// API: convo_info_volatile/convo_info_volatile_size
 ///
diff --git a/include/session/config/convo_info_volatile.hpp b/include/session/config/convo_info_volatile.hpp
@@ -174,10 +174,8 @@ namespace convo {
         ///
         /// Inputs:
         /// - `blinded_session_id` -- Hex string of the blinded session id
-        /// - `legacy_blinding` -- flag indicating whether this blinded contact should use legacy
-        /// blinding
-        explicit blinded_one_to_one(std::string&& blinded_session_id, bool legacy_blinding);
-        explicit blinded_one_to_one(std::string_view blinded_session_id, bool legacy_blinding);
+        explicit blinded_one_to_one(std::string&& blinded_session_id);
+        explicit blinded_one_to_one(std::string_view blinded_session_id);
 
         // Internal ctor/method for C API implementations:
         blinded_one_to_one(const struct convo_info_volatile_blinded_1to1& c);  // From c struct
@@ -341,13 +339,11 @@ class ConvoInfoVolatile : public ConfigBase {
     ///
     /// Inputs:
     /// - `blinded_session_id` -- Hex string of the blinded Session ID
-    /// - `legacy_blinding` -- flag indicating whether this blinded contact should use legacy
-    /// blinding
     ///
     /// Outputs:
     /// - `std::optional<convo::blinded_one_to_one>` - Returns a contact
     std::optional<convo::blinded_one_to_one> get_blinded_1to1(
-            std::string_view blinded_session_id, bool legacy_blinding) const;
+            std::string_view blinded_session_id) const;
 
     /// API: convo_info_volatile/ConvoInfoVolatile::get_or_construct_1to1
     ///
@@ -444,13 +440,11 @@ class ConvoInfoVolatile : public ConfigBase {
     ///
     /// Inputs:
     /// - `blinded_session_id` -- Hex string blinded Session ID
-    /// - `legacy_blinding` -- flag indicating whether this blinded contact should use legacy
-    /// blinding
     ///
     /// Outputs:
     /// - `convo::blinded_one_to_one` - Returns a blinded contact
     convo::blinded_one_to_one get_or_construct_blinded_1to1(
-            std::string_view blinded_session_id, bool legacy_blinding) const;
+            std::string_view blinded_session_id) const;
 
     /// API: convo_info_volatile/ConvoInfoVolatile::set
     ///
@@ -545,11 +539,10 @@ class ConvoInfoVolatile : public ConfigBase {
     ///
     /// Inputs:
     /// - `pubkey` -- hex blinded session id
-    /// - `legacy_blinding` -- flag indicating whether this blinded contact is using legacy blinding
     ///
     /// Outputs:
     /// - `bool` - Returns true if found and removed, otherwise false
-    bool erase_blinded_1to1(std::string_view pubkey, bool legacy_blinding);
+    bool erase_blinded_1to1(std::string_view pubkey);
 
     /// API: convo_info_volatile/ConvoInfoVolatile::erase
     ///
diff --git a/src/config/convo_info_volatile.cpp b/src/config/convo_info_volatile.cpp
@@ -82,13 +82,23 @@ namespace convo {
         c.unread = unread;
     }
 
-    blinded_one_to_one::blinded_one_to_one(std::string&& sid, bool legacy_blinding) :
-            blinded_session_id{std::move(sid)}, legacy_blinding{legacy_blinding} {
-        check_session_id(blinded_session_id, legacy_blinding ? "15" : "25");
+    blinded_one_to_one::blinded_one_to_one(std::string&& sid) : blinded_session_id{std::move(sid)} {
+        auto prefix = get_session_id_prefix(blinded_session_id);
+        legacy_blinding = (prefix == session::SessionIDPrefix::community_blinded_legacy);
+
+        if (prefix != session::SessionIDPrefix::community_blinded &&
+            prefix != session::SessionIDPrefix::community_blinded_legacy)
+            throw std::invalid_argument{
+                    "Invalid blinded ID: Expected '15' or '25' prefix; got " + blinded_session_id};
     }
-    blinded_one_to_one::blinded_one_to_one(std::string_view sid, bool legacy_blinding) :
-            blinded_session_id{sid}, legacy_blinding{legacy_blinding} {
-        check_session_id(blinded_session_id, legacy_blinding ? "15" : "25");
+    blinded_one_to_one::blinded_one_to_one(std::string_view sid) : blinded_session_id{sid} {
+        auto prefix = get_session_id_prefix(blinded_session_id);
+        legacy_blinding = (prefix == session::SessionIDPrefix::community_blinded_legacy);
+
+        if (prefix != session::SessionIDPrefix::community_blinded &&
+            prefix != session::SessionIDPrefix::community_blinded_legacy)
+            throw std::invalid_argument{
+                    "Invalid blinded ID: Expected '15' or '25' prefix; got " + blinded_session_id};
     }
     blinded_one_to_one::blinded_one_to_one(const convo_info_volatile_blinded_1to1& c) :
             base{c.last_read, c.unread},
@@ -234,25 +244,31 @@ convo::legacy_group ConvoInfoVolatile::get_or_construct_legacy_group(
 }
 
 std::optional<convo::blinded_one_to_one> ConvoInfoVolatile::get_blinded_1to1(
-        std::string_view pubkey_hex, bool legacy_blinding) const {
-    std::string pubkey = session_id_to_bytes(pubkey_hex, legacy_blinding ? "15" : "25");
+        std::string_view pubkey_hex) const {
+    auto prefix = get_session_id_prefix(pubkey_hex);
+
+    if (prefix != session::SessionIDPrefix::community_blinded &&
+        prefix != session::SessionIDPrefix::community_blinded_legacy)
+        throw std::invalid_argument{
+                "Invalid blinded ID: Expected '15' or '25' prefix; got " + std::string{pubkey_hex}};
+
+    std::string pubkey = session_id_to_bytes(pubkey_hex, to_string(prefix));
 
     auto* info_dict = data["b"][pubkey].dict();
     if (!info_dict)
         return std::nullopt;
 
-    auto result =
-            std::make_optional<convo::blinded_one_to_one>(std::string{pubkey_hex}, legacy_blinding);
+    auto result = std::make_optional<convo::blinded_one_to_one>(std::string{pubkey_hex});
     result->load(*info_dict);
     return result;
 }
 
 convo::blinded_one_to_one ConvoInfoVolatile::get_or_construct_blinded_1to1(
-        std::string_view pubkey_hex, bool legacy_blinding) const {
-    if (auto maybe = get_blinded_1to1(pubkey_hex, legacy_blinding))
+        std::string_view pubkey_hex) const {
+    if (auto maybe = get_blinded_1to1(pubkey_hex))
         return *std::move(maybe);
 
-    return convo::blinded_one_to_one{std::string{pubkey_hex}, legacy_blinding};
+    return convo::blinded_one_to_one{std::string{pubkey_hex}};
 }
 
 void ConvoInfoVolatile::set(const convo::one_to_one& c) {
@@ -386,9 +402,8 @@ bool ConvoInfoVolatile::erase_group(std::string_view id) {
 bool ConvoInfoVolatile::erase_legacy_group(std::string_view id) {
     return erase(convo::legacy_group{id});
 }
-bool ConvoInfoVolatile::erase_blinded_1to1(
-        std::string_view blinded_session_id, bool legacy_blinding) {
-    return erase(convo::blinded_one_to_one{blinded_session_id, legacy_blinding});
+bool ConvoInfoVolatile::erase_blinded_1to1(std::string_view blinded_session_id) {
+    return erase(convo::blinded_one_to_one{blinded_session_id});
 }
 
 size_t ConvoInfoVolatile::size_1to1() const {
@@ -489,11 +504,7 @@ class val_loader {
 
             if (k.size() == 33 && (k[0] == prefix || (legacy_prefix && k[0] == *legacy_prefix))) {
                 if (auto* info_dict = std::get_if<dict>(&v)) {
-                    if constexpr (std::is_same_v<ConvoType, convo::blinded_one_to_one>)
-                        val = std::make_shared<convo::any>(ConvoType{
-                                oxenc::to_hex(k), (legacy_prefix && k[0] == *legacy_prefix)});
-                    else
-                        val = std::make_shared<convo::any>(ConvoType{oxenc::to_hex(k)});
+                    val = std::make_shared<convo::any>(ConvoType{oxenc::to_hex(k)});
                     std::get<ConvoType>(*val).load(*info_dict);
                     return true;
                 }
@@ -693,13 +704,11 @@ LIBSESSION_C_API bool convo_info_volatile_get_or_construct_legacy_group(
 LIBSESSION_C_API bool convo_info_volatile_get_blinded_1to1(
         config_object* conf,
         convo_info_volatile_blinded_1to1* convo,
-        const char* blinded_session_id,
-        bool legacy_blinding) {
+        const char* blinded_session_id) {
     return wrap_exceptions(
             conf,
             [&] {
-                if (auto c = unbox<ConvoInfoVolatile>(conf)->get_blinded_1to1(
-                            blinded_session_id, legacy_blinding)) {
+                if (auto c = unbox<ConvoInfoVolatile>(conf)->get_blinded_1to1(blinded_session_id)) {
                     c->into(*convo);
                     return true;
                 }
@@ -711,13 +720,12 @@ LIBSESSION_C_API bool convo_info_volatile_get_blinded_1to1(
 LIBSESSION_C_API bool convo_info_volatile_get_or_construct_blinded_1to1(
         config_object* conf,
         convo_info_volatile_blinded_1to1* convo,
-        const char* blinded_session_id,
-        bool legacy_blinding) {
+        const char* blinded_session_id) {
     return wrap_exceptions(
             conf,
             [&] {
                 unbox<ConvoInfoVolatile>(conf)
-                        ->get_or_construct_blinded_1to1(blinded_session_id, legacy_blinding)
+                        ->get_or_construct_blinded_1to1(blinded_session_id)
                         .into(*convo);
                 return true;
             },
@@ -799,13 +807,10 @@ LIBSESSION_C_API bool convo_info_volatile_erase_legacy_group(
             false);
 }
 LIBSESSION_C_API bool convo_info_volatile_erase_blinded_1to1(
-        config_object* conf, const char* blinded_session_id, bool legacy_blinding) {
+        config_object* conf, const char* blinded_session_id) {
     return wrap_exceptions(
             conf,
-            [&] {
-                return unbox<ConvoInfoVolatile>(conf)->erase_blinded_1to1(
-                        blinded_session_id, legacy_blinding);
-            },
+            [&] { return unbox<ConvoInfoVolatile>(conf)->erase_blinded_1to1(blinded_session_id); },
             false);
 }
 
diff --git a/tests/test_config_convo_info_volatile.cpp b/tests/test_config_convo_info_volatile.cpp
@@ -95,10 +95,10 @@ TEST_CASE("Conversations", "[config][conversations]") {
     g.unread = true;
     convos.set(g);
 
-    CHECK_FALSE(convos.get_blinded_1to1(legacy_blinded_id, true));
-    CHECK_FALSE(convos.get_blinded_1to1(blinded_id, false));
+    CHECK_FALSE(convos.get_blinded_1to1(legacy_blinded_id));
+    CHECK_FALSE(convos.get_blinded_1to1(blinded_id));
 
-    auto lb = convos.get_or_construct_blinded_1to1(legacy_blinded_id, true);
+    auto lb = convos.get_or_construct_blinded_1to1(legacy_blinded_id);
     CHECK(lb.blinded_session_id == legacy_blinded_id);
     CHECK(lb.last_read == 0);
     CHECK_FALSE(lb.unread);
@@ -107,7 +107,7 @@ TEST_CASE("Conversations", "[config][conversations]") {
     lb.unread = true;
     convos.set(lb);
 
-    auto b = convos.get_or_construct_blinded_1to1(blinded_id, false);
+    auto b = convos.get_or_construct_blinded_1to1(blinded_id);
     CHECK(b.blinded_session_id == blinded_id);
     CHECK(b.last_read == 0);
     CHECK_FALSE(b.unread);
@@ -153,14 +153,14 @@ TEST_CASE("Conversations", "[config][conversations]") {
     CHECK(x3->last_read == now_ms);
     CHECK(x3->unread);
 
-    auto x4 = convos2.get_blinded_1to1(legacy_blinded_id, true);
+    auto x4 = convos2.get_blinded_1to1(legacy_blinded_id);
     REQUIRE(x4);
     CHECK(x4->blinded_session_id ==
           "150000000000000000000000000000000000101010111010000110100001210000");
     CHECK(x4->last_read == now_ms);
     CHECK(x4->unread);
 
-    auto x5 = convos2.get_blinded_1to1(blinded_id, false);
+    auto x5 = convos2.get_blinded_1to1(blinded_id);
     REQUIRE(x5);
     CHECK(x5->blinded_session_id ==
           "255000000000000000000000000000000000101010111010000110100001210000");
@@ -178,7 +178,7 @@ TEST_CASE("Conversations", "[config][conversations]") {
     convos2.set(c3);
 
     auto c4 = convos2.get_or_construct_blinded_1to1(
-            "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", false);
+            "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc");
     c4.unread = true;
     convos2.set(c4);
 
@@ -250,8 +250,7 @@ TEST_CASE("Conversations", "[config][conversations]") {
     convos.erase_1to1("052000000000000000000000000000000000000000000000000000000000000000");
     CHECK_FALSE(convos.needs_push());
     convos.erase_1to1("055000000000000000000000000000000000000000000000000000000000000000");
-    convos.erase_blinded_1to1(
-            "255000000000000000000000000000000000101010111010000110100001210000", false);
+    convos.erase_blinded_1to1("255000000000000000000000000000000000101010111010000110100001210000");
     CHECK(convos.needs_push());
     CHECK(convos.size() == 6);
     CHECK(convos.size_1to1() == 1);
@@ -287,6 +286,12 @@ TEST_CASE("Conversations", "[config][conversations]") {
                           "150000000000000000000000000000000000101010111010000110100001210000",
                           "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
                   });
+
+    // Ensure that we throw correctly when giving invalid blinded ids
+    auto invalid_id_1 = "072222222222222222222222222222222222222222222222222222222222222222"sv;
+    auto invalid_id_2 = "992222222222222222222222222222222222222222222222222222222222222222"sv;
+    CHECK_THROWS(convos.get_or_construct_blinded_1to1(invalid_id_1));
+    CHECK_THROWS(convos.get_or_construct_blinded_1to1(invalid_id_2));
 }
 
 TEST_CASE("Conversations (C API)", "[config][conversations][c]") {
@@ -382,8 +387,8 @@ TEST_CASE("Conversations (C API)", "[config][conversations][c]") {
     const char* const blinded_id =
             "150000000000000000000000000000000000101010111010000110100001210000";
     convo_info_volatile_blinded_1to1 b1;
-    REQUIRE_FALSE(convo_info_volatile_get_blinded_1to1(conf, &b1, blinded_id, true));
-    REQUIRE(convo_info_volatile_get_or_construct_blinded_1to1(conf, &b1, blinded_id, true));
+    REQUIRE_FALSE(convo_info_volatile_get_blinded_1to1(conf, &b1, blinded_id));
+    REQUIRE(convo_info_volatile_get_or_construct_blinded_1to1(conf, &b1, blinded_id));
     b1.last_read = now_ms;
     convo_info_volatile_set_blinded_1to1(conf, &b1);
 
@@ -438,10 +443,7 @@ TEST_CASE("Conversations (C API)", "[config][conversations][c]") {
 
     convo_info_volatile_blinded_1to1 b2;
     REQUIRE(convo_info_volatile_get_or_construct_blinded_1to1(
-            conf2,
-            &b2,
-            "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
-            false));
+            conf2, &b2, "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"));
     b2.unread = true;
     convo_info_volatile_set_blinded_1to1(conf2, &b2);
     CHECK(config_needs_push(conf2));
@@ -515,7 +517,7 @@ TEST_CASE("Conversations (C API)", "[config][conversations][c]") {
     convo_info_volatile_erase_1to1(
             conf, "055000000000000000000000000000000000000000000000000000000000000000");
     convo_info_volatile_erase_blinded_1to1(
-            conf, "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", false);
+            conf, "2512345ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc");
     CHECK(config_needs_push(conf));
     CHECK(convo_info_volatile_size(conf) == 4);
     CHECK(convo_info_volatile_size_1to1(conf) == 1);
