Remove the metadata type enum in favour of allowing the client to def…

…ine whatever they want

base_layer/chat_ffi/chat.h

@@ -675,9 +675,7 @@ struct ChatByteVector *read_chat_message_id(struct Message *message, int *error_
  *
  * ## Arguments
  * `message` - A pointer to a message
- * `metadata_type` - An c_uchar that maps to MessageMetadataType enum
- *     '0' -> Reply
- *     '1' -> TokenRequest
+ * `key` - A pointer to a byte vector containing bytes for the key field
  * `data` - A pointer to a byte vector containing bytes for the data field
  * `error_out` - Pointer to an int which will be modified
  *
@@ -688,7 +686,7 @@ struct ChatByteVector *read_chat_message_id(struct Message *message, int *error_
  * `message` should be destroyed eventually
  */
 void add_chat_message_metadata(struct Message *message,
-                               unsigned char metadata_type,
+                               struct ChatByteVector *key,
                                struct ChatByteVector *data,
                                int *error_out);
 
@@ -700,16 +698,13 @@ void add_chat_message_metadata(struct Message *message,
  * `error_out` - Pointer to an int which will be modified
  *
  * ## Returns
- * `c_uchar` - An uint8 that maps to MessageMetadataType enum. May return 0 if something goes wrong
- *     '0' -> Reply
- *     '1' -> TokenRequest
- *     '2' -> Gif
- *     '3' -> Link
+ * `*mut ChatByteVector` - A ptr to a ChatByteVector
  *
  * ## Safety
  * `msg_metadata` should be destroyed eventually
+ * the returned `ChatByteVector` should be destroyed eventually
  */
-unsigned char read_chat_metadata_type(struct MessageMetadata *msg_metadata, int *error_out);
+struct ChatByteVector *read_chat_metadata_key(struct MessageMetadata *msg_metadata, int *error_out);
 
 /**
  * Returns a ptr to a ByteVector

base_layer/chat_ffi/src/byte_vector.rs

@@ -152,3 +152,17 @@ pub unsafe extern "C" fn chat_byte_vector_get_length(vec: *const ChatByteVector,
 
     (*vec).0.len() as c_uint
 }
+
+pub(crate) unsafe fn process_vector(vector: *mut ChatByteVector, error_out: *mut c_int) -> Vec<u8> {
+    let data_byte_vector_length = chat_byte_vector_get_length(vector, error_out);
+    let mut bytes: Vec<u8> = Vec::new();
+
+    if data_byte_vector_length > 0 {
+        for c in 0..data_byte_vector_length {
+            let byte = chat_byte_vector_get_at(vector, c as c_uint, error_out);
+            bytes.push(byte);
+        }
+    }
+
+    bytes
+}

base_layer/chat_ffi/src/message_metadata.rs

@@ -22,22 +22,20 @@
 
 use std::{convert::TryFrom, ptr};
 
-use libc::{c_int, c_uchar, c_uint};
-use tari_contacts::contacts_service::types::{Message, MessageMetadata, MessageMetadataType};
+use libc::{c_int, c_uint};
+use tari_contacts::contacts_service::types::{Message, MessageMetadata};
 use tari_utilities::ByteArray;
 
 use crate::{
-    byte_vector::{chat_byte_vector_create, chat_byte_vector_get_at, chat_byte_vector_get_length, ChatByteVector},
+    byte_vector::{chat_byte_vector_create, process_vector, ChatByteVector},
     error::{InterfaceError, LibChatError},
 };
 
 /// Creates message metadata and appends it to a Message
 ///
 /// ## Arguments
 /// `message` - A pointer to a message
-/// `metadata_type` - An c_uchar that maps to MessageMetadataType enum
-///     '0' -> Reply
-///     '1' -> TokenRequest
+/// `key` - A pointer to a byte vector containing bytes for the key field
 /// `data` - A pointer to a byte vector containing bytes for the data field
 /// `error_out` - Pointer to an int which will be modified
 ///
@@ -49,51 +47,26 @@ use crate::{
 #[no_mangle]
 pub unsafe extern "C" fn add_chat_message_metadata(
     message: *mut Message,
-    metadata_type: c_uchar,
+    key: *mut ChatByteVector,
     data: *mut ChatByteVector,
     error_out: *mut c_int,
 ) {
     let mut error = 0;
     ptr::swap(error_out, &mut error as *mut c_int);
 
-    if message.is_null() {
-        error = LibChatError::from(InterfaceError::NullError("message".to_string())).code;
-        ptr::swap(error_out, &mut error as *mut c_int);
-        return;
-    }
-
-    let metadata_type = match MessageMetadataType::from_byte(metadata_type) {
-        Some(t) => t,
-        None => {
-            error = LibChatError::from(InterfaceError::InvalidArgument(
-                "Couldn't convert byte to Metadata type".to_string(),
-            ))
-            .code;
+    for (name, d) in [("key", key), ("data", data)] {
+        if d.is_null() {
+            error = LibChatError::from(InterfaceError::NullError(name.to_string())).code;
             ptr::swap(error_out, &mut error as *mut c_int);
             return;
-        },
-    };
-
-    if data.is_null() {
-        error = LibChatError::from(InterfaceError::NullError("data".to_string())).code;
-        ptr::swap(error_out, &mut error as *mut c_int);
-        return;
-    }
-
-    let chat_byte_vector_length = chat_byte_vector_get_length(data, error_out);
-    let mut bytes: Vec<u8> = Vec::new();
-
-    if chat_byte_vector_length > 0 {
-        for c in 0..chat_byte_vector_length {
-            let byte = chat_byte_vector_get_at(data, c as c_uint, error_out);
-            bytes.push(byte);
         }
     }
 
     let metadata = MessageMetadata {
-        metadata_type,
-        data: bytes,
+        key: process_vector(key, error_out),
+        data: process_vector(data, error_out),
     };
+
     (*message).push(metadata);
 }
 
@@ -104,34 +77,37 @@ pub unsafe extern "C" fn add_chat_message_metadata(
 /// `error_out` - Pointer to an int which will be modified
 ///
 /// ## Returns
-/// `c_uchar` - An uint8 that maps to MessageMetadataType enum. May return 0 if something goes wrong
-///     '0' -> Reply
-///     '1' -> TokenRequest
-///     '2' -> Gif
-///     '3' -> Link
+/// `*mut ChatByteVector` - A ptr to a ChatByteVector
 ///
 /// ## Safety
 /// `msg_metadata` should be destroyed eventually
+/// the returned `ChatByteVector` should be destroyed eventually
 #[no_mangle]
-pub unsafe extern "C" fn read_chat_metadata_type(msg_metadata: *mut MessageMetadata, error_out: *mut c_int) -> c_uchar {
+pub unsafe extern "C" fn read_chat_metadata_key(
+    msg_metadata: *mut MessageMetadata,
+    error_out: *mut c_int,
+) -> *mut ChatByteVector {
     let mut error = 0;
     ptr::swap(error_out, &mut error as *mut c_int);
 
     if msg_metadata.is_null() {
         error = LibChatError::from(InterfaceError::NullError("message".to_string())).code;
         ptr::swap(error_out, &mut error as *mut c_int);
-        return 0;
+        return ptr::null_mut();
     }
 
-    let md = &(*msg_metadata);
-    match c_uchar::try_from(md.metadata_type.as_byte()) {
-        Ok(t) => t,
-        Err(e) => {
-            error = LibChatError::from(InterfaceError::ConversionError(e.to_string())).code;
+    let data = (*msg_metadata).key.clone();
+    let data_bytes = data.as_bytes();
+    let len = match c_uint::try_from(data_bytes.len()) {
+        Ok(num) => num,
+        Err(_e) => {
+            error = LibChatError::from(InterfaceError::PositionInvalidError).code;
             ptr::swap(error_out, &mut error as *mut c_int);
-            0
+            return ptr::null_mut();
         },
-    }
+    };
+
+    chat_byte_vector_create(data_bytes.as_ptr(), len, error_out)
 }
 
 /// Returns a ptr to a ByteVector
@@ -201,7 +177,12 @@ mod test {
 
     use super::*;
     use crate::{
-        byte_vector::{chat_byte_vector_create, chat_byte_vector_destroy},
+        byte_vector::{
+            chat_byte_vector_create,
+            chat_byte_vector_destroy,
+            chat_byte_vector_get_at,
+            chat_byte_vector_get_length,
+        },
         message::{chat_metadata_get_at, destroy_chat_message},
     };
 
@@ -212,10 +193,15 @@ mod test {
 
         let data = "hello".to_string();
         let data_bytes = data.as_bytes();
-        let len = u32::try_from(data.len()).expect("Can't cast from usize");
-        let data = unsafe { chat_byte_vector_create(data_bytes.as_ptr(), len as c_uint, error_out) };
+        let data_len = u32::try_from(data.len()).expect("Can't cast from usize");
+        let data = unsafe { chat_byte_vector_create(data_bytes.as_ptr(), data_len as c_uint, error_out) };
 
-        unsafe { add_chat_message_metadata(message_ptr, 0, data, error_out) }
+        let key = "gif".to_string();
+        let key_bytes = key.as_bytes();
+        let key_len = u32::try_from(key.len()).expect("Can't cast from usize");
+        let key = unsafe { chat_byte_vector_create(key_bytes.as_ptr(), key_len as c_uint, error_out) };
+
+        unsafe { add_chat_message_metadata(message_ptr, key, data, error_out) }
 
         let message = unsafe { Box::from_raw(message_ptr) };
         assert_eq!(message.metadata.len(), 1);
@@ -243,28 +229,41 @@ mod test {
             let data_bytes = data.as_bytes();
             let len = u32::try_from(data.len()).expect("Can't cast from usize");
             let data = chat_byte_vector_create(data_bytes.as_ptr(), len as c_uint, error_out);
-            let md_type = 0;
 
-            add_chat_message_metadata(message_ptr, md_type, data, error_out);
+            let key = "gif".to_string();
+            let key_bytes = key.as_bytes();
+            let len = u32::try_from(key.len()).expect("Can't cast from usize");
+            let key = chat_byte_vector_create(key_bytes.as_ptr(), len as c_uint, error_out);
+
+            add_chat_message_metadata(message_ptr, key, data, error_out);
 
             let metadata_ptr = chat_metadata_get_at(message_ptr, 0, error_out);
 
-            let metadata_type = read_chat_metadata_type(metadata_ptr, error_out);
-            let metadata_byte_vector = read_chat_metadata_data(metadata_ptr, error_out);
-            let metadata_byte_vector_len = chat_byte_vector_get_length(metadata_byte_vector, error_out);
+            let metadata_key_vector = read_chat_metadata_key(metadata_ptr, error_out);
+            let metadata_key_vector_len = chat_byte_vector_get_length(metadata_key_vector, error_out);
+
+            let mut metadata_key = vec![];
+
+            for i in 0..metadata_key_vector_len {
+                metadata_key.push(chat_byte_vector_get_at(metadata_key_vector, i, error_out));
+            }
+
+            let metadata_data_vector = read_chat_metadata_data(metadata_ptr, error_out);
+            let metadata_data_vector_len = chat_byte_vector_get_length(metadata_data_vector, error_out);
 
             let mut metadata_data = vec![];
 
-            for i in 0..metadata_byte_vector_len {
-                metadata_data.push(chat_byte_vector_get_at(metadata_byte_vector, i, error_out));
+            for i in 0..metadata_data_vector_len {
+                metadata_data.push(chat_byte_vector_get_at(metadata_data_vector, i, error_out));
             }
 
-            assert_eq!(metadata_type, md_type);
+            assert_eq!(metadata_key, key_bytes);
             assert_eq!(metadata_data, data_bytes);
 
             destroy_chat_message_metadata(metadata_ptr);
             destroy_chat_message(message_ptr);
-            chat_byte_vector_destroy(metadata_byte_vector);
+            chat_byte_vector_destroy(metadata_key_vector);
+            chat_byte_vector_destroy(metadata_data_vector);
             drop(Box::from_raw(error_out));
         }
     }

base_layer/contacts/proto/message.proto

@@ -18,14 +18,10 @@ enum DirectionEnum {
 }
 
 message MessageMetadata {
-  MessageTypeEnum metadata_type = 1;
+  bytes key = 1;
   bytes data = 2;
 }
 
-enum MessageTypeEnum {
-  TokenRequest = 0;
-}
-
 message Confirmation {
   bytes message_id = 1;
   uint64 timestamp = 2;

base_layer/contacts/src/chat_client/src/client.rs

@@ -34,7 +34,7 @@ use tari_comms::{peer_manager::PeerFeatures, CommsNode, NodeIdentity};
 use tari_contacts::contacts_service::{
     handle::ContactsServiceHandle,
     service::ContactOnlineStatus,
-    types::{Message, MessageBuilder, MessageMetadata, MessageMetadataType},
+    types::{Message, MessageBuilder, MessageMetadata},
 };
 use tari_shutdown::Shutdown;
 
@@ -45,7 +45,7 @@ const LOG_TARGET: &str = "contacts::chat_client";
 #[async_trait]
 pub trait ChatClient {
     async fn add_contact(&self, address: &TariAddress) -> Result<(), Error>;
-    fn add_metadata(&self, message: Message, metadata_type: MessageMetadataType, data: String) -> Message;
+    fn add_metadata(&self, message: Message, metadata_type: String, data: String) -> Message;
     async fn check_online_status(&self, address: &TariAddress) -> Result<ContactOnlineStatus, Error>;
     fn create_message(&self, receiver: &TariAddress, message: String) -> Message;
     async fn get_messages(&self, sender: &TariAddress, limit: u64, page: u64) -> Result<Vec<Message>, Error>;
@@ -198,9 +198,9 @@ impl ChatClient for Client {
         MessageBuilder::new().address(receiver.clone()).message(message).build()
     }
 
-    fn add_metadata(&self, mut message: Message, metadata_type: MessageMetadataType, data: String) -> Message {
+    fn add_metadata(&self, mut message: Message, key: String, data: String) -> Message {
         let metadata = MessageMetadata {
-            metadata_type,
+            key: key.into_bytes(),
             data: data.into_bytes(),
         };