Replaced BoundedString with BoundedVec

Author: Klapeyron

node/runtime/src/lib.rs

@@ -33,7 +33,7 @@ use parity_scale_codec::MaxEncodedLen;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use serde::{Deserialize, Serialize};
-use sidechain_domain::byte_string::{BoundedString, SizedByteString};
+use sidechain_domain::byte_string::SizedByteString;
 use sidechain_domain::{
 	CrossChainPublicKey, DelegatorKey, MainchainKeyHash, PermissionedCandidateData,
 	RegistrationData, ScEpochNumber, ScSlotNumber, StakeDelegation, StakePoolPublicKey, UtxoId,
@@ -461,13 +461,15 @@ impl AsCardanoSPO for BlockAuthor {
 	}
 }
 
-pub const MAX_METADATA_URL_LENGTH: u32 = 512;
+parameter_types! {
+	pub const MaxMetadataUrlLength: u32 = 512;
+}
 
 #[derive(
 	Clone, Debug, MaxEncodedLen, Encode, Decode, Serialize, Deserialize, PartialEq, Eq, TypeInfo,
 )]
 pub struct BlockProducerMetadataType {
-	pub url: BoundedString<MAX_METADATA_URL_LENGTH>,
+	pub url: BoundedVec<u8, MaxMetadataUrlLength>,
 	pub hash: SizedByteString<32>,
 }
 

toolkit/sidechain/domain/src/byte_string.rs

@@ -1,14 +1,7 @@
-use core::fmt::{Debug, Display};
-
 use alloc::vec::Vec;
 use byte_string_derive::byte_string;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
-use serde::de::Error as DeError;
-use serde::ser::Error as SerError;
-use serde::{Deserialize, Serialize};
-use sp_core::bounded::BoundedVec;
-use sp_core::ConstU32;
 
 /// Wrapper for bytes that is serialized as hex string
 /// To be used for binary data that we want to display nicely but
@@ -52,54 +45,3 @@ impl<const N: usize> Default for SizedByteString<N> {
 		Self([0; N])
 	}
 }
-
-/// Byte-encoded text string with bounded length
-#[derive(Eq, Clone, PartialEq, TypeInfo, Default, Encode, Decode, MaxEncodedLen)]
-pub struct BoundedString<const N: u32>(pub BoundedVec<u8, ConstU32<N>>);
-
-impl<const N: u32> TryFrom<Vec<u8>> for BoundedString<N> {
-	type Error = <BoundedVec<u8, ConstU32<N>> as TryFrom<Vec<u8>>>::Error;
-
-	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
-		Ok(Self(value.try_into()?))
-	}
-}
-
-impl<'a, const N: u32> Deserialize<'a> for BoundedString<N> {
-	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-	where
-		D: serde::Deserializer<'a>,
-	{
-		Ok(Self(
-			BoundedVec::try_from(
-				alloc::string::String::deserialize(deserializer)?.as_bytes().to_vec(),
-			)
-			.map_err(|_| D::Error::custom("Size limit exceeded"))?,
-		))
-	}
-}
-
-impl<const N: u32> Serialize for BoundedString<N> {
-	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: serde::Serializer,
-	{
-		let str = alloc::string::String::from_utf8(self.0.to_vec())
-			.map_err(|_| S::Error::custom("String is not valid UTF-8"))?;
-		serializer.serialize_str(&str)
-	}
-}
-
-impl<const N: u32> Display for BoundedString<N> {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-		f.write_str(
-			&alloc::string::String::from_utf8(self.0.to_vec()).map_err(|_| core::fmt::Error)?,
-		)
-	}
-}
-
-impl<const N: u32> Debug for BoundedString<N> {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-		f.write_str(&alloc::format!("BoundedString<{}>({:?})", N, self.0))
-	}
-}