Merge pull request #60 from mpretty-cyro/fix/remove-legacy-blinding-flag-convo-info-volatile

Removed 'legacy_blinding' flag from convo info volatile functions

Author: mpretty-cyro

CMakeLists.txt

@@ -17,7 +17,7 @@ if(CCACHE_PROGRAM)
 endif()
 
 project(libsession-util
-    VERSION 1.5.3
+    VERSION 1.5.4
     DESCRIPTION "Session client utility library"
     LANGUAGES ${LANGS})
 

include/session/config/contacts.h

@@ -45,6 +45,9 @@ typedef struct contacts_blinded_contact {
 
     char name[101];  // This will be a 0-length string when unset
     user_profile_pic profile_pic;
+    int64_t profile_updated;  // unix timestamp (seconds)
+
+    int priority;
 
     bool legacy_blinding;
     int64_t created;  // unix timestamp (seconds)

include/session/config/contacts.hpp

@@ -61,6 +61,10 @@ namespace session::config {
 ///           alive as empty dicts get pruned).
 ///       p - profile url (string)
 ///       q - profile decryption key (binary)
+///       t - The `profile_updated` unix timestamp (seconds) for this contacts profile information.
+///       + - the conversation priority; -1 means hidden; omitted means not pinned; otherwise an
+///           integer value >0, where a higher priority means the conversation is meant to appear
+///           earlier in the pinned conversation list.
 ///       j - Unix timestamp (seconds) when the contact was created ("j" to match user_groups
 ///           equivalent "j"oined field). Omitted if 0.
 ///       y - flag indicating whether the blinded message request is using legac"y" blinding.
@@ -122,6 +126,13 @@ struct blinded_contact_info {
     const std::string session_id() const;  // in hex
     std::string name;
     profile_pic profile_picture;
+    std::chrono::sys_seconds profile_updated{};  /// The unix timestamp (seconds) that this
+                                                 /// profile information was last updated.
+    int priority = 0;  // If >0 then this message is pinned; higher values mean higher priority
+                       // (i.e. pinned earlier in the pinned list).  If negative then this
+                       // conversation is hidden.  Otherwise (0) this is a regular, unpinned
+                       // conversation.
+
     bool legacy_blinding;
     std::chrono::sys_seconds created{};  // Unix timestamp (seconds) when this contact was added
 
@@ -142,7 +153,7 @@ struct blinded_contact_info {
     /// - `c` -- Return Parameter that will be filled with data in blinded_contact_info
     void into(contacts_blinded_contact& c) const;
 
-    /// API: contacts/contact_info::set_name
+    /// API: contacts/blinded_contact_info::set_name
     ///
     /// Sets a name; this is exactly the same as assigning to .name directly,
     /// except that we throw an exception if the given name is longer than MAX_NAME_LENGTH.

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
 ///

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
     ///

src/config/contacts.cpp

@@ -332,6 +332,8 @@ void blinded_contact_info::load(const dict& info_dict) {
     } else {
         profile_picture.clear();
     }
+    profile_updated = ts_or_epoch(info_dict, "t");
+    priority = int_or_0(info_dict, "+");
     legacy_blinding = int_or_0(info_dict, "y");
     created = ts_or_epoch(info_dict, "j");
 }
@@ -350,6 +352,8 @@ void blinded_contact_info::into(contacts_blinded_contact& c) const {
     } else {
         copy_c_str(c.profile_pic.url, "");
     }
+    c.profile_updated = profile_updated.time_since_epoch().count();
+    c.priority = priority;
     c.legacy_blinding = legacy_blinding;
     c.created = created.time_since_epoch().count();
 }
@@ -363,6 +367,8 @@ blinded_contact_info::blinded_contact_info(const contacts_blinded_contact& c) {
         profile_picture.url = c.profile_pic.url;
         profile_picture.key.assign(c.profile_pic.key, c.profile_pic.key + 32);
     }
+    profile_updated = to_sys_seconds(c.profile_updated);
+    priority = c.priority;
     legacy_blinding = c.legacy_blinding;
     created = to_sys_seconds(c.created);
 }
@@ -474,7 +480,8 @@ void Contacts::set_blinded(const blinded_contact_info& bc) {
             bc.profile_picture.url,
             info["q"],
             bc.profile_picture.key);
-
+    set_ts(info["t"], bc.profile_updated);
+    set_nonzero_int(info["+"], bc.priority);
     set_positive_int(info["y"], bc.legacy_blinding);
     set_ts(info["j"], bc.created);
 }

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);
 }