12 changed files with 168 additions and 534 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1186,7 +1186,7 @@ dependencies = [

 [[package]]
 name = "casper-runtime"
-version = "3.5.31"
+version = "3.5.30"
 dependencies = [
 "casper-runtime-constants",
 "frame-benchmarking",
@ -3649,14 +3649,13 @@ dependencies = [

 [[package]]
 name = "ghost-networks"
-version = "0.1.16"
+version = "0.1.13"
 dependencies = [
 "frame-benchmarking",
 "frame-support",
 "frame-system",
 "ghost-core-primitives",
 "ghost-traits",
- "num-traits",
 "pallet-balances",
 "pallet-staking",
 "pallet-staking-reward-curve",
@ -3836,7 +3835,7 @@ dependencies = [

 [[package]]
 name = "ghost-slow-clap"
-version = "0.3.40"
+version = "0.3.39"
 dependencies = [
 "frame-benchmarking",
 "frame-support",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -69,7 +69,6 @@ bs58 = { version = "0.5.0" }
 prometheus-parse = { version = "0.2.2" }
 rustc-hex = { version = "2.1.0", default-features = false }
 log = { version = "0.4", default-features = false }
-num-traits = { version = "0.2.17", default-features = false }
 libsecp256k1 = { version = "0.7", default-features = false }
 bip39 = { package = "parity-bip39", version = "2.0.1" }
 sha3 = { version = "0.10", default-features = false }
--- a/README.md
+++ b/README.md
@ -150,8 +150,28 @@ rustup default stable
 rustup update
 ```

+Add the nightly release and the nightly WebAssembly (wasm) targets
+to your development environment by running the following commands:
 ```bash
-rustup target add wasm32-unknown-unknown --toolchain stable
+rustup update nightly
+```
+
+```bash
+rustup target add wasm32-unknown-unknown --toolchain nightly
+```
+
+```bash
+rustup target add wasm32-unknown-unknown --toolchain stable-x86_64-unknown-linux-gnu
+```
+
+If you are trying to install WebAssembly (wasm) on an ARM-based processor like the ones in Raspberry Pi try this instead:
+```bash
+rustup target add wasm32-unknown-unknown --toolchain stable-aarch64-unknown-linux-gnu
+```
+
+**_IF error try_**
+```bash
+rustup target add wasm32-unknown-unknown --toolchain default
 ```

 Verify the configuration of your development environment by running
@ -160,6 +180,10 @@ the following command:
 rustup show
 ```

+```bash
+rustup +nightly show
+```
+
 You should see something like this:

 ![images/img_9.png](images/img_9.png)
@ -170,6 +194,13 @@ Now run:
 rustup component add rust-src --toolchain stable
 ```

+**_IF error try_**
+```bash
+rustup component add rust-src --toolchain default
+```
+
+
+
 ## Install GHOST

 Check if Git is already installed:
@ -180,7 +211,7 @@ git --version

 Make a GHOST Directory and go to it:
 ```bash
-mkdir ~/ghost && cd ~/ghost
+mkdir ghost && cd ghost
 ```

 Clone GHOST Node Git:
@ -195,7 +226,7 @@ cd ghost-node

 Compile the node template by running the following command:
 ```bash
-./scripts/starter.sh --release
+cargo build --release
 ```

 The build can take up to 20 minutes depending on the specifications of your machine.
@ -203,6 +234,7 @@ The build can take up to 20 minutes depending on the specifications of your mach
 ![images/img_12.png](images/img_12.png)


+
 # Boot Node Qualification

 ## Boot Node Qualification Test
@ -288,7 +320,7 @@ Only `port 30333` should be opened.

 Press _CTRL+C_ to stop the node.

-# Launching GHOST TestNet
+# Launching GHOST TestNet 3.1

 Switch to main GIT branch:
 ```bash
@ -316,7 +348,66 @@ To generate the node key use the following command:
 ./target/release/ghost key generate-node-key --bin --file=/etc/ghost/node-key
 ```

-Feel free to backup the file on a separate storage device.
+Generate Wallet Key file with the following command:
+```bash
+./target/release/ghost key generate | grep "Secret seed" | awk '{$1=$2=""; sub(/^[ \t]+/, ""); print}' > /etc/ghost/wallet-key
+```
+
+Display the wallet-key on the screen by using cat command:
+```bash
+./target/release/ghost key inspect $(cat /etc/ghost/wallet-key)
+```
+![images/img_22.png](images/img_22.png)
+
+Feel free to back the file on a separate storage device.
+
+Generate Stash Key file with the following command:
+```bash
+./target/release/ghost key generate | grep "Secret seed" | awk '{$1=$2=""; sub(/^[ \t]+/, ""); print}' > /etc/ghost/stash-key
+```
+
+Display the stash-key on the screen by using cat command:
+```bash
+./target/release/ghost key inspect $(cat /etc/ghost/stash-key)
+```
+![images/img_23.png](images/img_23.png)
+
+Generate Session Key file with the following command:
+```bash
+./target/release/ghost key generate | grep "Secret seed" | awk '{$1=$2=""; sub(/^[ \t]+/, ""); print}' > /etc/ghost/session-key
+```
+You have generates 4 types of Session Keys:
+
+1. Session Key – AUDI
+2. Session Key – BABE
+3. Session Key – SLOW
+4. Session Key – GRAN
+
+Now let's display them!
+
+Display the session-key//audi on the screen by using cat command:
+```bash
+./target/release/ghost key inspect "$(cat /etc/ghost/session-key)//audi"
+```
+![images/img_24.png](images/img_24.png)
+
+Display the session-key//babe on the screen by using cat command:
+```bash
+./target/release/ghost key inspect "$(cat /etc/ghost/session-key)//babe"
+```
+![images/img_25.png](images/img_25.png)
+
+Display the session-key//slow on the screen by using cat command:
+```bash
+./target/release/ghost key inspect "$(cat /etc/ghost/session-key)//slow"
+```
+![images/img_26.png](images/img_26.png)
+
+Display the session-key//gran on the screen by using cat command:
+```bash
+./target/release/ghost key inspect "$(cat /etc/ghost/session-key)//gran" --scheme=ed25519
+```
+![images/img_27.png](images/img_27.png)

 ## Build and start the ghost-node

@ -346,7 +437,7 @@ sha256sum /etc/ghost/casper.json

 You should see:
 ```
-9da6045ed6d4fd844e3939573b31c013d0e564e542029330faa6d978cb4a915a
+ad653233c978bfd00c5e4525b17628632bc4319c5f5f4b4dcc2f050ef3c3d145
 ```

 Create running `ghost-node` service that starts on system boot using `--unit-file` flag.
@ -372,7 +463,10 @@ To choose default options press Enter here:

 ![images/img_30.png](images/img_30.png)

-If you want to validate from this node press Enter:
+Currently, you have to qualify to become a validator node through [GHOST Whales](https://ghostchain.io/whales-apply).
+If you were NOT included in the [ghosties file](https://git.ghostchain.io/ghostchain/ghost-node/src/branch/main/service/ghosties) then you cannot be a validator node,
+and you can only be a full node so for `disable validator mode? [y/N]` type `y`.
+If you were included in the ghosties file you can press Enter:
 ```
 disable validator mode? [y/N]: y
 ```
@ -417,6 +511,17 @@ Type `y` and press _Enter_ for create dedicated user for running `ghost-node`:

 ![images/img_37.png](images/img_37.png)

+Now you can check whether or not the keys on your GHOST Node match those
+in the [ghosties file](https://git.ghostchain.io/ghostchain/ghost-node/src/branch/main/service/ghosties) on GHOST Git.
+If you are running a **Validator Node** and if you have followed
+the Generating Keys Part you will see all `[+]`.
+If you are a running a **Full Node** you will see errors:
+
+(Press _Enter_ for prompts)
+```bash
+./scripts/starter.sh --check-keys
+```
+
 Full Node:

 ![images/img_38.png](images/img_38.png)
@ -430,7 +535,7 @@ Start `ghost-node`:
 sudo systemctl start ghost-node
 ```

-Wait ~60 seconds!
+Wait 60 seconds!

 Check node is started:
 ```bash
@ -440,6 +545,11 @@ sudo systemctl status ghost-node

 For exit press _CTRL+C_

+In order to insert keys run the following flags `--check-keys` `--insert-keys`:
+```bash
+./scripts/starter.sh --check-keys --insert-keys
+```
+
 Restart `ghost-node`:
 ```bash
 sudo systemctl restart ghost-node
--- a/pallets/networks/Cargo.toml
+++ b/pallets/networks/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ghost-networks"
-version = "0.1.16"
+version = "0.1.13"
 license.workspace = true
 authors.workspace = true
 edition.workspace = true
@ -10,7 +10,6 @@ repository.workspace = true
 [dependencies]
 scale-info = { workspace = true, features = ["derive"] }
 codec = { workspace = true, features = ["max-encoded-len"] }
-num-traits = { workspace = true }

 frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
@ -31,7 +30,6 @@ default = ["std"]
 std = [
    "scale-info/std",
    "codec/std",
-    "num-traits/std",
    "frame-support/std",
    "frame-system/std",
    "frame-benchmarking?/std",
--- a/pallets/networks/src/lib.rs
+++ b/pallets/networks/src/lib.rs
@ -21,11 +21,9 @@ pub use ghost_traits::networks::{
    NetworkDataBasicHandler, NetworkDataInspectHandler, NetworkDataMutateHandler,
 };

-mod math;
 mod weights;

 pub use crate::weights::WeightInfo;
-use math::MulDiv;
 pub use module::*;

 #[cfg(any(feature = "runtime-benchmarks", test))]
@ -75,17 +73,7 @@ pub struct BridgedInflationCurve<RewardCurve, T>(core::marker::PhantomData<(Rewa
 impl<Balance, RewardCurve, T> pallet_staking::EraPayout<Balance>
    for BridgedInflationCurve<RewardCurve, T>
 where
-    Balance: Default
-        + Copy
-        + From<BalanceOf<T>>
-        + AtLeast32BitUnsigned
-        + num_traits::ops::wrapping::WrappingAdd
-        + num_traits::ops::overflowing::OverflowingAdd
-        + sp_std::ops::AddAssign
-        + sp_std::ops::Not<Output = Balance>
-        + sp_std::ops::Shl<Output = Balance>
-        + sp_std::ops::Shr<Output = Balance>
-        + sp_std::ops::BitAnd<Balance, Output = Balance>,
+    Balance: Default + AtLeast32BitUnsigned + Clone + Copy + From<u128>,
    RewardCurve: Get<&'static PiecewiseLinear<'static>>,
    T: Config,
 {
@ -94,27 +82,30 @@ where
        total_issuance: Balance,
        _era_duration_in_millis: u64,
    ) -> (Balance, Balance) {
-        let reward_curve = RewardCurve::get();
-        let bridged_imbalance = BridgedImbalance::<T>::get();
+        let piecewise_linear = RewardCurve::get();
+        let bridge_adjustment = BridgedImbalance::<T>::get();
        let accumulated_commission = AccumulatedCommission::<T>::get();

-        let accumulated_commission: Balance = accumulated_commission.into();
-        let adjusted_issuance: Balance = total_issuance
-            .saturating_add(bridged_imbalance.bridged_out.into())
-            .saturating_sub(bridged_imbalance.bridged_in.into());
+        let bridged_out: u128 = bridge_adjustment.bridged_out.try_into().unwrap_or_default();
+        let bridged_in: u128 = bridge_adjustment.bridged_in.try_into().unwrap_or_default();
+        let accumulated_commission: u128 = accumulated_commission.try_into().unwrap_or_default();
+
+        let accumulated_balance = Balance::from(accumulated_commission);
+        let adjusted_issuance = match bridged_out > bridged_in {
+            true => total_issuance.saturating_add(Balance::from(bridged_out - bridged_in)),
+            false => total_issuance.saturating_sub(Balance::from(bridged_in - bridged_out)),
+        };

        NullifyNeeded::<T>::set(true);

-        let estimated_reward =
-            reward_curve.calculate_for_fraction_times_denominator(total_staked, adjusted_issuance);
-        let payout = MulDiv::<Balance>::calculate(
-            estimated_reward,
-            accumulated_commission,
-            adjusted_issuance,
-        );
-        let rest_payout = accumulated_commission.saturating_sub(payout);
-
-        (payout, rest_payout)
+        match piecewise_linear
+            .calculate_for_fraction_times_denominator(total_staked, adjusted_issuance)
+            .checked_mul(&accumulated_balance)
+            .and_then(|product| product.checked_div(&adjusted_issuance))
+        {
+            Some(payout) => (payout, accumulated_balance.saturating_sub(payout)),
+            None => (Balance::default(), Balance::default()),
+        }
    }
 }

@ -788,7 +779,6 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T

    fn nullify_commission() {
        AccumulatedCommission::<T>::set(Default::default());
-        BridgedImbalance::<T>::set(Default::default());
    }

    fn trigger_nullification() {
--- a/pallets/networks/src/math.rs
+++ b/pallets/networks/src/math.rs
@ -1,135 +0,0 @@
-use crate::AtLeast32BitUnsigned;
-
-pub struct MulDiv<Balance>(core::marker::PhantomData<Balance>);
-impl<Balance> MulDiv<Balance>
-where
-    Balance: Copy
-        + AtLeast32BitUnsigned
-        + num_traits::ops::wrapping::WrappingAdd
-        + num_traits::ops::overflowing::OverflowingAdd
-        + sp_std::ops::AddAssign
-        + sp_std::ops::Not<Output = Balance>
-        + sp_std::ops::Shl<Output = Balance>
-        + sp_std::ops::Shr<Output = Balance>
-        + sp_std::ops::BitAnd<Balance, Output = Balance>,
-{
-
-    fn zero(&self) -> Balance {
-        0u32.into()
-    }
-
-    fn one(&self) -> Balance {
-        1u32.into()
-    }
-
-    fn bit_shift(&self) -> Balance {
-        let u32_shift: u32 = core::mem::size_of::<Balance>()
-            .saturating_mul(4)
-            .try_into()
-            .unwrap_or_default();
-        u32_shift.into()
-    }
-
-    fn least_significant_bits(&self, a: Balance) -> Balance {
-        a & ((self.one() << self.bit_shift()) - self.one())
-    }
-
-    fn most_significant_bits(&self, a: Balance) -> Balance {
-        a >> self.bit_shift()
-    }
-
-    fn two_complement(&self, a: Balance) -> Balance {
-        (!a).wrapping_add(&self.one())
-    }
-
-    fn adjusted_ratio(&self, a: Balance) -> Balance {
-        (self.two_complement(a) / a).wrapping_add(&self.one())
-    }
-
-    fn modulo(&self, a: Balance) -> Balance {
-        self.two_complement(a) % a
-    }
-
-    fn overflow_resistant_addition(
-        &self,
-        a0: Balance,
-        a1: Balance,
-        b0: Balance,
-        b1: Balance,
-    ) -> (Balance, Balance) {
-        let (r0, overflow) = a0.overflowing_add(&b0);
-        let overflow: Balance = overflow.then(|| 1u32).unwrap_or_default().into();
-        let r1 = a1.wrapping_add(&b1).wrapping_add(&overflow);
-        (r0, r1)
-    }
-
-    fn overflow_resistant_multiplication(&self, a: Balance, b: Balance) -> (Balance, Balance) {
-        let (a0, a1) = (
-            self.least_significant_bits(a),
-            self.most_significant_bits(a),
-        );
-        let (b0, b1) = (
-            self.least_significant_bits(b),
-            self.most_significant_bits(b),
-        );
-        let (x, y) = (a1 * b0, b1 * a0);
-
-        let (r0, r1) = (a0 * b0, a1 * b1);
-        let (r0, r1) = self.overflow_resistant_addition(
-            r0,
-            r1,
-            self.least_significant_bits(x) << self.bit_shift(),
-            self.most_significant_bits(x),
-        );
-        let (r0, r1) = self.overflow_resistant_addition(
-            r0,
-            r1,
-            self.least_significant_bits(y) << self.bit_shift(),
-            self.most_significant_bits(y),
-        );
-
-        (r0, r1)
-    }
-
-    fn overflow_resistant_division(
-        &self,
-        mut a0: Balance,
-        mut a1: Balance,
-        b: Balance,
-    ) -> (Balance, Balance) {
-        if b == self.one() {
-            return (a0, a1);
-        }
-
-        let zero: Balance = 0u32.into();
-        let (q, r) = (self.adjusted_ratio(b), self.modulo(b));
-        let (mut x0, mut x1) = (zero, zero);
-
-        while a1 != zero {
-            let (t0, t1) = self.overflow_resistant_multiplication(a1, q);
-            let (new_x0, new_x1) = self.overflow_resistant_addition(x0, x1, t0, t1);
-            x0 = new_x0;
-            x1 = new_x1;
-
-            let (t0, t1) = self.overflow_resistant_multiplication(a1, r);
-            let (new_a0, new_a1) = self.overflow_resistant_addition(t0, t1, a0, zero);
-            a0 = new_a0;
-            a1 = new_a1;
-        }
-
-        self.overflow_resistant_addition(x0, x1, a0 / b, zero)
-    }
-
-    fn mul_div(&self, a: Balance, b: Balance, c: Balance) -> Balance {
-        let (t0, t1) = self.overflow_resistant_multiplication(a, b);
-        self.overflow_resistant_division(t0, t1, c).0
-    }
-
-    pub fn calculate(a: Balance, b: Balance, c: Balance) -> Balance {
-        let inner = MulDiv(core::marker::PhantomData);
-        if c == inner.zero() {
-            return c;
-        }
-        inner.mul_div(a, b, c)
-    }
-}
--- a/pallets/networks/src/tests.rs
+++ b/pallets/networks/src/tests.rs
@ -1295,10 +1295,8 @@ fn accumulated_commission_could_be_nullified() {
 #[test]
 fn bridged_inlation_reward_works() {
    ExtBuilder::build().execute_with(|| {
-        let amount_full: u128 = 1337 * 1_000_000_000;
-        let commission: u128 = amount_full / 100; // 1% commission
-        let amount: u128 = amount_full - commission;
-
+        let amount: u128 = 1337 * 1_000_000_000;
+        let commission: u128 = amount / 100; // 1% commission
        let total_staked_ideal: u128 = 69;
        let total_staked_not_ideal: u128 = 68;
        let total_issuance: u128 = 100;
@ -1540,10 +1538,8 @@ fn bridged_inlation_reward_works() {
 #[test]
 fn bridged_inflation_era_payout_triggers_need_of_nullification() {
    ExtBuilder::build().execute_with(|| {
-        let amount_full: u128 = 1337 * 1_000_000_000;
-        let commission: u128 = amount_full / 100; // 1% commission
-        let amount: u128 = amount_full - commission;
-
+        let amount: u128 = 1337 * 1_000_000_000;
+        let commission: u128 = amount / 100; // 1% commission
        let total_staked_ideal: u128 = 69;
        let total_issuance: u128 = 100;

@ -1567,333 +1563,10 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
 #[test]
 fn trigger_nullification_works_as_expected() {
    ExtBuilder::build().execute_with(|| {
-        let commission: u128 = 69;
-        let imbalance = BridgeAdjustment {
-            bridged_in: 1337u128,
-            bridged_out: 420u128,
-        };
-
-        assert_eq!(AccumulatedCommission::<Test>::get(), 0);
-        assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
-
-        AccumulatedCommission::<Test>::set(commission);
-        BridgedImbalance::<Test>::set(imbalance.clone());
-
-        assert_eq!(AccumulatedCommission::<Test>::get(), commission);
-        assert_eq!(BridgedImbalance::<Test>::get(), imbalance);
-
        assert_eq!(NullifyNeeded::<Test>::get(), false);
        GhostNetworks::trigger_nullification();
        assert_eq!(NullifyNeeded::<Test>::get(), true);
        GhostNetworks::trigger_nullification();
        assert_eq!(NullifyNeeded::<Test>::get(), false);
-        assert_eq!(AccumulatedCommission::<Test>::get(), 0);
-        assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
-    });
-}
-
-#[test]
-fn check_substrate_guarantees_not_to_overflow_u128() {
-    ExtBuilder::build().execute_with(|| {
-        let reward_curve = RewardCurve::get();
-        let mut n: u128 = 69;
-        let mut d: u128 = 100;
-
-        loop {
-            n = match n.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            d = match d.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            assert_eq!(
-                reward_curve.calculate_for_fraction_times_denominator(n, d),
-                d
-            );
-        }
-    });
-}
-
-#[test]
-fn check_substrate_guarantees_not_to_overflow_u64() {
-    ExtBuilder::build().execute_with(|| {
-        let reward_curve = RewardCurve::get();
-        let mut n: u64 = 69;
-        let mut d: u64 = 100;
-
-        loop {
-            n = match n.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            d = match d.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            assert_eq!(
-                reward_curve.calculate_for_fraction_times_denominator(n, d),
-                d
-            );
-        }
-    });
-}
-
-#[test]
-fn check_substrate_guarantees_not_to_overflow_u32() {
-    ExtBuilder::build().execute_with(|| {
-        let reward_curve = RewardCurve::get();
-        let mut n: u32 = 69;
-        let mut d: u32 = 100;
-
-        loop {
-            n = match n.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            d = match d.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            assert_eq!(
-                reward_curve.calculate_for_fraction_times_denominator(n, d),
-                d
-            );
-        }
-    });
-}
-
-#[test]
-fn check_muldiv_guarantees_not_to_overflow_for_u128() {
-    ExtBuilder::build().execute_with(|| {
-        let mut a: u128 = 2;
-        let mut b: u128 = 3;
-        let mut c: u128 = 6;
-        let mut result: u128 = 1;
-
-        loop {
-            a = match a.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            b = match b.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            c = match c.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            result = match result.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-
-            assert_eq!(MulDiv::<u128>::calculate(a, b, c), result);
-        }
-
-        assert_eq!(
-            MulDiv::<u128>::calculate(u128::MAX, u128::MAX, u128::MAX),
-            u128::MAX
-        );
-        assert_eq!(MulDiv::<u128>::calculate(u128::MAX, 0, 0), 0);
-        assert_eq!(MulDiv::<u128>::calculate(0, u128::MAX, 0), 0);
-        assert_eq!(MulDiv::<u128>::calculate(0, 0, u128::MAX), 0);
-    });
-}
-
-#[test]
-fn check_muldiv_guarantees_not_to_overflow_for_u64() {
-    ExtBuilder::build().execute_with(|| {
-        let mut a: u64 = 2;
-        let mut b: u64 = 3;
-        let mut c: u64 = 6;
-        let mut result: u64 = 1;
-
-        loop {
-            a = match a.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            b = match b.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            c = match c.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            result = match result.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-
-            assert_eq!(MulDiv::<u64>::calculate(a, b, c), result);
-        }
-
-        assert_eq!(
-            MulDiv::<u64>::calculate(u64::MAX, u64::MAX, u64::MAX),
-            u64::MAX
-        );
-        assert_eq!(MulDiv::<u64>::calculate(u64::MAX, 0, 0), 0);
-        assert_eq!(MulDiv::<u64>::calculate(0, u64::MAX, 0), 0);
-        assert_eq!(MulDiv::<u64>::calculate(0, 0, u64::MAX), 0);
-    });
-}
-
-#[test]
-fn check_muldiv_guarantees_not_to_overflow_for_u32() {
-    ExtBuilder::build().execute_with(|| {
-        let mut a: u32 = 2;
-        let mut b: u32 = 3;
-        let mut c: u32 = 6;
-        let mut result: u32 = 1;
-
-        loop {
-            a = match a.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            b = match b.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            c = match c.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            result = match result.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-
-            assert_eq!(MulDiv::<u32>::calculate(a, b, c), result);
-        }
-
-        assert_eq!(
-            MulDiv::<u32>::calculate(u32::MAX, u32::MAX, u32::MAX),
-            u32::MAX
-        );
-        assert_eq!(MulDiv::<u32>::calculate(u32::MAX, 0, 0), 0);
-        assert_eq!(MulDiv::<u32>::calculate(0, u32::MAX, 0), 0);
-        assert_eq!(MulDiv::<u32>::calculate(0, 0, u32::MAX), 0);
-    });
-}
-
-#[test]
-fn check_bridged_inflation_curve_for_overflow() {
-    ExtBuilder::build().execute_with(|| {
-        let amount_full: u128 = 1337 * 1_000_000_000;
-        let commission: u128 = amount_full / 100; // 1% commission
-        let amount: u128 = amount_full - commission;
-
-        let tollerance: u128 = commission / 100; // 1% tollerance
-        let precomputed_payout: u128 = 13177568884;
-        let precomputed_rest: u128 = 192431116;
-        assert_eq!(precomputed_payout + precomputed_rest, commission);
-
-        let mut total_staked_ideal: u128 = 69_000;
-        let mut total_staked_not_ideal: u128 = 68_000;
-        let mut total_issuance: u128 = 100_000;
-
-        assert_ok!(GhostNetworks::accumulate_commission(&commission));
-        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
-
-        loop {
-            total_staked_ideal = match total_staked_ideal.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            total_staked_not_ideal = match total_staked_not_ideal.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            total_issuance = match total_issuance.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            assert_eq!(
-                BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                    total_staked_ideal,
-                    total_issuance + amount,
-                    0
-                ),
-                (commission, 0)
-            );
-
-            let (payout, rest) = BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                total_staked_not_ideal,
-                total_issuance + amount,
-                0,
-            );
-
-            let payout_deviation = if precomputed_payout > payout {
-                precomputed_payout - payout
-            } else {
-                payout - precomputed_payout
-            };
-
-            let rest_deviation = if precomputed_rest > rest {
-                precomputed_rest - rest
-            } else {
-                rest - precomputed_rest
-            };
-
-            assert!(payout_deviation < tollerance);
-            assert!(rest_deviation < tollerance);
-        }
-    });
-}
-
-#[test]
-fn check_bridged_inflation_curve_for_big_commissions() {
-    ExtBuilder::build().execute_with(|| {
-        let mut amount_full: u128 = 1337;
-
-        let total_staked_ideal: u128 = 69_000_000;
-        let total_staked_gt_ideal: u128 = 100_000_000;
-        let total_staked_lt_ideal: u128 = 3_000_000;
-        let total_issuance: u128 = 100_000_000;
-
-        loop {
-            amount_full = match amount_full.checked_mul(1_000) {
-                Some(value) => value,
-                None => break,
-            };
-            let commission: u128 = amount_full / 100; // 1% commission
-            let amount: u128 = amount_full - commission;
-
-            AccumulatedCommission::<Test>::set(commission);
-            BridgedImbalance::<Test>::set(BridgeAdjustment {
-                bridged_in: amount,
-                bridged_out: 0,
-            });
-
-            assert_eq!(
-                BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                    total_staked_ideal,
-                    total_issuance + amount,
-                    0
-                ),
-                (commission, 0)
-            );
-
-            let (payout, rest) = BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                total_staked_gt_ideal,
-                total_issuance + amount,
-                0
-            );
-            assert!(payout < commission);
-            assert!(rest < commission);
-
-            let (payout, rest) = BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                total_staked_lt_ideal,
-                total_issuance + amount,
-                0
-            );
-            assert!(payout < commission);
-            assert!(rest < commission);
-        }
    });
 }
--- a/pallets/slow-clap/Cargo.toml
+++ b/pallets/slow-clap/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "ghost-slow-clap"
-version = "0.3.40"
+version = "0.3.39"
 description = "Applause protocol for the EVM bridge"
 license.workspace = true
 authors.workspace = true
--- a/pallets/slow-clap/src/tests.rs
+++ b/pallets/slow-clap/src/tests.rs
@ -905,9 +905,9 @@ fn should_nullify_commission_on_finalize() {
            BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
                total_staked,
                total_issuance,
-                0u64
+                0
            ),
-            (420000000000000u64, 0u64)
+            (420000000000000, 0)
        ); // precomputed values
        assert_eq!(Networks::is_nullification_period(), true);
        Networks::on_finalize(System::block_number());
@ -921,7 +921,6 @@ fn should_nullify_commission_on_finalize() {

 #[test]
 fn should_avoid_applause_during_nullification_period() {
-    let zero: u64 = 0u64;
    let total_staked = 69_000_000;
    let total_issuance = 100_000_000;

@ -937,9 +936,9 @@ fn should_avoid_applause_during_nullification_period() {
            BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
                total_staked,
                total_issuance,
-                zero
+                0
            ),
-            (zero, zero)
+            (0, 0)
        );
        assert_eq!(Networks::is_nullification_period(), true);

@ -957,7 +956,6 @@ fn should_avoid_applause_during_nullification_period() {

 #[test]
 fn should_self_applause_if_enough_received_claps() {
-    let zero: u64 = 0u64;
    let (network_id, transaction_hash, unique_transaction_hash) =
        generate_unique_hash(None, None, None, None);
    let (_, receiver, amount) = get_mocked_metadata();
@ -983,10 +981,10 @@ fn should_self_applause_if_enough_received_claps() {
            pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
            false
        );
-        assert_eq!(Balances::balance(&receiver), zero);
+        assert_eq!(Balances::balance(&receiver), 0);
        assert_eq!(
-            BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(zero, zero, zero),
-            (zero, zero)
+            BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(0, 0, 0),
+            (0, 0)
        );

        assert_ok!(do_clap_from(session_index, network_id, 0, false));
--- a/runtime/casper/Cargo.toml
+++ b/runtime/casper/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "casper-runtime"
-version = "3.5.31"
+version = "3.5.30"
 build = "build.rs"
 description = "Runtime of the Casper Network"
 edition.workspace = true
--- a/runtime/casper/src/lib.rs
+++ b/runtime/casper/src/lib.rs
@ -117,7 +117,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
    spec_name: create_runtime_str!("casper"),
    impl_name: create_runtime_str!("casper-svengali"),
    authoring_version: 0,
-    spec_version: 2,
+    spec_version: 1,
    impl_version: 0,
    apis: RUNTIME_API_VERSIONS,
    transaction_version: 1,
--- a/scripts/starter.sh
+++ b/scripts/starter.sh
@ -81,18 +81,20 @@ extract_seed() {
 }

 downgrade_compiler_if_needed() {
-    echo "[+] fetching the latest ghost-node source code"
-    git switch main
-    git pull origin main
+    # TODO: uncomment later
+    # echo "[+] fetching the latest ghost-node source code"
+    # git switch main
+    # git pull origin main
    
-    # 1.86.0 works fine, tested with:
+    # 1.83.0 works fine, tested with:
+    # ...
    # 1.87.0 throws errors during compilation
    # 1.88.0 throws errors during compilation
-    LATEST_TESTED_VERSION=86
+    LATEST_TESTED_VERSION=83
    cargo_version=$(cargo --version | cut -d'.' -f2)
    if [ "$cargo_version" -gt "$LATEST_TESTED_VERSION" ]; then 
-        echo "[+] downgrading rustc compiler version to 1.86.0"
-        rustup default 1.86.0
+        echo "[+] downgrading rustc compiler version to 1.83.0"
+        rustup default 1.83.0
        toolchain_name=$(rustup show | grep default | head -n 1 | cut -d' ' -f1)
        rustup target add wasm32-unknown-unknown --toolchain $toolchain_name
        rustup component add rust-src --toolchain $toolchain_name
@ -227,7 +229,6 @@ if [[ $HARD_RESET = true ]]; then
    sudo rm -rf "$BASE_PATH/chains/casper_staging_testnet"

    cd $PROJECT_FOLDER
-    git pull origin main
    echo "[+] starting build in 3 seconds..."
    sleep 3
    cargo build --release
@ -243,8 +244,9 @@ if [[ $HARD_RESET = true ]]; then
    echo "[+] ghost executable copied in '$EXECUTABLE_PATH' from '$TARGET'"
    echo "[+] specification '$SPECIFICATION_NAME.json' copied to '$SPECIFICATION_PATH'"

-    echo "[+] starting ghost-node"
-    sudo systemctl start ghost-node
+    # TODO: uncomment later
+    # echo "[+] starting ghost-node"
+    # sudo systemctl start ghost-node

    exit 0
 fi