Retyped the libSession wrapper code in preparation of the 1.3.0 changes

Author: mpretty-cyro

src/base_config.cpp

@@ -61,7 +61,7 @@ Napi::Value ConfigBaseImpl::merge(const Napi::CallbackInfo& info) {
         assertIsArray(info[0]);
         Napi::Array asArray = info[0].As<Napi::Array>();
 
-        std::vector<std::pair<std::string, ustring_view>> conf_strs;
+        std::vector<std::pair<std::string, std::span<const unsigned char>>> conf_strs;
         conf_strs.reserve(asArray.Length());
 
         for (uint32_t i = 0; i < asArray.Length(); i++) {

src/base_config.hpp

@@ -5,6 +5,7 @@
 
 #include <cassert>
 #include <memory>
+#include <span>
 #include <stdexcept>
 #include <unordered_set>
 
@@ -13,8 +14,6 @@
 #include "session/types.hpp"
 #include "utilities.hpp"
 
-using ustring_view = std::basic_string_view<unsigned char>;
-
 namespace session::nodeapi {
 
 class ConfigBaseImpl;
@@ -95,9 +94,9 @@ class ConfigBaseImpl {
             // we should get secret key as first arg and optional dumped as second argument
             assertIsUInt8Array(info[0], "base construct");
             assertIsUInt8ArrayOrNull(info[1]);
-            ustring_view secretKey = toCppBufferView(info[0], class_name + ".new");
+            std::span<const unsigned char> secretKey = toCppBufferView(info[0], class_name + ".new");
 
-            std::optional<ustring_view> dump;
+            std::optional<std::span<const unsigned char>> dump;
             auto second = info[1];
             if (!second.IsEmpty() && !second.IsNull() && !second.IsUndefined())
                 dump = toCppBufferView(second, class_name + ".new");

src/blinding/blinding.hpp

@@ -3,6 +3,7 @@
 #include <napi.h>
 
 #include <algorithm>
+#include <vector>
 
 #include "../meta/meta_base_wrapper.hpp"
 #include "../utilities.hpp"
@@ -58,8 +59,7 @@ class BlindingWrapper : public Napi::ObjectWrap<BlindingWrapper> {
 
             auto keypair = session::blind_version_key_pair(ed25519_secret_key);
             session::uc32 pk_arr = std::get<0>(keypair);
-            ustring blinded_pk = session::ustring(
-                    session::to_unsigned_sv(std::string(pk_arr.begin(), pk_arr.end())));
+            std::vector<unsigned char> blinded_pk = session::to_vector(pk_arr);
             std::string blinded_pk_hex;
             blinded_pk_hex.reserve(66);
             blinded_pk_hex += "07";

src/groups/meta_group.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <napi.h>
+#include <vector>
 
 #include "session/config/groups/info.hpp"
 #include "session/config/groups/keys.hpp"
@@ -32,12 +33,12 @@ class MetaGroup {
             shared_ptr<config::groups::Info> info,
             shared_ptr<config::groups::Members> members,
             shared_ptr<config::groups::Keys> keys,
-            session::ustring edGroupPubKey,
-            std::optional<session::ustring> edGroupSecKey) :
-            info{info}, members{members}, keys{keys}, edGroupPubKey{oxenc::to_hex(edGroupPubKey)} {
+            std::vector<unsigned char> edGroupPubKey,
+            std::optional<std::vector<unsigned char>> edGroupSecKey) :
+            info{info}, members{members}, keys{keys}, edGroupPubKey{oxenc::to_hex(edGroupPubKey.begin(), edGroupPubKey.end())} {
 
         if (edGroupSecKey.has_value()) {
-            this->edGroupSecKey = oxenc::to_hex(*edGroupSecKey);
+            this->edGroupSecKey = oxenc::to_hex(edGroupSecKey->begin(), edGroupSecKey->end());
         } else {
             this->edGroupSecKey = std::nullopt;
         }

src/groups/meta_group_wrapper.cpp

@@ -3,6 +3,8 @@
 #include <napi.h>
 
 #include <memory>
+#include <span>
+#include <vector>
 
 #include "oxenc/bt_producer.h"
 #include "session/types.hpp"
@@ -208,12 +210,12 @@ Napi::Value MetaGroupWrapper::metaDump(const Napi::CallbackInfo& info) {
         oxenc::bt_dict_producer combined;
 
         // NOTE: the keys have to be in ascii-sorted order:
-        combined.append("info", session::from_unsigned_sv(this->meta_group->info->dump()));
-        combined.append("keys", session::from_unsigned_sv(this->meta_group->keys->dump()));
-        combined.append("members", session::from_unsigned_sv(this->meta_group->members->dump()));
+        combined.append("info", session::to_string(this->meta_group->info->dump()));
+        combined.append("keys", session::to_string(this->meta_group->keys->dump()));
+        combined.append("members", session::to_string(this->meta_group->members->dump()));
         auto to_dump = std::move(combined).str();
 
-        return session::ustring{to_unsigned_sv(to_dump)};
+        return session::to_vector(to_dump);
     });
 }
 
@@ -222,13 +224,13 @@ Napi::Value MetaGroupWrapper::metaMakeDump(const Napi::CallbackInfo& info) {
         oxenc::bt_dict_producer combined;
 
         // NOTE: the keys have to be in ascii-sorted order:
-        combined.append("info", session::from_unsigned_sv(this->meta_group->info->make_dump()));
-        combined.append("keys", session::from_unsigned_sv(this->meta_group->keys->make_dump()));
+        combined.append("info", session::to_string(this->meta_group->info->make_dump()));
+        combined.append("keys", session::to_string(this->meta_group->keys->make_dump()));
         combined.append(
-                "members", session::from_unsigned_sv(this->meta_group->members->make_dump()));
+                "members", session::to_string(this->meta_group->members->make_dump()));
         auto to_dump = std::move(combined).str();
 
-        return ustring{to_unsigned_sv(to_dump)};
+        return session::to_vector(to_dump);
     });
 }
 
@@ -326,7 +328,7 @@ Napi::Value MetaGroupWrapper::metaMerge(const Napi::CallbackInfo& info) {
             assertIsArray(groupInfo);
             auto asArr = groupInfo.As<Napi::Array>();
 
-            std::vector<std::pair<std::string, ustring_view>> conf_strs;
+            std::vector<std::pair<std::string, std::span<const unsigned char>>> conf_strs;
             conf_strs.reserve(asArr.Length());
 
             for (uint32_t i = 0; i < asArr.Length(); i++) {
@@ -353,7 +355,7 @@ Napi::Value MetaGroupWrapper::metaMerge(const Napi::CallbackInfo& info) {
             assertIsArray(groupMember);
             auto asArr = groupMember.As<Napi::Array>();
 
-            std::vector<std::pair<std::string, ustring_view>> conf_strs;
+            std::vector<std::pair<std::string, std::span<const unsigned char>>> conf_strs;
             conf_strs.reserve(asArr.Length());
 
             for (uint32_t i = 0; i < asArr.Length(); i++) {
@@ -790,7 +792,7 @@ Napi::Value MetaGroupWrapper::encryptMessages(const Napi::CallbackInfo& info) {
 
         auto plaintextsJS = info[0].As<Napi::Array>();
         uint32_t arrayLength = plaintextsJS.Length();
-        std::vector<session::ustring> encryptedMessages;
+        std::vector<std::vector<unsigned char>> encryptedMessages;
         encryptedMessages.reserve(arrayLength);
 
         for (uint32_t i = 0; i < plaintextsJS.Length(); i++) {
@@ -820,10 +822,10 @@ Napi::Value MetaGroupWrapper::makeSwarmSubAccount(const Napi::CallbackInfo& info
         assertIsString(info[0]);
 
         auto memberPk = toCppString(info[0], "makeSwarmSubAccount");
-        ustring subaccount = this->meta_group->keys->swarm_make_subaccount(memberPk);
+        std::vector<unsigned char> subaccount = this->meta_group->keys->swarm_make_subaccount(memberPk);
 
         session::nodeapi::checkOrThrow(
-                subaccount.length() == 100, "expected subaccount to be 100 bytes long");
+                subaccount.size() == 100, "expected subaccount to be 100 bytes long");
 
         return subaccount;
     });
@@ -835,12 +837,12 @@ Napi::Value MetaGroupWrapper::swarmSubAccountToken(const Napi::CallbackInfo& inf
         assertIsString(info[0]);
 
         auto memberPk = toCppString(info[0], "swarmSubAccountToken");
-        ustring subaccount = this->meta_group->keys->swarm_subaccount_token(memberPk);
+        std::vector<unsigned char> subaccount = this->meta_group->keys->swarm_subaccount_token(memberPk);
 
         session::nodeapi::checkOrThrow(
-                subaccount.length() == 36, "expected subaccount token to be 36 bytes long");
+                subaccount.size() == 36, "expected subaccount token to be 36 bytes long");
 
-        return oxenc::to_hex(subaccount);
+        return oxenc::to_hex(subaccount.begin(), subaccount.end());
     });
 }
 

src/meta/meta_base_wrapper.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <napi.h>
+#include <vector>
+#include <span>
 
 #include "../base_config.hpp"
 #include "../groups/meta_group.hpp"
@@ -56,33 +58,33 @@ class MetaBaseWrapper {
                     obj.Get("groupEd25519Pubkey"),
                     class_name + ":constructGroupWrapper.groupEd25519Pubkey");
 
-            std::optional<ustring> group_ed25519_secretkey = maybeNonemptyBuffer(
+            std::optional<std::vector<unsigned char>> group_ed25519_secretkey = maybeNonemptyBuffer(
                     obj.Get("groupEd25519Secretkey"),
                     class_name + ":constructGroupWrapper.groupEd25519Secretkey");
 
-            std::optional<ustring> dumped_meta = maybeNonemptyBuffer(
+            std::optional<std::vector<unsigned char>> dumped_meta = maybeNonemptyBuffer(
                     obj.Get("metaDumped"), class_name + ":constructGroupWrapper.metaDumped");
 
-            std::optional<ustring_view> dumped_info;
-            std::optional<ustring_view> dumped_members;
-            std::optional<ustring_view> dumped_keys;
+            std::optional<std::span<const unsigned char>> dumped_info;
+            std::optional<std::span<const unsigned char>> dumped_members;
+            std::optional<std::span<const unsigned char>> dumped_keys;
 
             if (dumped_meta) {
-                auto dumped_meta_str = from_unsigned_sv(*dumped_meta);
+                auto dumped_meta_str = to_string(*dumped_meta);
 
                 oxenc::bt_dict_consumer combined{dumped_meta_str};
                 // NB: must read in ascii-sorted order:
                 if (!combined.skip_until("info"))
                     throw std::runtime_error{"info dump not found in combined dump!"};
-                dumped_info = session::to_unsigned_sv(combined.consume_string_view());
+                dumped_info = session::to_span(combined.consume_string_view());
 
                 if (!combined.skip_until("keys"))
                     throw std::runtime_error{"keys dump not found in combined dump!"};
-                dumped_keys = session::to_unsigned_sv(combined.consume_string_view());
+                dumped_keys = session::to_span(combined.consume_string_view());
 
                 if (!combined.skip_until("members"))
                     throw std::runtime_error{"members dump not found in combined dump!"};
-                dumped_members = session::to_unsigned_sv(combined.consume_string_view());
+                dumped_members = session::to_span(combined.consume_string_view());
             }
 
             // Note, we keep shared_ptr for those as the Keys one need a reference to Members and

src/multi_encrypt/multi_encrypt.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <napi.h>
+#include <span>
+#include <vector>
 
 #include <algorithm>
 
@@ -58,7 +60,7 @@ class MultiEncryptWrapper : public Napi::ObjectWrap<MultiEncryptWrapper> {
             auto messagesJSValue = obj.Get("messages");
             assertIsArray(messagesJSValue);
             auto messagesJS = messagesJSValue.As<Napi::Array>();
-            std::vector<ustring> messages;
+            std::vector<std::vector<unsigned char>> messages;
             messages.reserve(messagesJS.Length());
             for (uint32_t i = 0; i < messagesJS.Length(); i++) {
                 auto itemValue = messagesJS.Get(i);
@@ -71,18 +73,18 @@ class MultiEncryptWrapper : public Napi::ObjectWrap<MultiEncryptWrapper> {
             auto recipientsJSValue = obj.Get("recipients");
             assertIsArray(recipientsJSValue);
             auto recipientsJS = recipientsJSValue.As<Napi::Array>();
-            std::vector<ustring> recipients;
+            std::vector<std::vector<unsigned char>> recipients;
             recipients.reserve(recipientsJS.Length());
             for (uint32_t i = 0; i < recipientsJS.Length(); i++) {
                 auto itemValue = recipientsJS.Get(i);
                 assertIsUInt8Array(itemValue, "multiEncrypt.itemValue.recipient");
                 auto item = toCppBuffer(itemValue, "multiEncrypt.itemValue.recipient");
                 recipients.push_back(item);
             }
-            ustring random_nonce = session::random::random(24);
+            std::vector<unsigned char> random_nonce = session::random::random(24);
 
-            std::vector<ustring_view> messages_sv(messages.begin(), messages.end());
-            std::vector<ustring_view> recipients_sv(recipients.begin(), recipients.end());
+            std::vector<std::span<const unsigned char>> messages_sv(messages.begin(), messages.end());
+            std::vector<std::span<const unsigned char>> recipients_sv(recipients.begin(), recipients.end());
 
             // Note: this function needs the first 2 args to be vector of sv explicitly
             return session::encrypt_for_multiple_simple(

src/user_groups_config.cpp

@@ -4,6 +4,7 @@
 
 #include <iostream>
 #include <optional>
+#include <vector>
 
 #include "base_config.hpp"
 #include "community.hpp"
@@ -158,7 +159,7 @@ Napi::Value UserGroupsWrapper::buildFullUrlFromDetails(const Napi::CallbackInfo&
     return wrapResult(env, [&]() {
         auto [baseUrl, roomId, pubkeyHex] = getStringArgs<3>(info);
 
-        ustring pubkey_bytes;
+        std::vector<unsigned char> pubkey_bytes;
         if (!oxenc::is_hex(pubkeyHex.begin(), pubkeyHex.end()))
             throw std::invalid_argument{"community pubkey is not hex!"};
         oxenc::from_hex(pubkeyHex.begin(), pubkeyHex.end(), std::back_inserter(pubkey_bytes));

src/utilities.cpp

@@ -5,6 +5,7 @@
 #include <chrono>
 
 #include "session/config/namespaces.hpp"
+#include "session/util.hpp"
 
 namespace session::nodeapi {
 
@@ -87,9 +88,9 @@ std::optional<std::string> maybeNonemptyString(Napi::Value x, const std::string&
     throw std::invalid_argument{"maybeNonemptyString with invalid type, called from " + identifier};
 }
 
-// Converts to a ustring_view that views directly into the Uint8Array data of `x`.  Throws if x is
+// Converts to a std::span<const unsigned char> that views directly into the Uint8Array data of `x`.  Throws if x is
 // not a Uint8Array.  The view must not be used beyond the lifetime of `x`.
-ustring_view toCppBufferView(Napi::Value x, const std::string& identifier) {
+std::span<const unsigned char> toCppBufferView(Napi::Value x, const std::string& identifier) {
     if (x.IsNull() || x.IsUndefined())
         throw std::invalid_argument(
                 "toCppBuffer called with null or undefined with identifier: " + identifier);
@@ -101,15 +102,15 @@ ustring_view toCppBufferView(Napi::Value x, const std::string& identifier) {
     return {u8Array.Data(), u8Array.ByteLength()};
 }
 
-ustring toCppBuffer(Napi::Value x, const std::string& identifier) {
-    return ustring{toCppBufferView(x, std::move(identifier))};
+std::vector<unsigned char> toCppBuffer(Napi::Value x, const std::string& identifier) {
+    return session::to_vector(toCppBufferView(x, std::move(identifier)));
 }
 
-std::optional<ustring> maybeNonemptyBuffer(Napi::Value x, const std::string& identifier) {
+std::optional<std::vector<unsigned char>> maybeNonemptyBuffer(Napi::Value x, const std::string& identifier) {
     if (x.IsNull() || x.IsUndefined())
         return std::nullopt;
 
-    std::optional<ustring> buf{toCppBuffer(x, identifier)};
+    std::optional<std::vector<unsigned char>> buf{toCppBuffer(x, identifier)};
     if (buf->empty())
         buf.reset();
     return buf;
@@ -172,7 +173,7 @@ std::string printable(const char* x, size_t n) {
     return printable(std::string_view{x, n});
 }
 
-std::string printable(ustring_view x) {
+std::string printable(std::span<const unsigned char> x) {
     return printable(reinterpret_cast<const char*>(x.data()), x.size());
 }
 
@@ -208,7 +209,7 @@ Napi::Object push_result_to_JS(
 
 Napi::Object push_key_entry_to_JS(
         const Napi::Env& env,
-        const session::ustring_view& key_data,
+        const std::span<const unsigned char>& key_data,
         const session::config::Namespace& push_namespace) {
     auto obj = Napi::Object::New(env);
 
@@ -219,7 +220,7 @@ Napi::Object push_key_entry_to_JS(
 };
 
 Napi::Object decrypt_result_to_JS(
-        const Napi::Env& env, const std::pair<std::string, ustring> decrypted) {
+        const Napi::Env& env, const std::pair<std::string, std::vector<unsigned char>> decrypted) {
     auto obj = Napi::Object::New(env);
 
     obj["pubkeyHex"] = toJs(env, decrypted.first);