use benchmarked weights as a default weights for ghost-claims pallet

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

Cargo.lock

@@ -1186,7 +1186,7 @@ dependencies = [
 
 [[package]]
 name = "casper-runtime"
-version = "3.5.19"
+version = "3.5.20"
 dependencies = [
  "casper-runtime-constants",
  "frame-benchmarking",
@@ -3528,7 +3528,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-cli"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "cfg-if",
  "clap 4.5.4",
@@ -3584,7 +3584,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-machine-primitives"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "lazy_static",
  "sc-sysinfo",
@@ -3593,7 +3593,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-metrics"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "assert_cmd",
  "bs58 0.5.1",
@@ -3648,7 +3648,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-networks"
-version = "0.7.180"
+version = "0.1.2"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3656,6 +3656,8 @@ dependencies = [
  "ghost-core-primitives",
  "ghost-traits",
  "pallet-balances",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
  "parity-scale-codec",
  "scale-info",
  "sp-io 30.0.0",
@@ -3665,7 +3667,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-node"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "assert_cmd",
  "color-eyre",
@@ -3696,7 +3698,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-rpc"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "ghost-core-primitives",
  "jsonrpsee",
@@ -3748,7 +3750,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-service"
-version = "0.7.180"
+version = "0.7.197"
 dependencies = [
  "assert_matches",
  "async-trait",
@@ -3832,7 +3834,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-slow-clap"
-version = "0.3.14"
+version = "0.3.15"
 dependencies = [
  "frame-benchmarking",
  "frame-support",

Cargo.toml

@@ -17,7 +17,7 @@ homepage.workspace = true
 [workspace.package]
 license = "GPL-3.0-only"
 authors = ["571nky", "57r37ch", "f4750"]
-version = "0.7.180"
+version = "0.7.197"
 edition = "2021"
 homepage = "https://ghostchain.io"
 repository = "https://git.ghostchain.io/ghostchain/ghost-node"

README.md

@@ -56,6 +56,12 @@ an SSH server.
 sudo apt install openssh-server
 ```
 
+Start SSH Service using _systemctl_.
+
+```bash
+sudo systemctl start ssh
+```
+
 Enable SSH Service to Start on Boot: To ensure that the SSH service automatically
 starts after a reboot, you need to enable it using _systemctl_.
 
@@ -158,6 +164,11 @@ rustup target add wasm32-unknown-unknown --toolchain nightly
 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
@@ -309,7 +320,7 @@ Only `port 30333` should be opened.
 
 Press _CTRL+C_ to stop the node.
 
-# Launching GHOST TestNet 2.0
+# Launching GHOST TestNet 3.1
 
 Switch to main GIT branch:
 ```bash
@@ -426,9 +437,8 @@ sha256sum /etc/ghost/casper.json
 
 You should see:
 ```
-6c1bab2e9c04043814b5e5e72984b00ac60150bd48cb16068495f1b49fbc5008
+ad653233c978bfd00c5e4525b17628632bc4319c5f5f4b4dcc2f050ef3c3d145
 ```
-![images/img_29.png](images/img_29.png)
 
 Create running `ghost-node` service that starts on system boot using `--unit-file` flag.
 And we must set up the `ghost-node` launch command by setting arguments using
@@ -481,7 +491,7 @@ Official **Boot Node** addresses:
 /dns/bootnode70.chain.ghostchain.io/tcp/30333/p2p/12D3KooWP3h5dSdqcpvsCr7fp1jyfqDj291QDZ68a4gY6VQ8T1nW
 ```
 
-A full list of available **Boot Nodes** can be found on [the guide page](https://blog.ghostchain.io/launching-ghost-testnet-2-0/#Boot_Node).
+A full list of available **Boot Nodes** can be found on [the guide page](https://blog.ghostchain.io/launching-ghost-testnet-3-1/#Boot_Node).
 
 ![images/img_33.png](images/img_33.png)
 
@@ -497,7 +507,7 @@ Type `y` and press _Enter_ for create dedicated user for running `ghost-node`:
 
 ![images/img_36.png](images/img_36.png)
 
-**DO NOT start and enable** `ghost-node.service` press _Enter_:
+**DO NOT start and DO NOT enable** `ghost-node.service` (press _Enter_):
 
 ![images/img_37.png](images/img_37.png)
 

pallets/claims/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-claims"
-version = "0.2.2"
+version = "0.2.3"
 description = "Ghost balance and rank claims based on EVM actions"
 license.workspace = true
 authors.workspace = true

pallets/claims/src/lib.rs

@@ -20,8 +20,9 @@ extern crate alloc;
 #[cfg(not(feature = "std"))]
 use alloc::{format, string::String};
 
-pub mod weights;
+mod weights;
 pub use crate::weights::WeightInfo;
+
 mod tests;
 mod mock;
 mod benchmarking;

pallets/claims/src/weights.rs

@@ -1,9 +1,104 @@
-use frame_support::weights::Weight;
+// This file is part of Ghost Network.
 
+// Ghost Network 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.
+
+// Ghost Network 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 Ghost Network.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Autogenerated weights for `ghost_claims`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2024-08-02, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `ghostown`, CPU: `Intel(R) Core(TM) i3-2310M CPU @ 2.10GHz`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("casper-dev")`, DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/ghost
+// benchmark
+// pallet
+// --chain=casper-dev
+// --steps=50
+// --repeat=20
+// --pallet=ghost_claims
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --header=./file_header.txt
+// --output=./runtime/casper/src/weights/ghost_claims.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{
+    traits::Get, 
+    weights::{Weight, constants::RocksDbWeight},
+};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `ghost_claims`.
 pub trait WeightInfo {
 	fn claim() -> Weight;
 }
 
-impl WeightInfo for () {
-    fn claim() -> Weight { Weight::zero() }
+/// Weight for ghost_claims using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `GhostClaims::Total` (r:1 w:1)
+	/// Proof: `GhostClaims::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `CultCollective::Members` (r:2 w:2)
+	/// Proof: `CultCollective::Members` (`max_values`: None, `max_size`: Some(42), added: 2517, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::MemberCount` (r:6 w:6)
+	/// Proof: `CultCollective::MemberCount` (`max_values`: None, `max_size`: Some(14), added: 2489, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::IdToIndex` (r:6 w:12)
+	/// Proof: `CultCollective::IdToIndex` (`max_values`: None, `max_size`: Some(54), added: 2529, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::IndexToId` (r:0 w:6)
+	/// Proof: `CultCollective::IndexToId` (`max_values`: None, `max_size`: Some(54), added: 2529, mode: `MaxEncodedLen`)
+	fn claim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `896`
+		//  Estimated: `16164`
+		// Minimum execution time: 754_086_000 picoseconds.
+		Weight::from_parts(756_147_000, 0)
+			.saturating_add(Weight::from_parts(0, 16164))
+			.saturating_add(T::DbWeight::get().reads(17))
+			.saturating_add(T::DbWeight::get().writes(29))
+	}
+}
+
+impl WeightInfo for () {
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `GhostClaims::Total` (r:1 w:1)
+	/// Proof: `GhostClaims::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `CultCollective::Members` (r:2 w:2)
+	/// Proof: `CultCollective::Members` (`max_values`: None, `max_size`: Some(42), added: 2517, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::MemberCount` (r:6 w:6)
+	/// Proof: `CultCollective::MemberCount` (`max_values`: None, `max_size`: Some(14), added: 2489, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::IdToIndex` (r:6 w:12)
+	/// Proof: `CultCollective::IdToIndex` (`max_values`: None, `max_size`: Some(54), added: 2529, mode: `MaxEncodedLen`)
+	/// Storage: `CultCollective::IndexToId` (r:0 w:6)
+	/// Proof: `CultCollective::IndexToId` (`max_values`: None, `max_size`: Some(54), added: 2529, mode: `MaxEncodedLen`)
+	fn claim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `896`
+		//  Estimated: `16164`
+		// Minimum execution time: 754_086_000 picoseconds.
+		Weight::from_parts(756_147_000, 0)
+			.saturating_add(Weight::from_parts(0, 16164))
+			.saturating_add(RocksDbWeight::get().reads(17))
+			.saturating_add(RocksDbWeight::get().writes(29))
+	}
 }

pallets/networks/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "ghost-networks"
+version = "0.1.2"
 license.workspace = true
 authors.workspace = true
-version.workspace = true
 edition.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -14,14 +14,16 @@ codec = { workspace = true, features = ["max-encoded-len"] }
 frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
+pallet-staking = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 ghost-traits = { workspace = true }
 
 [dev-dependencies]
 primitives = { workspace = true }
-pallet-balances = { workspace = true }
 sp-io = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-staking-reward-curve = { workspace = true }
 
 [features]
 default = ["std"]
@@ -35,6 +37,7 @@ std = [
     "sp-std/std",
     "sp-io/std",
     "ghost-traits/std",
+    "pallet-staking/std",
     "pallet-balances/std",
 ]
 runtime-benchmarks = [
@@ -42,6 +45,7 @@ runtime-benchmarks = [
     "frame-support/runtime-benchmarks",
     "frame-system/runtime-benchmarks",
     "sp-runtime/runtime-benchmarks",
+    "pallet-staking/runtime-benchmarks",
 ]
 try-runtime = [
     "frame-support/try-runtime",

pallets/networks/src/lib.rs

@@ -4,15 +4,17 @@
 
 use frame_support::{
     pallet_prelude::*,
-    storage::PrefixIterator, traits::EnsureOrigin,
+    storage::PrefixIterator, traits::{tokens::fungible::Inspect, EnsureOrigin},
 };
 use frame_system::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{AtLeast32BitUnsigned, Member},
+    traits::{CheckedSub, CheckedAdd, AtLeast32BitUnsigned, Member},
+    curve::PiecewiseLinear,
     DispatchResult,
 };
 use sp_std::prelude::*;
+use sp_std::convert::TryInto;
 
 pub use ghost_traits::networks::{
     NetworkDataBasicHandler, NetworkDataInspectHandler, 
@@ -31,6 +33,10 @@ mod mock;
 #[cfg(all(feature = "std", test))]
 mod tests;
 
+pub type BalanceOf<T> = <<T as Config>::Currency as Inspect<
+    <T as frame_system::Config>::AccountId,
+>>::Balance;
+
 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub enum NetworkType {
     Evm = 0,
@@ -55,6 +61,48 @@ pub struct NetworkData {
     pub outgoing_fee: u32,
 }
 
+#[derive(Default, Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct BridgeAdjustment<Balance> {
+    bridged_out: Balance,
+    bridged_in: Balance,
+}
+
+pub struct BridgedInflationCurve<RewardCurve, T>(core::marker::PhantomData<(RewardCurve, T)>);
+impl<Balance, RewardCurve, T> pallet_staking::EraPayout<Balance> for BridgedInflationCurve<RewardCurve, T>
+where
+    Balance: Default + AtLeast32BitUnsigned + Clone + Copy + From<u128>,
+    RewardCurve: Get<&'static PiecewiseLinear<'static>>,
+    T: Config,
+{
+    fn era_payout(
+        total_staked: Balance,
+        total_issuance: Balance,
+        _era_duration_in_millis: u64,
+    ) -> (Balance, Balance) {
+        let piecewise_linear = RewardCurve::get();
+        let bridge_adjustment = BridgedImbalance::<T>::get();
+        let accumulated_commission = AccumulatedCommission::<T>::get();
+
+        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)),
+        };
+
+        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()),
+            }
+    }
+}
+
 #[frame_support::pallet]
 pub mod module {
     use super::*;
@@ -63,6 +111,9 @@ pub mod module {
     pub trait Config: frame_system::Config {
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
+        /// The type used for the internal balance storage.
+        type Currency: Inspect<Self::AccountId>;
+
         /// The type used as a unique network id.
         type NetworkId: Parameter
             + Member
@@ -114,11 +165,31 @@ pub mod module {
         NetworkRemoved { chain_id: T::NetworkId },
     }
 
+    #[pallet::storage]
+    #[pallet::getter(fn bridged_imbalance)]
+    pub type BridgedImbalance<T: Config> =
+        StorageValue<_, BridgeAdjustment<BalanceOf<T>>, ValueQuery>;
+
+    #[pallet::storage]
+    #[pallet::getter(fn accumulated_commission)]
+    pub type AccumulatedCommission<T: Config> =
+        StorageValue<_, BalanceOf<T>, ValueQuery>;
+
     #[pallet::storage]
     #[pallet::getter(fn networks)]
     pub type Networks<T: Config> =
         StorageMap<_, Twox64Concat, T::NetworkId, NetworkData, OptionQuery>;
 
+    #[pallet::storage]
+    #[pallet::getter(fn gatekeeper_amount)]
+    pub type GatekeeperAmount<T: Config> = StorageMap<
+        _,
+        Twox64Concat,
+        T::NetworkId,
+        BalanceOf<T>,
+        ValueQuery,
+    >;
+
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
         pub networks: Vec<(T::NetworkId, Vec<u8>)>,
@@ -527,7 +598,7 @@ impl<T: Config> NetworkDataInspectHandler<NetworkData> for Pallet<T> {
     }
 }
 
-impl<T: Config> NetworkDataMutateHandler<NetworkData> for Pallet<T> {
+impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T> {
     fn register(chain_id: Self::NetworkId, network: NetworkData) -> DispatchResult {
         Self::do_register_network(chain_id, network)
     }
@@ -535,4 +606,74 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData> for Pallet<T> {
     fn remove(chain_id: Self::NetworkId) -> DispatchResult {
         Self::do_remove_network(chain_id)
     }
+
+    fn increase_gatekeeper_amount(
+        network_id: &T::NetworkId,
+        amount: &BalanceOf<T>,
+    ) -> Result<(BalanceOf<T>, BalanceOf<T>), ()> {
+        let new_bridged_in_amount = BridgedImbalance::<T>::mutate(|bridged_imbalance| {
+            match bridged_imbalance.bridged_in.checked_add(amount) {
+                Some(value) => {
+                    (*bridged_imbalance).bridged_in = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        let new_gatekeeper_amount = GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| {
+            match gatekeeper_amount.checked_add(amount) {
+                Some(value) => {
+                    *gatekeeper_amount = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        Ok((new_gatekeeper_amount, new_bridged_in_amount))
+    }
+
+    fn decrease_gatekeeper_amount(
+        network_id: &T::NetworkId,
+        amount: &BalanceOf<T>,
+    ) -> Result<(BalanceOf<T>, BalanceOf<T>), ()> {
+        let new_gatekeeper_amount = GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| {
+            match gatekeeper_amount.checked_sub(amount) {
+                Some(value) => {
+                    *gatekeeper_amount = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        let new_bridged_out_amount = BridgedImbalance::<T>::mutate(|bridged_imbalance| {
+             match bridged_imbalance.bridged_out.checked_add(amount) {
+                 Some(value) => {
+                     (*bridged_imbalance).bridged_out = value;
+                     Ok(value)
+                 },
+                 None => Err(())
+             }
+        })?;
+
+        Ok((new_gatekeeper_amount, new_bridged_out_amount))
+    }
+
+    fn accumulate_commission(commission: &BalanceOf<T>) -> Result<BalanceOf<T>, ()> {
+        AccumulatedCommission::<T>::mutate(|accumulated| {
+            match accumulated.checked_add(commission) {
+                Some(value) => {
+                    *accumulated = value;
+                    Ok(value)
+                },
+                None => Err(()),
+            }
+        })
+    }
+
+    fn nullify_commission() {
+        AccumulatedCommission::<T>::set(Default::default());
+    }
 }

pallets/networks/src/mock.rs

@@ -1,19 +1,25 @@
-use crate as ghost_networks;
+use crate::{self as ghost_networks};
 use frame_system::EnsureSignedBy;
 use frame_support::{
-    construct_runtime, ord_parameter_types, parameter_types, traits::{ConstU128, ConstU32, Everything}
+    construct_runtime, ord_parameter_types, parameter_types,
+    traits::{ConstU128, ConstU32, Everything},
 };
 pub use primitives::{
     AccountId, Balance, Nonce, BlockNumber, Hash,
     ReserveIdentifier, FreezeIdentifier,
 };
 use sp_runtime::{
-    traits::{BlakeTwo256, AccountIdLookup},
-    BuildStorage,
+    curve::PiecewiseLinear,
+    traits::{AccountIdLookup, BlakeTwo256},
+    BuildStorage
 };
 
 parameter_types! {
     pub const BlockHashCount: BlockNumber = 250;
+    pub static SlashDeferDuration: u32 = 0;
+    pub static Period: BlockNumber = 5;
+    pub static Offset: BlockNumber = 0;
+    pub static MaxControllersInDeprecationBatch: u32 = 5_000;
 }
 
 impl frame_system::Config for Test {
@@ -64,6 +70,21 @@ impl pallet_balances::Config for Test {
     type MaxFreezes = ConstU32<50>;
 }
 
+pallet_staking_reward_curve::build! {
+    const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+        min_inflation: 0_006_900,
+        max_inflation: 1_000_000,
+        ideal_stake: 0_690_000,
+        falloff: 0_050_000,
+        max_piece_count: 100,
+        test_precision: 0_005_000,
+    );
+}
+
+parameter_types! {
+    pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+}
+
 ord_parameter_types! {
     pub const RegistererAccount: AccountId = AccountId::from([1u8; 32]);
     pub const UpdaterAccount: AccountId = AccountId::from([2u8; 32]);
@@ -73,6 +94,7 @@ ord_parameter_types! {
 
 impl ghost_networks::Config for Test {
     type RuntimeEvent = RuntimeEvent;
+    type Currency = Balances;
     type NetworkId = u32;
     type RegisterOrigin = EnsureSignedBy::<RegistererAccount, AccountId>;
     type UpdateOrigin = EnsureSignedBy::<UpdaterAccount, AccountId>;
@@ -80,7 +102,7 @@ impl ghost_networks::Config for Test {
     type WeightInfo = crate::weights::SubstrateWeight<Test>;
 }
 
-type Block = frame_system::mocking::MockBlockU32<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
 
 construct_runtime!(
     pub enum Test {

pallets/networks/src/tests.rs

@@ -1,16 +1,16 @@
 use mock::{
     ExtBuilder, System, RegistererAccount, UpdaterAccount, RemoverAccount, 
-    RandomAccount, GhostNetworks, Test, RuntimeEvent, RuntimeOrigin,
+    RandomAccount, GhostNetworks, Test, RuntimeEvent, RuntimeOrigin, RewardCurve,
 };
 use frame_support::{assert_err, assert_ok};
 use sp_runtime::DispatchError;
+use pallet_staking::EraPayout;
 use super::*;
 
 fn prepare_network_data() -> (u32, NetworkData) {
     (1u32, NetworkData {
         chain_name: "Ethereum".into(),
-        default_endpoint:
-            "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
+        default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
         finality_delay: Some(69),
         release_delay: Some(69),
         network_type: NetworkType::Evm,
@@ -635,3 +635,281 @@ fn could_not_remove_non_existent_network() {
             assert_eq!(Networks::<Test>::get(chain_id), None);
         });
 }
+
+#[test]
+fn bridge_storage_is_empty_by_default() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(),
+                BridgeAdjustment::default());
+        });
+}
+
+#[test]
+fn gatekeeper_amount_changes_correctly() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let amount_in: u128 = 420;
+            let amount_out: u128 = 69;
+            let result = amount_in - 3 * amount_out;
+
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(),
+                BridgeAdjustment::default());
+
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount_in));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), result);
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: 3 * amount_out,
+                bridged_in: amount_in });
+        });
+}
+
+#[test]
+fn commission_accumulation_is_correct() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission_first: u128 = 420;
+            let commission_second: u128 = 69;
+            let result = commission_first + commission_second;
+
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(&commission_first));
+            assert_ok!(GhostNetworks::accumulate_commission(&commission_second));
+            assert_eq!(AccumulatedCommission::<Test>::get(), result);
+        });
+}
+
+#[test]
+fn commission_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(&commission));
+            assert_err!(GhostNetworks::accumulate_commission(&commission), ());
+            assert_eq!(AccumulatedCommission::<Test>::get(), commission);
+        });
+}
+
+#[test]
+fn gatekeeper_amount_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), (commission, commission));
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), commission);
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), (0, commission));
+            assert_err!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: commission,
+                bridged_in: commission,
+            });
+        });
+}
+
+#[test]
+fn bridged_amount_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id_first: u32 = 1;
+            let chain_id_second: u32 = 2;
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: 0,
+                bridged_in: 0,
+            });
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &commission,
+            ), (commission, commission));
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_second,
+                    &commission,
+            ), ());
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &u128::MAX,
+            ), ());
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_first), commission);
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_second), 0);
+            assert_err!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id_second,
+                    &commission,
+            ), ());
+        });
+}
+
+#[test]
+fn accumulated_commission_could_be_nullified() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission_first: u128 = 420;
+            let commission_second: u128 = 69;
+
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(
+                    &commission_first
+            ), commission_first);
+            assert_ok!(GhostNetworks::accumulate_commission(
+                    &commission_second,
+            ), commission_first + commission_second);
+            assert_eq!(AccumulatedCommission::<Test>::get(),
+                commission_first + commission_second);
+            GhostNetworks::nullify_commission();
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+        });
+}
+
+#[test]
+fn bridged_inlation_reward_works() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            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;
+
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000, 0), (0, 0));
+
+            assert_ok!(GhostNetworks::accumulate_commission(&commission));
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (commission, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (commission, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (commission, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (13177472000, 192528000));
+            assert_eq!(13177472000 + 192528000, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (13177568884, 192431116));
+            assert_eq!(13177568884 + 192431116, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (13177568884, 192431116));
+            assert_eq!(13177568884 + 192431116, commission);
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000 + amount, 0),
+                (92386700, 13277613300));
+            assert_eq!(92386700 + 13277613300, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000 + amount, 0),
+                (92253000, 13277747000));
+            assert_eq!(92253000 + 13277747000, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0),
+                (92253000, 13277747000));
+            assert_eq!(92253000 + 13277747000, commission);
+
+            GhostNetworks::nullify_commission();
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000 + amount, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000 + amount, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0), (0, 0));
+        });
+}

