LPv2: Batch Message serialization (#1920)

* custo serialize/deserialize for batch

* compiling solution

* serialization/deserialization working for batch message

* remove gmpf changes

* add batch nested protection

* faster serialization for submessages

* correct termination

* add tests for deserialize batch of batch

* add into_iter

* remove unused Box and add pack methods

* fix non_std compilation

* non_std

* fix max_encoded_len recursion issue

* fix submodules

* reduce batch limit

pallets/liquidity-pools/src/gmpf/error.rs

@@ -1,15 +1,12 @@
-use scale_info::prelude::string::ToString;
+use scale_info::prelude::string::{String, ToString};
 use serde::{de, ser};
-use sp_std::{
-	fmt::{self, Display},
-	vec::Vec,
-};
+use sp_std::fmt::{self, Display};
 
 pub type Result<T> = sp_std::result::Result<T, Error>;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Error {
-	Message(Vec<u8>),
+	Message(String),
 	EnumSize,
 	Unimplemented,
 	UnknownSize,
@@ -18,20 +15,20 @@ pub enum Error {
 
 impl ser::Error for Error {
 	fn custom<T: Display>(msg: T) -> Self {
-		Error::Message(msg.to_string().into_bytes())
+		Error::Message(msg.to_string())
 	}
 }
 
 impl de::Error for Error {
 	fn custom<T: Display>(msg: T) -> Self {
-		Error::Message(msg.to_string().into_bytes())
+		Error::Message(msg.to_string())
 	}
 }
 
 impl Display for Error {
 	fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 		let msg = match self {
-			Error::Message(msg) => sp_std::str::from_utf8(msg).unwrap_or(""),
+			Error::Message(msg) => msg,
 			Error::EnumSize => "enum variant size too large to serialize(> 255)",
 			Error::Unimplemented => "unimplemented serialization",
 			Error::UnknownSize => "sequence size is not known",

pallets/liquidity-pools/src/gmpf/ser.rs

@@ -151,8 +151,12 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 		value.serialize(self)
 	}
 
-	fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-		Err(Error::Unimplemented)
+	fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+		let len: u16 = len
+			.and_then(|len| len.try_into().ok())
+			.ok_or(Error::UnknownSize)?;
+		self.output.extend(&len.to_be_bytes());
+		Ok(self)
 	}
 
 	fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {

pallets/liquidity-pools/src/lib.rs

@@ -83,6 +83,8 @@ mod gmpf {
 	mod ser;
 
 	pub use de::from_slice;
+	#[cfg(test)]
+	pub use error::Error;
 	pub use ser::to_vec;
 }