feat: multi message rust

contracts/cosmwasm-vm/cw-xcall-lib/Cargo.toml

@@ -36,7 +36,7 @@ schemars = {workspace=true}
 serde = { workspace=true}
 thiserror = { workspace=true}
 debug_print={workspace=true}
-
+common = { git = "https://github.com/icon-project/IBC-Integration.git",branch="main" }
 
 
 [dev-dependencies]

contracts/cosmwasm-vm/cw-xcall-lib/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod dapp_msg;
 pub mod dapp_multi_msg;
+pub mod message;
 pub mod network_address;
 pub mod xcall_connection_msg;
 pub mod xcall_msg;

contracts/cosmwasm-vm/cw-xcall-lib/src/message/call_message.rs

@@ -0,0 +1,58 @@
+use common::rlp::{self, Decodable, DecoderError, Encodable, RlpStream};
+
+use super::{msg_trait::IMessage, msg_type::MessageType};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CallMessage {
+    pub msg_type: MessageType,
+    pub data: Vec<u8>,
+}
+
+impl Encodable for CallMessage {
+    fn rlp_append(&self, stream: &mut RlpStream) {
+        stream
+            .begin_list(2)
+            .append(&Into::<u8>::into(self.msg_type.clone()))
+            .append(&self.data);
+    }
+}
+
+impl Decodable for CallMessage {
+    fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
+        let msg_type: u8 = rlp.val_at(0)?;
+
+        Ok(Self {
+            msg_type: MessageType::from(msg_type),
+            data: rlp.val_at(1)?,
+        })
+    }
+}
+
+impl IMessage for CallMessage {
+    fn rollback(&self) -> Option<Vec<u8>> {
+        None
+    }
+
+    fn data(&self) -> Vec<u8> {
+        self.data.clone()
+    }
+
+    fn msg_type(&self) -> &MessageType {
+        &self.msg_type
+    }
+
+    fn should_persist(&self) -> bool {
+        false
+    }
+
+    fn to_bytes(&self) -> Result<Vec<u8>, DecoderError> {
+        Ok(rlp::encode(self).to_vec())
+    }
+
+    // fn from_bytes(bytes: Vec<u8>) -> Result<Self, rlp::DecoderError> {
+    //     let rlp = rlp::Rlp::new(&bytes);
+    //     let msg = Self::decode(&rlp)?;
+
+    //     Ok(msg)
+    // }
+}

contracts/cosmwasm-vm/cw-xcall-lib/src/message/call_message_rollback.rs

@@ -0,0 +1,60 @@
+use common::rlp::{self, Decodable, DecoderError, Encodable, RlpStream};
+
+use super::{msg_trait::IMessage, msg_type::MessageType};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CallMessageWithRollback {
+    pub msg_type: MessageType,
+    pub data: Vec<u8>,
+    pub rollback: Vec<u8>,
+}
+
+impl Encodable for CallMessageWithRollback {
+    fn rlp_append(&self, stream: &mut RlpStream) {
+        stream
+            .begin_list(2)
+            .append(&Into::<u8>::into(self.msg_type.clone()))
+            .append(&self.data)
+            .append(&self.rollback);
+    }
+}
+
+impl Decodable for CallMessageWithRollback {
+    fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
+        let msg_type: u8 = rlp.val_at(0)?;
+
+        Ok(Self {
+            msg_type: MessageType::from(msg_type),
+            data: rlp.val_at(1)?,
+            rollback: rlp.val_at(2)?,
+        })
+    }
+}
+
+impl IMessage for CallMessageWithRollback {
+    fn rollback(&self) -> Option<Vec<u8>> {
+        Some(self.rollback.clone())
+    }
+
+    fn data(&self) -> Vec<u8> {
+        self.data.clone()
+    }
+
+    fn msg_type(&self) -> &MessageType {
+        &self.msg_type
+    }
+
+    fn should_persist(&self) -> bool {
+        true
+    }
+    fn to_bytes(&self) -> Result<Vec<u8>, DecoderError> {
+        Ok(rlp::encode(self).to_vec())
+    }
+
+    //    fn from_bytes(bytes: Vec<u8>) -> Result<Self, rlp::DecoderError> {
+    //         let rlp = rlp::Rlp::new(&bytes);
+    //         let msg = Self::decode(&rlp)?;
+
+    //         Ok(msg)
+    //     }
+}

contracts/cosmwasm-vm/cw-xcall-lib/src/message/envelope.rs