pallets/slow-clap/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-slow-clap"
-version = "0.3.14"
+version = "0.3.15"
 description = "Applause protocol for the EVM bridge"
 license.workspace = true
 authors.workspace = true

pallets/slow-clap/src/lib.rs

@@ -1162,16 +1162,22 @@ impl<T: Config> Pallet<T> {
         session_index: SessionIndex,
         average_claps: u32,
     ) -> bool {
+        if average_claps == 0 {
+            return true;
+        }
+
         let claps_in_session = AuthorityInfoInSession::<T>::get(session_index);
         match claps_in_session.get(authority_index) {
             Some(clap_in_session) => {
                 let number_of_claps = &clap_in_session.actions;
                 let authority_deviation = if *number_of_claps < average_claps {
-                    Perbill::from_rational(*number_of_claps, average_claps)
-                } else { Perbill::from_rational(average_claps, *number_of_claps) };
+                    Perbill::from_rational(average_claps - *number_of_claps, average_claps)
+                } else { 
+                    Perbill::from_rational(*number_of_claps - average_claps, average_claps)
+                };
                 authority_deviation < Perbill::from_percent(T::OffenceThreshold::get())
             },
-            _ => false,
+            None => false,
         }
     }
 

pallets/slow-clap/src/tests.rs

@@ -35,7 +35,6 @@ fn prepare_companion(amount: u64) -> Companion<NetworkIdOf<Runtime>, BalanceOf<R
     Companion {
         network_id: 1,
         receiver: H160::from_low_u64_ne(1337),
-        fee: H256::from_low_u64_ne(40_000),
         amount: amount,
     }
 }

