Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-04-30 02:37:58 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,181 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run biguint`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug biguint hfuzz_workspace/biguint/*.fuzz`.
+//!
+//! # More infomation
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use honggfuzz::fuzz;
+use sr_arithmetic::biguint::{BigUint, Single};
+use std::convert::TryFrom;
+
+fn main() {
+	loop {
+		fuzz!(|data: (Vec<Single>, Vec<Single>, bool)| {
+			let (mut digits_u, mut digits_v, return_remainder) = data;
+
+			let mut u = BigUint::from_limbs(&digits_u);
+			let mut v = BigUint::from_limbs(&digits_v);
+
+			u.lstrip();
+			v.lstrip();
+
+			let ue = u128::try_from(u.clone());
+			let ve = u128::try_from(v.clone());
+
+			digits_u.reverse();
+			digits_v.reverse();
+
+			let num_u = num_bigint::BigUint::new(digits_u.clone());
+			let num_v = num_bigint::BigUint::new(digits_v.clone());
+
+			if check_digit_lengths(&u, &v, 4) {
+				assert_eq!(u.cmp(&v), ue.cmp(&ve));
+				assert_eq!(u.eq(&v), ue.eq(&ve));
+			}
+
+			if check_digit_lengths(&u, &v, 3) {
+				let expected = ue.unwrap() + ve.unwrap();
+				let t = u.clone().add(&v);
+				assert_eq!(
+					u128::try_from(t.clone()).unwrap(), expected,
+					"{:?} + {:?} ===> {:?} != {:?}", u, v, t, expected,
+				);
+			}
+
+			if check_digit_lengths(&u, &v, 4) {
+				let expected = ue.unwrap().checked_sub(ve.unwrap());
+				let t = u.clone().sub(&v);
+				if expected.is_none() {
+					assert!(t.is_err())
+				} else {
+					let t = t.unwrap();
+					let expected = expected.unwrap();
+					assert_eq!(
+						u128::try_from(t.clone()).unwrap(), expected,
+						"{:?} - {:?} ===> {:?} != {:?}", u, v, t, expected,
+					);
+				}
+			}
+
+			if check_digit_lengths(&u, &v, 2) {
+				let expected = ue.unwrap() * ve.unwrap();
+				let t = u.clone().mul(&v);
+				assert_eq!(
+					u128::try_from(t.clone()).unwrap(), expected,
+					"{:?} * {:?} ===> {:?} != {:?}", u, v, t, expected,
+				);
+			}
+
+			if check_digit_lengths(&u, &v, 4) {
+				let (ue, ve) = (ue.unwrap(), ve.unwrap());
+				if ve == 0 {
+					return;
+				}
+				let (q, r) = (ue / ve, ue % ve);
+				if let Some((qq, rr)) = u.clone().div(&v, true) {
+					assert_eq!(
+						u128::try_from(qq.clone()).unwrap(), q,
+						"{:?} / {:?} ===> {:?} != {:?}", u, v, qq, q,
+					);
+					assert_eq!(
+						u128::try_from(rr.clone()).unwrap(), r,
+						"{:?} % {:?} ===> {:?} != {:?}", u, v, rr, r,
+					);
+				} else if v.len() == 1 {
+					let qq = u.clone().div_unit(ve as Single);
+					assert_eq!(
+						u128::try_from(qq.clone()).unwrap(), q,
+						"[single] {:?} / {:?} ===> {:?} != {:?}", u, v, qq, q,
+					);
+				} else if v.msb() != 0 && u.msb() != 0 && u.len() > v.len() {
+					panic!("div returned none for an unexpected reason");
+				}
+			}
+
+			// Test against num_bigint
+
+			// Equality
+
+			assert_eq!(u.cmp(&v), num_u.cmp(&num_v));
+
+			// Addition
+
+			let w = u.clone().add(&v);
+			let num_w = num_u.clone() + &num_v;
+
+			assert_biguints_eq(&w, &num_w);
+
+			// Subtraction
+
+			if let Ok(w) = u.clone().sub(&v) {
+				let num_w = num_u.clone() - &num_v;
+
+				assert_biguints_eq(&w, &num_w);
+			}
+
+			// Multiplication
+
+			let w = u.clone().mul(&v);
+			let num_w = num_u.clone() * &num_v;
+
+			assert_biguints_eq(&w, &num_w);
+
+			// Division
+
+			if v.len() == 1 && v.get(0) != 0 {
+				let w = u.clone().div_unit(v.get(0));
+				let num_w = num_u.clone() / &num_v;
+				assert_biguints_eq(&w, &num_w);
+			} else if u.len() > v.len() && v.len() > 0 {
+				let num_remainder = num_u.clone() % num_v.clone();
+
+				let (w, remainder) = u.clone().div(&v, return_remainder).unwrap();
+				let num_w = num_u.clone() / &num_v;
+
+				assert_biguints_eq(&w, &num_w);
+
+				if return_remainder {
+					assert_biguints_eq(&remainder, &num_remainder);
+				}
+			}
+		});
+	}
+}
+
+fn check_digit_lengths(u: &BigUint, v: &BigUint, max_limbs: usize) -> bool {
+	1 <= u.len() && u.len() <= max_limbs && 1 <= v.len() && v.len() <= max_limbs
+}
+
+fn assert_biguints_eq(a: &BigUint, b: &num_bigint::BigUint) {
+	let mut a = a.clone();
+	a.lstrip();
+
+	// `num_bigint::BigUint` doesn't expose it's internals, so we need to convert into that to
+	// compare.
+	let limbs = (0 .. a.len()).map(|i| a.get(i)).collect();
+	let num_a = num_bigint::BigUint::new(limbs);
+
+	assert!(&num_a == b, "\narithmetic: {:?}\nnum-bigint: {:?}", a, b);
+}
@@ -0,0 +1,77 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run rational128`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug rational128 hfuzz_workspace/rational128/*.fuzz`.
+//!
+//! # More infomation
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use honggfuzz::fuzz;
+use sr_arithmetic::{helpers_128bit::multiply_by_rational, traits::Zero};
+
+fn main() {
+	loop {
+		fuzz!(|data: ([u8; 16], [u8; 16], [u8; 16])| {
+			let (a_bytes, b_bytes, c_bytes) = data;
+			let (a, b, c) = (
+				u128::from_be_bytes(a_bytes),
+				u128::from_be_bytes(b_bytes),
+				u128::from_be_bytes(c_bytes),
+			);
+
+			println!("++ Equation: {} * {} / {}", a, b, c);
+
+			// The point of this fuzzing is to make sure that `multiply_by_rational` is 100%
+			// accurate as long as the value fits in a u128.
+			if let Ok(result) = multiply_by_rational(a, b, c) {
+				let truth = mul_div(a, b, c);
+
+				if result != truth && result != truth + 1 {
+					println!("++ Expected {}", truth);
+					println!("+++++++ Got {}", result);
+					panic!();
+				}
+			}
+		})
+	}
+}
+
+fn mul_div(a: u128, b: u128, c: u128) -> u128 {
+	use primitive_types::U256;
+	if a.is_zero() {
+		return Zero::zero();
+	}
+	let c = c.max(1);
+
+	// e for extended
+	let ae: U256 = a.into();
+	let be: U256 = b.into();
+	let ce: U256 = c.into();
+
+	let r = ae * be / ce;
+	if r > u128::max_value().into() {
+		a
+	} else {
+		r.as_u128()
+	}
+}