Removed sp-arithmetic (#126)

* Removed sp-arithmetic

* pr fixes

Author: markopoloparadox

Cargo.lock

@@ -10,7 +10,6 @@ scale-info = { version = "2", default-features = false, features = ["derive"] }
 
 # Polkadot SDK
 binary-merkle-tree = { git = "https://github.com/availproject/polkadot-sdk", tag = "polkadot-1.7.1-patch-12", default-features = false }
-sp-arithmetic = { git = "https://github.com/availproject/polkadot-sdk", tag = "polkadot-1.7.1-patch-12", default-features = false }
 sp-std = { git = "https://github.com/availproject/polkadot-sdk", tag = "polkadot-1.7.1-patch-12", default-features = false }
 sp-trie = { git = "https://github.com/availproject/polkadot-sdk", tag = "polkadot-1.7.1-patch-12", default-features = false }
 sp-runtime = { git = "https://github.com/availproject/polkadot-sdk", tag = "polkadot-1.7.1-patch-12", default-features = false }
@@ -55,6 +54,7 @@ hash-db = { version = "0.16.0",  default-features = false }
 rayon = "1.5.2"
 once_cell = "1.8.0"
 nalgebra = { version = "0.32.2", default-features = false }
+num-traits = { version = "0.2.18", default-features = false }
 
 # ETH
 ethabi-decode = { git = "https://github.com/Snowfork/ethabi-decode.git", branch = "master", default-features = false }

Cargo.toml

@@ -17,6 +17,7 @@ log.workspace = true
 static_assertions.workspace = true
 thiserror-no-std.workspace = true
 tiny-keccak.workspace = true
+num-traits = { workspace = true }
 
 # Parity
 binary-merkle-tree = { workspace = true, optional = true }
@@ -30,7 +31,6 @@ sp-runtime-interface = { workspace = true, optional = true }
 sp-trie = { workspace = true, optional = true }
 sp-storage = { workspace = true, optional = true }
 sp-debug-derive = { workspace = true, optional = true }
-sp-arithmetic.workspace = true
 sp-std.workspace = true
 
 blake2b_simd.workspace = true
@@ -62,7 +62,6 @@ std = [
 	"primitive-types/std",
 	"scale-info/std",
 	"serde?/std",
-	"sp-arithmetic/std",
 	"sp-runtime-interface?/std",
 	"sp-runtime?/std",
 	"sp-std/std",

core/Cargo.toml

@@ -1,14 +1,13 @@
 use core::num::NonZeroU32;
-use sp_arithmetic::Perbill;
 use static_assertions::{const_assert, const_assert_eq};
 
 /// We allow `Normal` extrinsics to fill up the block up to 85%, the rest can be used
 /// by  Operational  extrinsics.
-pub const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(85);
+pub const NORMAL_DISPATCH_RATIO: u8 = 85;
 
 /// We allow `Normal` data submissions to fill up the matrix up to 100%, there is no
 /// Operational or mandatory extrinsic that goes in the matrix.
-pub const DA_DISPATCH_RATIO: Perbill = Perbill::from_percent(100);
+pub const DA_DISPATCH_RATIO: u8 = 100;
 
 const_assert!(BLOCK_CHUNK_SIZE.get() > 0);
 pub const BLOCK_CHUNK_SIZE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(32) };

core/src/constants.rs

@@ -5,8 +5,8 @@ use core::fmt::Debug;
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use derive_more::{Add, Constructor, Deref, Into, Mul};
+use num_traits::Zero;
 use scale_info::TypeInfo;
-use sp_arithmetic::traits::Zero;
 
 #[cfg(feature = "runtime")]
 use sp_debug_derive::RuntimeDebug;

core/src/lib.rs

@@ -17,7 +17,6 @@ poly-multiproof = { workspace = true, default-features = false, features = ["bls
 
 # Parity & Substrate
 codec = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
-sp-arithmetic.workspace = true
 sp-std.workspace = true
 
 # 3rd-party
@@ -61,7 +60,6 @@ std = [
 	"rand_chacha/std",
 	"serde",
 	"serde_json/std",
-	"sp-arithmetic/std",
 ]
 
 serde = [ "avail-core/serde", "dep:serde" ]

kate/Cargo.toml

@@ -14,7 +14,6 @@ use nalgebra::DMatrix;
 use rand::{prelude::IteratorRandom, Rng, SeedableRng};
 use rand_chacha::ChaChaRng;
 use serde::{Deserialize, Serialize};
-use sp_arithmetic::{traits::SaturatedConversion, Percent};
 
 const XTS_JSON_SETS: &str = include_str!("reconstruct.data.json");
 
@@ -81,15 +80,14 @@ fn sample_cells_from_matrix(matrix: &DMatrix<ArkScalar>, columns: Option<&[u16]>
 fn random_cells(
 	max_cols: BlockLengthColumns,
 	max_rows: BlockLengthRows,
-	percents: Percent,
+	percents: u8,
 ) -> Vec<Cell> {
-	let max_cols = max_cols.into();
-	let max_rows = max_rows.into();
+	let max_cols: u32 = max_cols.into();
+	let max_rows: u32 = max_rows.into();
 
 	let rng = &mut ChaChaRng::from_seed([0u8; 32]);
-	let amount: usize = percents
-		.mul_ceil::<u32>(max_cols * max_rows)
-		.saturated_into();
+	let amount = (percents as u32 * (max_cols * max_rows)).div_ceil(100);
+	let amount: usize = usize::try_from(amount).unwrap_or(usize::MAX);
 
 	(0..max_cols)
 		.flat_map(move |col| {
@@ -148,7 +146,7 @@ fn reconstruct(xts: &[AppExtrinsic]) {
 		usize::try_from(dims_cols).unwrap(),
 		usize::try_from(dims_cols).unwrap(),
 	);
-	for cell in random_cells(dims.cols(), dims.rows(), Percent::one()) {
+	for cell in random_cells(dims.cols(), dims.rows(), 100) {
 		let row: u32 = cell.row.into();
 
 		let proof = build_proof(&public_params, dims, &matrix, &[cell], &metrics).unwrap();

kate/benches/reconstruct.rs

@@ -12,7 +12,6 @@ poly-multiproof = { workspace = true, default-features = false, features = ["bls
 
 # Parity
 codec = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
-sp-arithmetic.workspace = true
 sp-std.workspace = true
 
 # 3rd-parties
@@ -26,6 +25,7 @@ once_cell = { workspace = true, optional = true }
 rand = { workspace = true, optional = true }
 rand_chacha = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
+num-traits = { workspace = true, optional = true }
 
 [dev-dependencies]
 hex.workspace = true
@@ -40,8 +40,8 @@ std = [
 	"rand/std",
 	"rand_chacha/std",
 	"serde",
-	"sp-arithmetic/std",
 	"sp-std/std",
+	"num-traits",
 ]
 
 serde = [ "dep:serde" ]

kate/recovery/Cargo.toml

@@ -18,12 +18,9 @@ use super::commons::{ArkEvaluationDomain, ArkScalar};
 #[cfg(feature = "std")]
 use codec::{Decode, IoReader};
 #[cfg(feature = "std")]
-use poly_multiproof::{ark_ff::Field, ark_poly::EvaluationDomain, traits::AsBytes};
+pub use num_traits::{One, Zero};
 #[cfg(feature = "std")]
-pub use sp_arithmetic::{
-	traits::{One, SaturatedConversion as _, Zero},
-	Percent,
-};
+use poly_multiproof::{ark_ff::Field, ark_poly::EvaluationDomain, traits::AsBytes};
 #[cfg(feature = "std")]
 use static_assertions::{const_assert, const_assert_ne};
 #[cfg(feature = "std")]
@@ -83,14 +80,13 @@ impl std::error::Error for ReconstructionError {
 pub fn columns_positions<R: rand::RngCore>(
 	dimensions: matrix::Dimensions,
 	positions: &[matrix::Position],
-	factor: Percent,
+	factor: u8,
 	rng: &mut R,
 ) -> Vec<matrix::Position> {
 	use rand::seq::SliceRandom;
 
-	let cells = factor
-		.mul_ceil(dimensions.extended_rows())
-		.saturated_into::<usize>();
+	let cells = (factor as u32 * dimensions.extended_rows()).div_ceil(100);
+	let cells = usize::try_from(cells).unwrap_or(usize::MAX);
 
 	let columns: HashSet<u16> = HashSet::from_iter(positions.iter().map(|position| position.col));
 

kate/recovery/src/com.rs

@@ -26,7 +26,6 @@ use rand_chacha::{
 use rayon::prelude::*;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use sp_arithmetic::traits::SaturatedConversion;
 use static_assertions::const_assert_eq;
 
 use crate::{
@@ -291,7 +290,8 @@ fn pad_to_chunk<const CHUNK_SIZE: usize>(chunk: DataChunk) -> Vec<u8> {
 }
 
 fn pad_iec_9797_1(mut data: Vec<u8>) -> Vec<DataChunk> {
-	let padded_size = padded_len_of_pad_iec_9797_1(data.len().saturated_into());
+	let data_len = u32::try_from(data.len()).unwrap_or(u32::MAX);
+	let padded_size = padded_len_of_pad_iec_9797_1(data_len);
 	data.resize(padded_size as usize, 0u8);
 
 	// Transform into `DataChunk`.
@@ -495,7 +495,8 @@ pub fn build_proof<M: Metrics>(
 		res[PROOF_SIZE..].copy_from_slice(&point_bytes);
 	});
 
-	metrics.proof_build_time(total_start.elapsed(), cells.len().saturated_into());
+	let cells_len = u32::try_from(cells.len()).unwrap_or(u32::MAX);
+	metrics.proof_build_time(total_start.elapsed(), cells_len);
 
 	if let Ok(mut errors) = locked_errors.lock() {
 		if let Some(error) = errors.pop() {
@@ -522,7 +523,8 @@ pub fn par_build_commitments<const CHUNK_SIZE: usize, M: Metrics>(
 	let (tx_layout, block, block_dims) =
 		flatten_and_pad_block::<CHUNK_SIZE>(rows, cols, extrinsics_by_key, rng_seed)?;
 
-	metrics.block_dims_and_size(block_dims, block.len().saturated_into());
+	let block_len = u32::try_from(block.len()).unwrap_or(u32::MAX);
+	metrics.block_dims_and_size(block_dims, block_len);
 
 	let ext_matrix = par_extend_data_matrix(block_dims, &block, metrics)?;
 
@@ -663,6 +665,7 @@ mod tests {
 		constants::kate::{CHUNK_SIZE, COMMITMENT_SIZE, DATA_CHUNK_SIZE},
 		DataLookup,
 	};
+	use core::usize;
 	use hex_literal::hex;
 	use kate_recovery::{
 		com::*,
@@ -676,7 +679,6 @@ mod tests {
 		prelude::*,
 	};
 	use rand::{prelude::IteratorRandom, Rng, SeedableRng};
-	use sp_arithmetic::Percent;
 	use std::{convert::TryInto, iter::repeat};
 	use test_case::test_case;
 
@@ -885,15 +887,14 @@ mod tests {
 	fn random_cells(
 		max_cols: BlockLengthColumns,
 		max_rows: BlockLengthRows,
-		percents: Percent,
+		percents: u8,
 	) -> Vec<Cell> {
-		let max_cols = max_cols.into();
-		let max_rows = max_rows.into();
+		let max_cols: u32 = max_cols.into();
+		let max_rows: u32 = max_rows.into();
 
 		let rng = &mut ChaChaRng::from_seed([0u8; 32]);
-		let amount: usize = percents
-			.mul_ceil::<u32>(max_cols * max_rows)
-			.saturated_into();
+		let amount = (percents as u32 * (max_cols * max_rows)).div_ceil(100);
+		let amount = usize::try_from(amount).unwrap_or(usize::MAX);
 
 		(0..max_cols)
 			.flat_map(move |col| {
@@ -923,7 +924,7 @@ mod tests {
 		// let dims_cols = usize::try_from(dims.cols.0).unwrap();
 		// let public_params = testnet::public_params(dims_cols);
 		let public_params = couscous::multiproof_params();
-		for cell in random_cells(dims.cols, dims.rows, Percent::one() ) {
+		for cell in random_cells(dims.cols, dims.rows, 100 ) {
 			let row = usize::try_from(cell.row.0).unwrap();
 
 			let proof = build_proof(&public_params, dims, &matrix, &[cell], &metrics).unwrap();
@@ -1199,12 +1200,12 @@ Let's see how this gets encoded and then reconstructed by sampling only some dat
 	#[test_case( build_extrinsics(&[]) => padded_len_group(&[], 32) ; "Empty chunk list")]
 	#[test_case( build_extrinsics(&[4096]) => padded_len_group(&[4096], 32) ; "4K chunk")]
 	fn test_padding_len(extrinsics: Vec<Vec<u8>>) -> u32 {
-		extrinsics
+		let sum = extrinsics
 			.into_iter()
 			.flat_map(pad_iec_9797_1)
 			.map(|chunk| pad_to_chunk::<TCHUNK_SIZE>(chunk).len())
-			.sum::<usize>()
-			.saturated_into()
+			.sum::<usize>();
+		u32::try_from(sum).unwrap_or(u32::MAX)
 	}
 
 	#[test]