pallets/traits/src/networks.rs

@@ -23,7 +23,18 @@ pub trait NetworkDataInspectHandler<Network>: NetworkDataBasicHandler {
     fn iter() -> PrefixIterator<(Self::NetworkId, Network)>;
 }
 
-pub trait NetworkDataMutateHandler<Network>: NetworkDataInspectHandler<Network> {
+pub trait NetworkDataMutateHandler<Network, Balance>: NetworkDataInspectHandler<Network> {
     fn register(chain_id: Self::NetworkId, network: Network) -> DispatchResult;
     fn remove(chain_id: Self::NetworkId) -> DispatchResult;
+
+    fn increase_gatekeeper_amount(
+        chain_id: &Self::NetworkId, 
+        amount: &Balance,
+    ) -> Result<(Balance, Balance), ()>;
+    fn decrease_gatekeeper_amount(
+        chain_id: &Self::NetworkId, 
+        amount: &Balance,
+    ) -> Result<(Balance, Balance), ()>;
+    fn accumulate_commission(commission: &Balance) -> Result<Balance, ()>;
+    fn nullify_commission();
 }

runtime/casper/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "casper-runtime"
-version = "3.5.19"
+version = "3.5.20"
 build = "build.rs"
 description = "Runtime of the Casper Network"
 edition.workspace = true

runtime/casper/src/lib.rs

@@ -473,9 +473,9 @@ impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
 
 pallet_staking_reward_curve::build! {
     const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
-        min_inflation: 0_025_000,
-        max_inflation: 0_100_000,
-        ideal_stake: 0_750_000,
+        min_inflation: 0_006_900,
+        max_inflation: 0_690_000,
+        ideal_stake: 0_690_000,
         falloff: 0_050_000,
         max_piece_count: 40,
         test_precision: 0_005_000,
@@ -484,8 +484,8 @@ pallet_staking_reward_curve::build! {
 
 parameter_types! {
     pub const SessionsPerEra: sp_staking::SessionIndex = prod_or_fast!(6, 1);
-    pub const BondingDuration: sp_staking::EraIndex = prod_or_fast!(28, 28);
-    pub const SlashDeferDuration: sp_staking::EraIndex = prod_or_fast!(27, 27);
+    pub const BondingDuration: sp_staking::EraIndex = prod_or_fast!(1, 1);
+    pub const SlashDeferDuration: sp_staking::EraIndex = prod_or_fast!(0, 0);
     pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
     pub const MaxExposurePageSize: u32 = 512;
     pub const MaxNominators: u32 = 512;

runtime/common/src/lib.rs

@@ -21,7 +21,7 @@ use static_assertions::const_assert;
 pub use pallet_balances::Call as BalancesCall;
 #[cfg(feature = "std")]
 pub use pallet_staking::StakerStatus;
-pub use pallet_timestamp::{Call as TimestampCall};
+pub use pallet_timestamp::Call as TimestampCall;
 use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
 pub use sp_runtime::traits::Bounded;
 #[cfg(any(feature = "std", test))]

scripts/packaging/template.service

@@ -1,6 +1,7 @@
 [Unit]
 Description=Ghost Node
-After=network.target
+After=network-online.target
+Requires=network-online.target
 Documentation=https://git.ghostchain.io/ghostchain/ghost-node
 
 [Service]

scripts/patch.sh

@@ -0,0 +1,2 @@
+SCRIPT_DIR=$(dirname "$0")
+bash "$SCRIPT_DIR/patches/patch-1.sh"

scripts/patches/patch-1.sh

@@ -0,0 +1,32 @@
+DEFAULT_SERVICE_NAME="ghost-node.service"
+
+check_unit_file_validity() {
+    SERVICE_NAME=$1
+    if [[ "$SERVICE_NAME" != *.service ]]; then
+        SERVICE_NAME="${SERVICE_NAME}.service"
+    fi
+
+    SERVICE_FULL_PATH="/etc/systemd/system/$SERVICE_NAME"
+    if [[ -e "$SERVICE_FULL_PATH" ]]; then
+        NETWORK_ONLINE_EXISTS=$(grep -Fx "After=network-online.target" "$SERVICE_FULL_PATH")
+        NETWORK_EXISTS=$(grep -Fx "After=network.target"  "$SERVICE_FULL_PATH")
+
+        if [[ -z "$NETWORK_ONLINE_EXISTS" && -n "$NETWORK_EXISTS" ]]
+        then
+            echo "[-] WARNING: missing network-online.target dependency in $SERVICE_FULL_PATH, trying to replace"
+            sudo sed -i "s/After=network.target/After=network-online.target\nRequires=network-online.target/g" "$SERVICE_FULL_PATH"
+        else
+            echo "[+] INFO: network-online.target is set correctly for $SERVICE_FULL_PATH"
+        fi
+    else
+        echo "[-] No serivce found at $SERVICE_FULL_PATH"
+    fi
+
+}
+
+check_unit_file_validity $DEFAULT_SERVICE_NAME
+read -p "[?] Enter names for the node service, separated by commas (default: ghost-node): " -a SERVICE_NAMES
+for NAME in "${SERVICE_NAMES[@]}"; do
+    check_unit_file_validity $NAME 
+done
+sudo systemctl daemon-reload

scripts/starter.sh

@@ -7,6 +7,7 @@ INSERT_KEYS=false
 UNIT_FILE=false
 SKIP_BUILD=false
 SET_ENVIRONMENT=false
+VALIDATE=false
 EXECUTABLE_PATH="/usr/bin/"
 SPECIFICATION_PATH="/etc/ghost/"
 BASE_PATH="/var/lib/ghost"
@@ -88,6 +89,7 @@ help() {
     echo -e "-k, --check-keys\n\tCheck if your keys are already included in 'ghosties' file."
     echo -e "-y, --insert-keys\n\tInsert session keys to the keystore via JSON RPC."
     echo -e "-r, --release\n\tCompile node with '--release' flag."
+    echo -e "-v, --validate\n\tManipulate '--validate' flag in CLI_ARGS."
     echo -e "-p, --profile\n\tCompile node with '--profile [PROFILE]' flag."
     echo -e "-f, --features\n\tCompilation features '--features=\"FEATURE1,FEATURE2\"'"
     echo -e "-e, --executable-path\n\tPath to the executable ('/usr/lib/' is default)."
@@ -133,6 +135,9 @@ while [ $# -gt 0 ]; do
             RELEASE="--release"
             TARGET="release"
             ;;
+        --validate|-v)
+            VALIDATE=true
+            ;;
         --profile*|-p*)
             if [[ "$1" != *=* ]]; then shift; fi
             RELEASE="--profile=${1#*=}"
@@ -263,6 +268,32 @@ if [[ ! -z $RELEASE ]]; then
     fi
 fi
 
+if [[ $VALIDATE = true ]]; then
+    cli_args=$(cat /etc/default/ghost)
+    if prompt "[?] turn on validator mode?"; then
+        if [[ $cli_args == *"--validator"* ]]; then
+            echo "[+] '--validator' flag already exists in CLI_ARGS, check /etc/default/ghost"
+        else
+            cli_args="${cli_args%?} --validator\""
+            echo "[+] '--validator' flag inserted to CLI_ARGS, check /etc/default/ghost"
+        fi
+    else
+        cli_args=${cli_args// --validator/}
+        echo "[+] '--validator' flag removed"
+    fi
+
+    echo "[+] trying to store CLI updated arguments to '/etc/default/ghost'"
+    echo "$cli_args" | sudo tee /etc/default/ghost > /dev/null
+    echo "[+] updated CLI arguments stored in '/etc/default/ghost'"
+
+    if prompt "[?] do you want to restart 'ghost-node.service' now?"; then
+        sudo systemctl status ghost-node.service
+        echo "[+] 'ghost-node.service' succefully restarted, new CLI_ARGS applied"
+    else
+        echo "[+] don't forget to restart ghost node service manually"
+    fi
+fi
+
 if [[ $MAKE_GLOBAL = true ]]; then
     cd $PROJECT_FOLDER
     echo "[+] trying to copy executable to '$EXECUTABLE_PATH'"

service/ghosties

@@ -108,3 +108,33 @@ Public key (hex) for audi  : 0x1496150847d512e0491899eba72ee36f76b882ae29fccf182
 Public key (hex) for babe  : 0x8006e3f6e3d92c4c5f2e2f001452e4993e6d5c2b1136f2ae6060c6e9c9523b4a 
 Public key (hex) for slow  : 0xaaa41b6ade4c30b5792aa6e5604c444e424900ddf649b23eed4bd0d7f5d3a34f 
 Public key (hex) for gran  : 0x86ee138c9e7e67c1c2e157c0ba888761a122d8b9aa6a8653e886ac329e34255d 
+
+### Osiris-3 ###
+Local identity             : 12D3KooWSDL7dwYgExExi7vuxzMJFyLrsyx4oLJCejv9Q2gste93
+Public key (hex) wallet    : 0x64f685baa838323c0ef8c45259a3036b3e2bc54edf6553ce323e25b5e37a3721
+===============================================================================================
+Public key (hex) for stash : 0x40eef1c6c8d8242ccbd3f03144bd4ea1a7374cbd8219e2849d3a3ee78f1da045
+Public key (hex) for audi  : 0x8c3e730f6e6ecfb96581091e71556175384f077bee31b0199f13321df018427d
+Public key (hex) for babe  : 0x3a145fb664353e473f1937058c881b14ed150285f3cec1aff348c5209d56d96d
+Public key (hex) for slow  : 0xceb294227950d177b63e6c1d10a66131f5da3792428b03f5b83be84a33db215f
+Public key (hex) for gran  : 0x0c0891a518270014530061bd217606269686abdf3c1d237a3c6a3db308fc2d0d
+
+### Ogenkido ###
+Local identity              : 12D3KooW9zt8De3STX4TC8mALfDn8oJw1Qw6dBhRwu2aTabroBBr
+Public key (hex) wallet     : 0xa0a87a75dba18037aa2e7b8036ce951e8d8356104758e15c9f44e2fd7d1bbc41
+===============================================================================================
+Public key (hex) for stash  : 0x422e16b0c58f03af378d1638fe56127f337abf1d1a4a740c3371714616abd43d
+Public key (hex) for audi   : 0x52fe2b63b03a0d439923967278442418a2d1f0d250bcab26f85f12ea212cbd3e
+Public key (hex) for babe   : 0x78f612068566eb6cc5cb5d9f1fda92c5dc3e3888eb61eb1af27af6855365ba3c
+Public key (hex) for slow   : 0x027dd852bf20bef53545afd1e08bf8760abb6b1af1df6c17e73f4cf88210ee46
+Public key (hex) for gran   : 0xdba3613933d60ca248ee024deac42bc9c8c2d9fe8734b6052cd9a148978cbedb
+
+### Youconnect  ###
+Local identity             : 12D3KooWJXBYA7cUQLLenEfT7hmCjBJ6fyikDy8YhNz4aLfwbBC8
+Public key (hex) wallet    : 0x6e4429a8fa85cfe2a60488af446d57e719207831b2579b937325645e110bb666
+===============================================================================================
+Public key (hex) for stash : 0x3a6626211a2dd35683fd7cb5f2f343d75f2b698d6c48c2d6eb1cdbe116e32315
+Public key (hex) for audi  : 0x86676ad3cd2d970b86dee2f25d4318f9bba40455111f16300e114e7f00c58706
+Public key (hex) for babe  : 0x6c0aec49974aaff08ff962a2d8d7857227d027ed27a272cbc4acaa1ee937db0f
+Public key (hex) for slow  : 0x009712519ba7dad1c682c871b94573ccaba8b7d530f7194fb16bf553fd7ae67d
+Public key (hex) for gran  : 0x935becdfb2e0d4fcd46ba82e680cfc447180de6b85ec42d17f1396a520b0c04f

service/src/chain_spec.rs

@@ -13,7 +13,7 @@ use pallet_staking::Forcing;
 #[cfg(feature = "casper-native")]
 use casper_runtime as casper;
 #[cfg(feature = "casper-native")]
-use casper_runtime_constants::currency::CSPR;
+use casper_runtime_constants::currency::{CSPR, STRH};
 use sc_chain_spec::ChainSpecExtension;
 #[cfg(feature = "casper-native")]
 use sc_chain_spec::ChainType;
@@ -288,6 +288,148 @@ fn casper_staging_config_genesis() -> serde_json::Value {
     use hex_literal::hex;
     use sp_core::crypto::UncheckedInto;
 
+    // Endowments for the whales from previous testnet.
+    let whales_endowments = [
+        // sfHXFVNvLVp8uSZauMyMijqXfoods8kkkik2MKnmr5MTdsweh
+        (hex!["a8ab31b36aae0dc29d2b92714cee75ee2784037c6f150d759d9aa757ab5a4666"].into(), 25 * CSPR),
+        // sfEtW9ijdwbU17oderTmwseMV84c7c9Xi1JW7T94rBbYKMMZq
+        (hex!["342c0035531136ff50d8488eb4d4772dfd10e565f6a5d28c7298b354d33f2dfe"].into(), 14 * CSPR),
+        // sfJtE2J5yVQBHdzwmXhzTwQZLtS853MFkUVYv5AfnB7TEVp2E
+        (hex!["e4e6a493d23633bf72b16ead89ab1451611b08311a9a49cc874a92e6ac4f5b1d"].into(), 31 * CSPR),
+        // sfFf48EnVLjD4wMecZh7meP5RWwYXZr54QiW2xQyPKPjxsxNo
+        (hex!["56266f27a02869f9498a113cbd4d1507ae5f4b8c91a6b8ccecda3331c21fd67f"].into(), 6 * CSPR),
+        // sfHxHVmMKZfUUzXRzKrV3oXSSynG1uAJ7c6dhFSq4CwE8qLn3
+        (hex!["bbc31594a2338e91c248aba474d892f41811a072c7e7c692fcae07fdb398b89f"].into(), 3 * CSPR),
+        // sfGvSkgfv99AndiEuhmL6t49ekbb2og2aYVRisAeNMPHueACW
+        (hex!["8e1f85cc6bb89182bc473859287b82fc2b9c89f461431090c2246a1a8d92d911"].into(), 14 * CSPR),
+        // sfHfByscdWfjzQNXc5g2q2ScMhop5pr5TiqiZosKxtMit1bRy
+        (hex!["aeb95893ab118bf02f5cd80ebab71ba58490c645e4302773fdc90b659f5c5e22"].into(), 11 * CSPR),
+        // sfGh1jtdTwWEco2N6cymxKgaoAJwYFMj2K2tdEbuML5LjUprc
+        (hex!["83e120fa3994efedc51092a8d90882803997f39f552a37699e3acb06c1f8158d"].into(), 28 * CSPR),
+        // sfJHvJDgdKdo1ZFXB146jhKVgngDrDeKTKF3GV5Eyvg1tJqTq
+        (hex!["cabca1450cbdc5769fa8f7b80d5bfd00df35b65613d8694e02517c9415fc5462"].into(), 12 * CSPR),
+        // sfE4SvLvh66FSThDnrTx5Qf5vHNCmBkrAJy8Zt8pMPN8h6dzw
+        (hex!["0f85589e37f3c0859ba7c055dec527a63796d6285b73cf8bd4657da052ff893c"].into(), 2 * CSPR),
+        // sfHJF1dYfzCpjJ8QHRBexNMfvSfsJvE75eCzgosrB6PwFXmpz
+        (hex!["9ebf64b6bc73baf1428da1cfcf36fde9695be0a56a855ddabb5612a70b10e447"].into(), 6 * CSPR),
+        // sfEEixqLWYct7au1PWkQAKbyso5VQhrgXQ2RXVW5TjcBm3vZ6
+        (hex!["175bce3674e24ec942112d91df594ba551b329ae7183b0faaef79fa051a85948"].into(), 21 * CSPR),
+        // sfH5nCFu2wNXnfD1Fic1weyLHncxHb7qpa8yXXQuNbQRUm9HH
+        (hex!["953e2cdbf7a66e34c50c51d199ad8970b1b2233da5604eb79a1de8d277c03061"].into(), 10 * CSPR),
+        // sfJnVLd4PMfoABtQiPmifeqkpQQKoV4wbXyAzhXKdSDHfi1bY
+        (hex!["e086ba892126243d6ef1c2b9132790e4455a3b1271baac8033306d55c8473af4"].into(), 30 * CSPR),
+        // sfECamJamifU5XyHH27ekuWY3MHAwj1z3rDcV2rpWdeGdAe2Y
+        (hex!["15b9b710a589968804e6e00f2ccb576ded431627a733b7f9fa0845f59e73f5cc"].into(), 31 * CSPR),
+        // sfEAhZrKxxChBR5SHQML6gNDJCK2FTMnRZZ2s2KVCFRxqFFTG
+        (hex!["144a1fa97fdba679efd2a36696a0d40f585b649143bb7da5cbd7458ea4a0f674"].into(), 2 * CSPR),
+        // sfDrDchmoxEfzyyPFWGX2fekP4mic99D6inhPnRvwokRZCbv5
+        (hex!["06319d9539108995233c48032bda04d50115fe829a2c4b5b23e54a4d17188606"].into(), 14 * CSPR),
+        // sfEb6NRc4ZbcuWUGJAnBkvEoacoXLbHZSM1asLpHiXqeY6YkE
+        (hex!["26e4c66dab5d9df3cb196ce320314e2565489f7d56b9868299a68cc4a1b4c917"].into(), 24 * CSPR),
+        // sfHfQMwpzNaA3D1uRGrzNPwZDeFbdXQDBJMay1oFDmD7C2RLn
+        (hex!["aee305cf2e015ef860c96815bb34ff9ac7df36db95f0587b6ded75218ae0d526"].into(), 22 * CSPR),
+        // sfKPnkuxV9u7AEk6bqU4i83NpAeG5w6VjcXYER5yfoojkkcN4
+        (hex!["fb72f46bd61ce821d12f5bdd6dc587afe5ae5821632b7e4b09464ea9e04111e3"].into(), 4 * CSPR),
+        // sfJGyU6k2gPVhmQJvgtY3iaVsakKQuD56jdgKZTGRLwjkHcbQ
+        (hex!["ca040e9167e0e7675ea2163506706cb7883a601a9ece1ba702fd253446f69e5d"].into(), 19 * CSPR),
+        // sfF8tAs7Z9R3GU8AnWgHEubxbwGt4zk7V6gSBeJJSqvt1xs8e
+        (hex!["3f238fbe70fdf9df12ed42416be91fa556802e7be7ea43c4de33314f5fb2da53"].into(), 22 * CSPR),
+        // sfHtQ3XxjAc3fbr4rxnx5P5ejV7LPXnN8nXwxevJ5MZwPJFCa
+        (hex!["b8cc24f449bd14c9903431b710842e1398a83d2ced33c5ea8fa4b75461db2f1f"].into(), 28 * CSPR),
+        // sfG5KDhmeKs6jXC2Jt1otffwHQyLR58dMGHwJCizUJHr4a7pU
+        (hex!["68a722b719350846a1f5a83143e01fdf18422d0d3d489877510062498ba74e5b"].into(), 17 * CSPR),
+        // sfH28MB4HFrE8YmtAcj95oTyMsQ9GgYWqxVtisWPqV5SwSMVS
+        (hex!["9275098141352f7e4fb3a4be9b2e50269947b7f54ecf2a493454955dd327274a"].into(), 28 * CSPR),
+        // sfEBNrjumQ8GLJTxeu3HvUDqHki3UxHCoSzg1x8SDJkfWfhWc
+        (hex!["14ce63bf285ad88594a93af2f1b8fd822c4db73030ae0783836083201876cb71"].into(), 14 * CSPR),
+        // sfFMYowKRoik3N9tYoSaPZ4vGPaPrDaezXiTVGZUBGWEwSKWQ
+        (hex!["48cc93d26f56df01cbd642e2d6eca745a9e2b84616e7f3b405411963c9aefa2f"].into(), 11 * CSPR),
+        // sfHPg4uVcq3s3TnfqHcsT6nEmeKJuNiJCW2eHk8Uk5aRfS7jr
+        (hex!["a2e3f7cfc7d8b7992a17b7aa8a85b47f1e0d254f3f0b760764f79af5a8349b33"].into(), 22 * CSPR),
+        // sfFo97CYcVqhjeiQiu6umcDggkNRWNjNu3XA6pU67F2C4Zs7g
+        (hex!["5c512b2cdb7da57ac056d6573ae3d1ae027bcec1b3b3d4dd79dc50160b24101b"].into(), 3 * CSPR),
+        // sfGxyWHjTMDVfmScYXjRFwXuVLyPj6XB8nzVjeZTLZ8RQkXQU
+        (hex!["900d88832e0748670c2358f2238bd34aaf49e070aa41aba84d931a0d1fef0978"].into(), 15 * CSPR),
+        // sfJHHLnAf9kbZz1PL4ESDpEMuAw7GXfFigC9wJD7ZArqRPwVG
+        (hex!["ca4039b68f9924c12399808da77247f2f45b0a9e397de94a33104c610cd8287f"].into(), 1 * CSPR),
+        // sfHqoR2AnJgWckgFY4HE2p5SK5gf6mUZGCXV5S3Ck7mnpTWps
+        (hex!["b6d11481813a6968a1d056794e6f0b85408480c5e8a6056769fbec9b5424314d"].into(), 18 * CSPR),
+        // sfJCVDhbVQzg7Y9JTm9mYiowUg2SuGQLLKGPwtstLVgtrcnmu
+        (hex!["c697fbb0ecf8069a0f88292d0a2097ba24b8c6998d04d21a02d92f6a23a65b43"].into(), 11 * CSPR),
+        // sfFFc7sBndJG1sZpxXfzti9K4Z7cNNfW8EQtEzsX9B1BWXoBv
+        (hex!["44443e9670b7f6decd4da7b042b6c9f740bd6b82e564fd51c1453fa442f0192f"].into(), 15 * CSPR),
+        // sfJbxCLF7tdMQRqzVgTiGyJQ2V2tEJXeC9pmeZqRaH3kNqYFA
+        (hex!["d87d702b99b8b3d58d8a48e5d750f40338b3a3d43fab09c23c50036226ba5325"].into(), 28 * CSPR),
+        // sfDrr9Vh9k3hC8JnpN4BG15z5yJPfMhHuPwFsZrd3S62b5U2Y
+        (hex!["06ac96e99519ae0a38f2475edfda3e432d3ae8d1f889a82e9ded1f1ccc850505"].into(), 15 * CSPR),
+        // sfJq7W4AboVKNgeG33y2oCE5o6h3eJaG6cyoKwtqjTkjSZXs4
+        (hex!["e286f428cd368ae7249d4ea76ad17df9350b0dcb437eadbf60053177769fbc5a"].into(), 14 * CSPR),
+        // sfG8ERVrJaoaJZdxT8tt9ZBRH4y1q9RHkyW1juiQBFjfqNm5s
+        (hex!["6ae0b990e482c499d93382e6183c0d2f3e8228e603de7c154ffb93e2299f152a"].into(), 14 * CSPR),
+        // sfG7q2arcyPyzNWrEZRoFvrf6go5PuhwofYVcthR3Mpu8dHgz
+        (hex!["6a91f855ff00e83c9b03cc222291cd6d098be0318eb60b88e6c167ce9e513a50"].into(), 11 * CSPR),
+        // sfFoee91wxv2u9LRFxCv9pzpM9L9YWGX2CPZveLFWbntrq6zd
+        (hex!["5cb4964925c2061492b88ff8daea2804b5770c044946c4ff0ac5a170eab1422c"].into(), 26 * CSPR),
+        // sfGkHJcQDaqeagPGrpaNFKR1kdRShUZH4Ec8iYMj6kyH8M2Tg
+        (hex!["865f4233b54d0903f5fdad05b0ec715b0ad9613fc69df18df4a013d3c7d3ab73"].into(), 2 * CSPR),
+        // sfFXJNrot6ou3UAmcynzSrD1RZnZzyhKM4gdMPfuDLUhCPyDs
+        (hex!["503c72a0f2c549a62d876dea81aa2e597b88503fa639ab0e9b65db599785f61d"].into(), 26 * CSPR),
+        // sfJyW71FYeFRb3YSQSVJAEp3CjPpNcUmzkw7riKMSkCiBEAs6
+        (hex!["e8ed0109c607d78aec9d8aa3575a565e34d65b399a5bd0e0102032d807ea0975"].into(), 5 * CSPR),
+        // sfKCXSvdcMTWyJDXDdZ2QP88ZsHDiwnGPfDVRPetf6KQfDAKY
+        (hex!["f2dbb77f0f922e5e92d98de7d43612d2f0b0d503aff20607d6c771fe8ee4a623"].into(), 31 * CSPR),
+        // sfJjXxYZNuXNirgQFE4MxuJ1w2ekxXHvXtowqUqEN52BNRryW
+        (hex!["de45cf59f588af5ee252c0ee0c805be8fa1ce172f8a6187d3b63dce1dc9c0b60"].into(), 8 * CSPR),
+        // sfGZf5wgfaLUq3h3JwHgZ52Fg2P27JYn2tSCgjosp4gL2Mdpx
+        (hex!["7e44e1ede822621cc9f618480433fe002bb8edde02d2fcd4fcf406409e154e68"].into(), 28 * CSPR),
+        // sfETREDdpH8vyT6zHEfcF5qdJhNw8iJVFeSfspKHv2BeUGQg5
+        (hex!["210a4b979e39c3136be105df1974fc036f4fe9b035936c149bdb94a3f4820487"].into(), 6 * CSPR),
+        // sfHA9NkB5Bb5hgt1f58jf1UminCdrmyu94VGoKB3jo9YRoPjW
+        (hex!["98927535310e1b910ca19860e1539a15c5dc02df780a66a22f5796cec3768812"].into(), 12 * CSPR),
+        // sfJeYC8LPe41yBP8WptgSzkYgfM39y3derRV4YeYXkpEysT7b
+        (hex!["da765f0ad9bedffdc9aa88da6fdacf4afa4463395785b6e03acb0811395a8f5d"].into(), 20 * CSPR),
+        // sfEu7ZzgjwEuhS1EkebXfkvH3wMyxpSgcvH8btDi6EMqG4goQ
+        (hex!["34a33af049f4f1b65d518e51f38c7afb0cd973c649588808b2ba0211f4ada535"].into(), 5 * CSPR),
+        // sfHZx1bZK6aoJKfQ1XQfpRD5VZBXZM1uREGcBsnKJdTZDnDod
+        (hex!["aaba173e1cd257c1ba67afbed0fbf2c4aadbfac329f129f12c4941b8b6bc5865"].into(), 5 * CSPR),
+        // sfJHhyq2r19nHEbKbVn3NEWqkDWnK53rU9mpRVPEYh7dqkCwU
+        (hex!["ca932abf1648393d722ad23c2cd97515a436840d905d3dd2b4d1913989abbc12"].into(), 2 * CSPR),
+        // sfE8Hv37BNfZfdj6aKC8XuBPQRG6eLRJPuRqEmrCfPGF4F7Ag
+        (hex!["1274036453f19a410d99cd7a13235422062ff5b0d2dbd608d87ad33b9b7b544c"].into(), 17 * CSPR),
+        // sfJHHALMCEmBTJHEdHkgMbUt2XMFP4K2AcYPiwgtz429YUqWv
+        (hex!["ca3f9e8480f200b6afe9661cb96a30259fc88b947c3ab466bd2b8e902a859719"].into(), 2 * CSPR),
+        // sfKTaDy3Yw6eXz4GFfXLRx9LnDf8qEt4JpqnPJc8bQVAu6kET
+        (hex!["fe55bea13108c5f9e070689c96d63c40ca79db709bebe921289003e56a1fdf27"].into(), 3 * CSPR),
+        // sfJ4NLMc92S6gSvQLsxUvhh4zXwde1yHYJCBu2WFjwL1Hxgfh
+        (hex!["c066d79465a7bd3138c770f52c1ad160272705e98f9b3dacc22bc70f010a1564"].into(), 12 * CSPR),
+        // sfJcMpW8ESzTzpmftos8MoJ7pUyRbxPabxPHSuigfxQxy8GBR
+        (hex!["d8ccf65eb5e93fdf7af47e9c6962a6822c7f0e8ed14d84f2bebdae0c5623e62b"].into(), 16 * CSPR),
+        // sfESZE2fNkkRCR2bSmmKZ5VzmMGHFh8eUdE2isdjne7JGW9AU
+        (hex!["2061f823e814d8c6b524da2f26ba2bfa048bbce57a1186e560b84c47a162b927"].into(), 1 * CSPR),
+        // sfFSxdDQWSnuF2zJ3tRv3B9Xxzu8boEkByCSXkq1T1F6vRky5
+        (hex!["4cecf92b37e6954f086002cf7b6a61ac7d9ba40c83ef963005e3cacfb5c1e13f"].into(), 21 * CSPR),
+        // sfEivpTTfp6Xh7nHaco1sxXQiy163pT474cS2dj8d8MREaJ2x
+        (hex!["2cde961358bf934533495f186755eb538a925aaa19ab4bad097f9d23665a9553"].into(), 24 * CSPR),
+        // sfJHPU8JPeCg35QvgTwZ2iFAwiavxem4McAYtgvTKpePSnUrw
+        (hex!["ca54d983c77c48c948fa9a6f9261ce2d9c4f20abf6632e28da3ec41d4752d519"].into(), 8 * CSPR),
+        // sfDyruPst6vv93A1pUYtmNQa95iypWhMw1n4PWDfpP9g1WHTQ
+        (hex!["0c05daf23268fdae4efd5bc1211f662c63399be10666ad3bdc75f3470a5b3378"].into(), 11 * CSPR),
+        // sfG5dZrh8trJRWewe1THxhvCTdR1Qq6NDUkoGuQg4VA6iAm2z
+        (hex!["68e4e6131e6a7aaf5ab2629d2ee721031df2e2a6573701862508fa3dc5765f5c"].into(), 4 * CSPR),
+        // sfHNVjWNHs6fwPpHmmPj4nJQ7evN35qr9KkJVeiJjmyf3fGxj
+        (hex!["a1fdef07d92813b10b15914afe763aa16bbf3feca8db73fabf1422cd48e05db0"].into(), 16 * CSPR),
+        // sfEYCLQnQzp8EYfqqhWmB1mtWNPX9AmVLGiwhVpFVQ5JuuGmu
+        (hex!["24af1eab02801a2d1afe16c75baa55f930138d58229f02f2840f387241529424"].into(), 18 * CSPR),
+        // sfDwQQ2Zy16Hx5qnHQbsXw8reMewJ684yUydmTXT7E3Y489se
+        (hex!["0a2622dc4be5606375d3a47e56e2580636b0057c46ec85bd44e149bff55fb943"].into(), 27 * CSPR),
+        // sfFMhheEBKGwDcJ9aqpYvVsAAq3tu2tEcVaRd66zfxY8qaShs
+        (hex!["48ea8240144388abb847a7b2c52f6290aeb77f1b6d8e10cda7d14a2f48b05035"].into(), 3 * CSPR),
+        // sfE66BLe2b6wM9dWctMnizM7yzadJrzGtTDC64cMTmJxZqGG1
+        (hex!["10c603d5a51516d1ee97212cf0b79f106332439750673b8605a527ffe1d45c50"].into(), 3 * CSPR),
+        // sfEiXa1R4CGPDZcdJ7oEnTuwiicA5Dhtny8z7aYhSrbDQNygK
+        (hex!["2c90529d502a1f3c51fcf487782b4defa09bd0e7470d1d080e44da713058241c"].into(), 24 * CSPR),
+    ];
+
     // Following keys are used in genesis config for testing (casper) chains.
     // DO NOT use them in production chains such as ghost.
     let endowed_accounts = vec![
@@ -311,9 +453,14 @@ fn casper_staging_config_genesis() -> serde_json::Value {
         hex!["4078ddb1ba1388f768fe6aa40ba9124a72692ecbcc83dc088fa86c735e4dc128"].into(),
         // sfFqT8fmF15Ddshio5rnucmqzMxtUoHZVh7qSALSdAaM7Y6zb
         hex!["5e1456904c40192cd3a18183df7dffea90d97739830a902cabb702ecdae4f649"].into(),
+        // sfFzUcPxuourb6JtdiudRkrsbnkxne1KEcpksVMJYGau5BVTG
+        hex!["64f685baa838323c0ef8c45259a3036b3e2bc54edf6553ce323e25b5e37a3721"].into(),
+        // sfHLkJNKVyAsVMC4bQQwsm1EMyWgKLQH8FFnZzLC78dYJDqSp
+        hex!["a0a87a75dba18037aa2e7b8036ce951e8d8356104758e15c9f44e2fd7d1bbc41"].into(),
+        // sfGCg772bqKp3wH23EQbgSbCQ5Q8BCwmCJ39XjR3xLwq6foYD
+        hex!["6e4429a8fa85cfe2a60488af446d57e719207831b2579b937325645e110bb666"].into(),
     ];
 
-
     let initial_authorities: Vec<(
         AccountId,
         AccountId,
@@ -462,9 +609,50 @@ fn casper_staging_config_genesis() -> serde_json::Value {
             // sfHZqUptNXpRNGPHKn2Tfv8K1RjFGJ9XCdSw41nPAw9ZXM37T
             hex!["aaa41b6ade4c30b5792aa6e5604c444e424900ddf649b23eed4bd0d7f5d3a34f"].unchecked_into(),
         ),
+        (
+            // sfFBEdrB1J7jLJKQp3fABEiHkwec1gCgGeTxMVyVm4UjWwvRs
+            hex!["40eef1c6c8d8242ccbd3f03144bd4ea1a7374cbd8219e2849d3a3ee78f1da045"].into(),
+            // sfFBEdrB1J7jLJKQp3fABEiHkwec1gCgGeTxMVyVm4UjWwvRs
+            hex!["40eef1c6c8d8242ccbd3f03144bd4ea1a7374cbd8219e2849d3a3ee78f1da045"].into(),
+            // sfF2FRJSuQSCidfbpu8DwpsHwezCcBJcZfh7Pds5vqtEF3Rbw
+            hex!["3a145fb664353e473f1937058c881b14ed150285f3cec1aff348c5209d56d96d"].unchecked_into(),
+            // sfDysi9h3PJoA5BGeJ2vfAkx3wXS9oK7yTDUyuJG2CRMJvXnh
+            hex!["0c0891a518270014530061bd217606269686abdf3c1d237a3c6a3db308fc2d0d"].unchecked_into(),
+            // sfGsyqzBAT7a9oBGdDBykyRwF95wRBL4yaGs4QFWznXHw5xsF
+            hex!["8c3e730f6e6ecfb96581091e71556175384f077bee31b0199f13321df018427d"].unchecked_into(),
+            // sfJP7W9aZe2F6G5w7xZtHhzSUCg86SvUcur4GPm2LMs7N2f5w
+            hex!["ceb294227950d177b63e6c1d10a66131f5da3792428b03f5b83be84a33db215f"].unchecked_into(),
+        ),
+        (
+            // sfFCsSaJrPqkCZMdkm7WoyHP7w3UbNaC3aCHQfWbUaLbDqfdR
+            hex!["422e16b0c58f03af378d1638fe56127f337abf1d1a4a740c3371714616abd43d"].into(),
+            // sfFCsSaJrPqkCZMdkm7WoyHP7w3UbNaC3aCHQfWbUaLbDqfdR
+            hex!["422e16b0c58f03af378d1638fe56127f337abf1d1a4a740c3371714616abd43d"].into(),
+            // sfGShS9zKf8nzDr71qPv9LZJtK1LCMxPV4QUMYG8jvZhVe9pS
+            hex!["78f612068566eb6cc5cb5d9f1fda92c5dc3e3888eb61eb1af27af6855365ba3c"].unchecked_into(),
+            // sfJg5cPBkyrcu7zZaKaUkjp2vDVGfpGNjjT1sn8fS6qjv9mDU
+            hex!["dba3613933d60ca248ee024deac42bc9c8c2d9fe8734b6052cd9a148978cbedb"].unchecked_into(),
+            // sfFav2ALRGkJtmEHEpz2LiRmshGPzn4aWdAZeFUyKA56LqDDF
+            hex!["52fe2b63b03a0d439923967278442418a2d1f0d250bcab26f85f12ea212cbd3e"].unchecked_into(),
+            // sfDmN4zoicQ54R5MmSpCf9ojg8zE2eD3x39pnba412oDivkBc
+            hex!["027dd852bf20bef53545afd1e08bf8760abb6b1af1df6c17e73f4cf88210ee46"].unchecked_into(),
+        ),
+        (
+            // sfF2fiFe2PteoYe286cZNJpxaT1omCPuTgwHjB1Z8tqjsLxRn
+            hex!["3a6626211a2dd35683fd7cb5f2f343d75f2b698d6c48c2d6eb1cdbe116e32315"].into(),
+            // sfF2fiFe2PteoYe286cZNJpxaT1omCPuTgwHjB1Z8tqjsLxRn
+            hex!["3a6626211a2dd35683fd7cb5f2f343d75f2b698d6c48c2d6eb1cdbe116e32315"].into(),
+            // sfG9m1LEV1sjUwyLwp1UQPUGnuMGF1oaCjSC4PVx9q4zgJRMr
+            hex!["6c0aec49974aaff08ff962a2d8d7857227d027ed27a272cbc4acaa1ee937db0f"].unchecked_into(),
+            // sfH3JwHTbimvG3SZLd5d8Ad8Ztvgb8NVSwxxzxYfArpXVYqFD
+            hex!["935becdfb2e0d4fcd46ba82e680cfc447180de6b85ec42d17f1396a520b0c04f"].unchecked_into(),
+            // sfGkKjBX5UdujuTrbxyepUzdU4Jew7DvgNs1UUM2HBLj4xNM5
+            hex!["86676ad3cd2d970b86dee2f25d4318f9bba40455111f16300e114e7f00c58706"].unchecked_into(),
+            // sfDisU5wryao4kcd4WuHyZZB6LfJrDuoQoU14cTiiJqD7Whoc
+            hex!["009712519ba7dad1c682c871b94573ccaba8b7d530f7194fb16bf553fd7ae67d"].unchecked_into(),
+        ),
     ];
 
-
     let ghost_accounts: Vec<(AccountId, u128, u8)> = casper_testnet_evm_accounts();
     let evm_networks = casper_testnet_evm_networks();
 
@@ -477,6 +665,7 @@ fn casper_staging_config_genesis() -> serde_json::Value {
                 .iter()
                 .map(|k: &AccountId| (k.clone(), ENDOWMENT))
                 .chain(initial_authorities.iter().map(|x| (x.0.clone(), STASH)))
+                .chain(whales_endowments)
                 .collect::<Vec<_>>(),
         },
         "session": {
@@ -497,7 +686,7 @@ fn casper_staging_config_genesis() -> serde_json::Value {
                 .collect::<Vec<_>>(),
         },
         "staking": {
-            "validatorCount": 10,
+            "validatorCount": 500,
             "minimumValidatorCount": 3,
             "stakers": initial_authorities
                 .iter()
@@ -510,12 +699,10 @@ fn casper_staging_config_genesis() -> serde_json::Value {
                     )
                 })
                 .collect::<Vec<_>>(),
-            "invulnerables": initial_authorities
-                .iter()
-                .map(|x| x.0.clone())
-                .collect::<Vec<_>>(),
             "forceEra": Forcing::NotForcing,
-            "slashRewardFraction": Perbill::from_percent(10)
+            "slashRewardFraction": Perbill::from_percent(10),
+            "minNominatorBond": 6_900 * STRH,
+            "minValidatorBond": 6_900 * STRH,
         },
         "babe": {
             "epochConfig": Some(casper::BABE_GENESIS_EPOCH_CONFIG),