remove gmpf changes

centrifuge · Jul 17, 2024 · b94e44c · b94e44c
1 parent 24baa42
commit b94e44c
Show file tree

Hide file tree

Showing 3 changed files with 59 additions and 61 deletions.
diff --git a/pallets/liquidity-pools/src/gmpf/de.rs b/pallets/liquidity-pools/src/gmpf/de.rs
@@ -36,7 +36,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 	type Error = Error;
 
 	fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("any".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@@ -84,35 +84,35 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 	}
 
 	fn deserialize_f32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("f32".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_f64<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("f64".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_char<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("char".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_str<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("str".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_string<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("string".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_bytes<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("bytes".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_byte_buf<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("byte_buf".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_option<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("option".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@@ -136,10 +136,33 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 	}
 
 	fn deserialize_seq<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("seq".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
+		struct SeqDeserializer<'a, 'de>(&'a mut Deserializer<'de>, usize);
+
+		impl<'de, 'a> SeqAccess<'de> for SeqDeserializer<'a, 'de> {
+			type Error = Error;
+
+			fn next_element_seed<T: DeserializeSeed<'de>>(
+				&mut self,
+				seed: T,
+			) -> Result<Option<T::Value>> {
+				if self.1 > 0 {
+					self.1 -= 1;
+					let value = de::DeserializeSeed::deserialize(seed, &mut *self.0)?;
+					Ok(Some(value))
+				} else {
+					Ok(None)
+				}
+			}
+
+			fn size_hint(&self) -> Option<usize> {
+				Some(self.1)
+			}
+		}
+
 		visitor.visit_seq(SeqDeserializer(self, len))
 	}
 
@@ -153,7 +176,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 	}
 
 	fn deserialize_map<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("map".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_struct<V: Visitor<'de>>(
@@ -175,15 +198,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 	}
 
 	fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("indentifier".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
-		Err(Error::Unimplemented("ignored_any".into()))
-	}
-
-	fn is_human_readable(&self) -> bool {
-		false
+		Err(Error::Unimplemented)
 	}
 }
 
@@ -220,23 +239,3 @@ impl<'de, 'a> VariantAccess<'de> for &'a mut Deserializer<'de> {
 		de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
 	}
 }
-
-struct SeqDeserializer<'a, 'de>(&'a mut Deserializer<'de>, usize);
-
-impl<'de, 'a> SeqAccess<'de> for SeqDeserializer<'a, 'de> {
-	type Error = Error;
-
-	fn next_element_seed<T: DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>> {
-		if self.1 > 0 {
-			self.1 -= 1;
-			let value = de::DeserializeSeed::deserialize(seed, &mut *self.0)?;
-			Ok(Some(value))
-		} else {
-			Ok(None)
-		}
-	}
-
-	fn size_hint(&self) -> Option<usize> {
-		Some(self.1)
-	}
-}
diff --git a/pallets/liquidity-pools/src/gmpf/error.rs b/pallets/liquidity-pools/src/gmpf/error.rs
@@ -1,41 +1,44 @@
-use scale_info::prelude::string::{String, ToString};
+use scale_info::prelude::string::ToString;
 use serde::{de, ser};
-use sp_std::fmt::{self, Display};
+use sp_std::{
+	fmt::{self, Display},
+	vec::Vec,
+};
 
 pub type Result<T> = sp_std::result::Result<T, Error>;
 
 #[derive(Debug)]
 pub enum Error {
-	Message(String),
+	Message(Vec<u8>),
 	EnumSize,
-	Unimplemented(String),
+	Unimplemented,
 	UnknownSize,
 	Eof,
 }
 
 impl ser::Error for Error {
 	fn custom<T: Display>(msg: T) -> Self {
-		Error::Message(msg.to_string())
+		Error::Message(msg.to_string().into_bytes())
 	}
 }
 
 impl de::Error for Error {
 	fn custom<T: Display>(msg: T) -> Self {
-		Error::Message(msg.to_string())
+		Error::Message(msg.to_string().into_bytes())
 	}
 }
 
 impl Display for Error {
 	fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 		let msg = match self {
-			Error::Message(string) => string.clone(),
-			Error::EnumSize => "enum variant size too large to serialize(> 255)".into(),
-			Error::Unimplemented(who) => format!("unimplemented '{who}'"),
-			Error::UnknownSize => "sequence size is not known".into(),
-			Error::Eof => "End of file".into(),
+			Error::Message(msg) => sp_std::str::from_utf8(msg).unwrap_or(""),
+			Error::EnumSize => "enum variant size too large to serialize(> 255)",
+			Error::Unimplemented => "unimplemented serialization",
+			Error::UnknownSize => "sequence size is not known",
+			Error::Eof => "End of file",
 		};
 
-		formatter.write_str(&msg)
+		formatter.write_str(msg)
 	}
 }
 

diff --git a/pallets/liquidity-pools/src/gmpf/ser.rs b/pallets/liquidity-pools/src/gmpf/ser.rs
@@ -82,19 +82,19 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 	}
 
 	fn serialize_f32(self, _v: f32) -> Result<()> {
-		Err(Error::Unimplemented("f32".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_f64(self, _v: f64) -> Result<()> {
-		Err(Error::Unimplemented("f64".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_char(self, _v: char) -> Result<()> {
-		Err(Error::Unimplemented("char".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_str(self, _v: &str) -> Result<()> {
-		Err(Error::Unimplemented("str".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_bytes(self, v: &[u8]) -> Result<()> {
@@ -103,11 +103,11 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 	}
 
 	fn serialize_none(self) -> Result<()> {
-		Err(Error::Unimplemented("none".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> Result<()> {
-		Err(Error::Unimplemented("some".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_unit(self) -> Result<()> {
@@ -152,7 +152,7 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 	}
 
 	fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-		Err(Error::Unimplemented("seq".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
@@ -180,7 +180,7 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 	}
 
 	fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-		Err(Error::Unimplemented("map".into()))
+		Err(Error::Unimplemented)
 	}
 
 	fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
@@ -198,10 +198,6 @@ impl<'a> ser::Serializer for &'a mut Serializer {
 		self.output.push(index);
 		Ok(self)
 	}
-
-	fn is_human_readable(&self) -> bool {
-		false
-	}
 }
 
 impl<'a> ser::SerializeSeq for &'a mut Serializer {