@@ -0,0 +1,116 @@
+use common::rlp::{self, Decodable, DecoderError, Encodable};
+
+use super::{
+    call_message::CallMessage, call_message_rollback::CallMessageWithRollback, msg_trait::IMessage,
+    msg_type::MessageType, AnyMessage,
+};
+#[derive(Clone, Debug, PartialEq)]
+pub struct Envelope {
+    pub message: AnyMessage,
+    pub sources: Vec<String>,
+    pub destinations: Vec<String>,
+}
+
+impl Envelope {
+    pub fn new(msg: AnyMessage, sources: Vec<String>, destinations: Vec<String>) -> Self {
+        Self {
+            message: msg,
+            sources,
+            destinations,
+        }
+    }
+}
+
+impl Encodable for Envelope {
+    fn rlp_append(&self, stream: &mut common::rlp::RlpStream) {
+        stream.begin_list(4);
+        stream.append(&Into::<u8>::into(self.message.msg_type().clone()));
+        stream.append(&self.message.to_bytes().unwrap());
+        stream.begin_list(self.sources.len());
+        for source in self.sources.iter() {
+            stream.append(source);
+        }
+        stream.begin_list(self.destinations.len());
+        for dest in self.destinations.iter() {
+            stream.append(dest);
+        }
+    }
+}
+
+impl Decodable for Envelope {
+    fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
+        let msg_int: u8 = rlp.val_at(0)?;
+        let msg_type = MessageType::from(msg_int);
+        let message_bytes: Vec<u8> = rlp.val_at(1)?;
+        let message = decode_message(msg_type, message_bytes)?;
+
+        let sources = rlp.at(2)?;
+        let sources: Vec<String> = sources.as_list()?;
+        let destinations = rlp.at(3)?;
+        let destinations: Vec<String> = destinations.as_list()?;
+
+        Ok(Envelope {
+            message,
+            sources,
+            destinations,
+        })
+    }
+}
+
+pub fn decode_message(msg_type: MessageType, bytes: Vec<u8>) -> Result<AnyMessage, DecoderError> {
+    match msg_type {
+        MessageType::BasicMessage => {
+            let msg: CallMessage = rlp::decode(&bytes)?;
+            Ok(AnyMessage::CallMessage(msg))
+        }
+        MessageType::MessageWithRollback => {
+            let msg: CallMessageWithRollback = rlp::decode(&bytes)?;
+            Ok(AnyMessage::CallMessageWithRollback(msg))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_encoding_decoding_envelope_call_message() {
+        // Create a sample Envelope
+        let message = AnyMessage::CallMessage(CallMessage {
+            msg_type: MessageType::BasicMessage,
+            data: vec![1, 2, 3],
+        });
+        let sources = vec!["source1".to_string(), "source2".to_string()];
+        let destinations = vec!["dest1".to_string(), "dest2".to_string()];
+        let envelope = Envelope::new(message, sources, destinations);
+        let encoded_data = rlp::encode(&envelope).to_vec();
+
+        assert_eq!(
+            "e60186c50183010203d087736f757263653187736f7572636532cc856465737431856465737432",
+            hex::encode(&encoded_data)
+        );
+        let decoded: Envelope = rlp::decode(&encoded_data).unwrap();
+
+        assert_eq!(envelope, decoded);
+    }
+
+    #[test]
+    fn test_encoding_decoding_envelope_call_message_rollback() {
+        // Create a sample Envelope
+        let message = AnyMessage::CallMessageWithRollback(CallMessageWithRollback {
+            msg_type: MessageType::MessageWithRollback,
+            data: vec![1, 2, 3],
+            rollback: vec![1, 2, 3],
+        });
+        let sources = vec!["source1".to_string(), "source2".to_string()];
+        let destinations = vec!["dest1".to_string(), "dest2".to_string()];
+        let envelope = Envelope::new(message, sources, destinations);
+        let encoded_data = rlp::encode(&envelope).to_vec();
+
+        assert_eq!("ea028ac5028301020383010203d087736f757263653187736f7572636532cc856465737431856465737432",hex::encode(&encoded_data));
+        let decoded: Envelope = rlp::decode(&encoded_data).unwrap();
+
+        assert_eq!(envelope, decoded);
+    }
+}

contracts/cosmwasm-vm/cw-xcall-lib/src/message/mod.rs

@@ -0,0 +1,77 @@
+use common::rlp::DecoderError;
+
+use self::{
+    call_message::CallMessage, call_message_rollback::CallMessageWithRollback, msg_trait::IMessage,
+    msg_type::MessageType,
+};
+
+pub mod call_message;
+pub mod call_message_rollback;
+pub mod envelope;
+pub mod msg_trait;
+pub mod msg_type;
+#[derive(Clone, Debug, PartialEq)]
+pub enum AnyMessage {
+    CallMessage(CallMessage),
+    CallMessageWithRollback(CallMessageWithRollback),
+}
+
+impl IMessage for AnyMessage {
+    fn rollback(&self) -> Option<Vec<u8>> {
+        match self {
+            AnyMessage::CallMessage(m) => m.rollback(),
+            AnyMessage::CallMessageWithRollback(m) => m.rollback(),
+        }
+    }
+
+    fn data(&self) -> Vec<u8> {
+        match self {
+            AnyMessage::CallMessage(m) => m.data(),
+            AnyMessage::CallMessageWithRollback(m) => m.data(),
+        }
+    }
+
+    fn msg_type(&self) -> &MessageType {
+        match self {
+            AnyMessage::CallMessage(m) => m.msg_type(),
+            AnyMessage::CallMessageWithRollback(m) => m.msg_type(),
+        }
+    }
+
+    fn should_persist(&self) -> bool {
+        match self {
+            AnyMessage::CallMessage(m) => m.should_persist(),
+            AnyMessage::CallMessageWithRollback(m) => m.should_persist(),
+        }
+    }
+
+    fn to_bytes(&self) -> Result<Vec<u8>, DecoderError> {
+        match self {
+            AnyMessage::CallMessage(m) => m.to_bytes(),
+            AnyMessage::CallMessageWithRollback(m) => m.to_bytes(),
+        }
+    }
+
+    // fn from_bytes(bytes:Vec<u8>)->Result<Self,DecoderError> {
+    //     todo!()
+    // }
+}
+
+// impl Encodable for AnyMessage {
+//     fn rlp_append(&self, s: &mut common::rlp::RlpStream) {
+//         match self{
+//             AnyMessage::CallMessage(m)=>{
+//                 s.append(&rlp::encode(m));
+//             },
+//             AnyMessage::CallMessageWithRollback(m)=>{
+//                 s.append(&rlp::encode(m));
+//             }
+//         }
+//     }
+// }
+
+// impl Decodable for AnyMessage {
+//     fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
+
+//     }
+// }

contracts/cosmwasm-vm/cw-xcall-lib/src/message/msg_trait.rs

@@ -0,0 +1,22 @@
+use common::rlp::DecoderError;
+
+use super::msg_type::MessageType;
+
+pub trait IMessage: Clone {
+    fn rollback(&self) -> Option<Vec<u8>>;
+    fn data(&self) -> Vec<u8>;
+    fn msg_type(&self) -> &MessageType;
+    // fn from_bytes(bytes: Vec<u8>) -> Result<Self, rlp::DecoderError> {
+    //     let rlp = rlp::Rlp::new(&bytes);
+    //     let msg = Self::decode(&rlp)?;
+
+    //     Ok(msg)
+    // }
+
+    // fn to_bytes(&self) -> Vec<u8> {
+    //     rlp::encode(self).to_vec()
+    // }
+    fn should_persist(&self) -> bool;
+    fn to_bytes(&self) -> Result<Vec<u8>, DecoderError>;
+    //fn from_bytes(bytes:Vec<u8>)->Result<Self,DecoderError>;
+}

contracts/cosmwasm-vm/cw-xcall-lib/src/message/msg_type.rs

@@ -0,0 +1,35 @@
+use serde::Serialize;
+
+#[derive(Clone, Debug, Serialize, serde::Deserialize, PartialEq, Eq)]
+pub enum MessageType {
+    BasicMessage = 1,
+    MessageWithRollback = 2,
+}
+
+impl From<MessageType> for u8 {
+    fn from(val: MessageType) -> Self {
+        match val {
+            MessageType::BasicMessage => 1,
+            MessageType::MessageWithRollback => 2,
+        }
+    }
+}
+
+impl From<u8> for MessageType {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => MessageType::BasicMessage,
+            2 => MessageType::MessageWithRollback,
+            _ => panic!("unsupported message type"),
+        }
+    }
+}
+
+impl MessageType {
+    pub fn as_int(&self) -> u8 {
+        self.clone().into()
+    }
+    pub fn from_int(val: u8) -> Self {
+        MessageType::from(val)
+    }
+}