db setup cleanup

primitives/src/shard.rs

@@ -25,81 +25,7 @@ pub type ShardId = u64;
 pub type ProofOfKnowledge = [u8; 65];
 
 #[derive(Encode, Decode, TypeInfo, PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "std", serde(transparent))]
-pub struct Commitment(
-	#[cfg_attr(feature = "std", serde(with = "serde_commitment"))]
-	pub  BoundedVec<TssPublicKey, ConstU32<MAX_SHARD_SIZE>>,
-);
-
-#[cfg(feature = "std")]
-pub mod serde_commitment {
-	use super::{BoundedVec, ConstU32, TssPublicKey, MAX_SHARD_SIZE};
-	use serde::{de::Error as DeError, ser::SerializeSeq, Deserialize, Deserializer, Serializer};
-
-	pub fn serialize<S>(
-		bounded_vec: &BoundedVec<TssPublicKey, ConstU32<MAX_SHARD_SIZE>>,
-		serializer: S,
-	) -> Result<S::Ok, S::Error>
-	where
-		S: Serializer,
-	{
-		let vec: &Vec<TssPublicKey> = bounded_vec.as_ref();
-		let mut seq = serializer.serialize_seq(Some(vec.len()))?;
-		for key in vec {
-			seq.serialize_element(&key[..])?;
-		}
-		seq.end()
-	}
-
-	pub fn deserialize<'de, D>(
-		deserializer: D,
-	) -> Result<BoundedVec<TssPublicKey, ConstU32<MAX_SHARD_SIZE>>, D::Error>
-	where
-		D: Deserializer<'de>,
-	{
-		let raw_keys: Vec<Vec<u8>> = Vec::deserialize(deserializer)?;
-		let mut bounded = BoundedVec::<TssPublicKey, ConstU32<MAX_SHARD_SIZE>>::new();
-		for raw in raw_keys {
-			if raw.len() != 33 {
-				return Err(D::Error::custom(format!(
-					"Invalid TssPublicKey length: expected 33, got {}",
-					raw.len()
-				)));
-			}
-			let key: TssPublicKey =
-				raw.try_into().map_err(|_| D::Error::custom("Conversion to [u8;33] failed"))?;
-
-			bounded
-				.try_push(key)
-				.map_err(|_| D::Error::custom("Exceeds maximum shard size"))?;
-		}
-
-		Ok(bounded)
-	}
-}
-
-#[cfg(feature = "std")]
-pub mod serde_proof_of_knowledge {
-	use super::ProofOfKnowledge;
-	use serde::de::Error;
-	use serde::{Deserialize, Deserializer, Serializer};
-
-	pub fn serialize<S>(proof: &ProofOfKnowledge, serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: Serializer,
-	{
-		serializer.serialize_bytes(&proof[..])
-	}
-
-	pub fn deserialize<'de, D>(deserializer: D) -> Result<ProofOfKnowledge, D::Error>
-	where
-		D: Deserializer<'de>,
-	{
-		let bytes = <Vec<u8>>::deserialize(deserializer)?;
-		ProofOfKnowledge::try_from(bytes).map_err(|_| D::Error::custom("invalid public key length"))
-	}
-}
+pub struct Commitment(pub BoundedVec<TssPublicKey, ConstU32<MAX_SHARD_SIZE>>);
 
 #[cfg(feature = "std")]
 pub mod serde_tss_public_key {

tc-subxt/src/db.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
 use redb::{Database, ReadableTable, TableDefinition};
+use scale_codec::{Decode, Encode};
 use std::collections::VecDeque;
 use subxt::utils::H256;
 
@@ -31,7 +32,7 @@ impl ITransactionDbOps for TransactionsDB {
 		composite_key[..32].copy_from_slice(&self.public_key);
 		composite_key[32..].copy_from_slice(tx_data.hash.as_bytes());
 
-		let tx_value = bincode::serialize(tx_data)?;
+		let tx_value = tx_data.encode();
 
 		let write_tx = self.db.begin_write()?;
 		{
@@ -72,8 +73,7 @@ impl ITransactionDbOps for TransactionsDB {
 
 			for entry in table.range(lower_bound..=upper_bound)? {
 				let (key, value) = entry?;
-				let tx_data: TxData = bincode::deserialize(value.value())?;
-
+				let tx_data = TxData::decode(&mut value.value())?;
 				if tx_data.nonce < nonce {
 					let key_bytes: [u8; 64] = key.value();
 					delete_keys.push(key_bytes);

tc-subxt/src/worker.rs

@@ -8,22 +8,22 @@ use futures::channel::{mpsc, oneshot};
 use futures::future::BoxFuture;
 use futures::stream::{BoxStream, Fuse, FuturesUnordered};
 use futures::{Future, FutureExt, StreamExt};
-use serde::{Deserialize, Serialize};
+use scale_codec::{Decode, Encode};
 use std::collections::{HashSet, VecDeque};
 use std::pin::Pin;
 use subxt::config::DefaultExtrinsicParamsBuilder;
 use subxt::utils::H256;
 use subxt_signer::sr25519::Keypair;
 use time_primitives::{
-	serde_proof_of_knowledge, traits::IdentifyAccount, AccountId, Commitment, GmpEvents, Network,
-	NetworkConfig, NetworkId, PeerId, ProofOfKnowledge, PublicKey, ShardId, TaskId, TaskResult,
+	traits::IdentifyAccount, AccountId, Commitment, GmpEvents, Network, NetworkConfig, NetworkId,
+	PeerId, ProofOfKnowledge, PublicKey, ShardId, TaskId, TaskResult,
 };
 
 pub const MORTALITY: u8 = 32;
 type TransactionFuture = Pin<Box<dyn Future<Output = Result<H256>> + Send>>;
 type TransactionsUnordered = FuturesUnordered<TransactionFuture>;
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Encode, Decode)]
 pub enum Tx {
 	// system
 	SetCode {
@@ -60,7 +60,7 @@ pub enum Tx {
 	Commitment {
 		shard_id: ShardId,
 		commitment: Commitment,
-		#[serde(with = "serde_proof_of_knowledge")]
+		// #[serde(with = "serde_proof_of_knowledge")]
 		proof_of_knowledge: ProofOfKnowledge,
 	},
 	Ready {
@@ -80,7 +80,7 @@ pub enum Tx {
 	},
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Clone, Encode, Decode)]
 pub struct TxData {
 	pub hash: H256,
 	pub era: u64,

tc-subxt/tests/test_cases.rs

@@ -71,7 +71,7 @@ async fn test_transaction_mortality_outage_flow() {
 }
 
 #[tokio::test]
-// #[ignore]
+#[ignore]
 // not working tbf
 async fn test_transaction_mortality_outage_flow_50() {
 	let total_tasks: usize = 50;