Compare commits
No commits in common. "0375bd1434be17ef096a6fb9dd2a57091489a906" and "0c3636fe79482510590da48e514862ed31115f84" have entirely different histories.
0375bd1434
...
0c3636fe79
20
Cargo.lock
generated
20
Cargo.lock
generated
@ -3504,7 +3504,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-claims"
|
||||
version = "0.2.4"
|
||||
version = "0.2.3"
|
||||
dependencies = [
|
||||
"frame-benchmarking",
|
||||
"frame-support",
|
||||
@ -3528,7 +3528,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-cli"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"clap 4.5.4",
|
||||
@ -3584,7 +3584,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-machine-primitives"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"sc-sysinfo",
|
||||
@ -3593,7 +3593,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-metrics"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"assert_cmd",
|
||||
"bs58 0.5.1",
|
||||
@ -3648,7 +3648,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-networks"
|
||||
version = "0.1.11"
|
||||
version = "0.1.10"
|
||||
dependencies = [
|
||||
"frame-benchmarking",
|
||||
"frame-support",
|
||||
@ -3667,7 +3667,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-node"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"assert_cmd",
|
||||
"color-eyre",
|
||||
@ -3698,7 +3698,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-rpc"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"ghost-core-primitives",
|
||||
"jsonrpsee",
|
||||
@ -3750,7 +3750,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-service"
|
||||
version = "0.7.201"
|
||||
version = "0.7.200"
|
||||
dependencies = [
|
||||
"assert_matches",
|
||||
"async-trait",
|
||||
@ -3834,7 +3834,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-slow-clap"
|
||||
version = "0.3.33"
|
||||
version = "0.3.30"
|
||||
dependencies = [
|
||||
"frame-benchmarking",
|
||||
"frame-support",
|
||||
@ -3870,7 +3870,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "ghost-traits"
|
||||
version = "0.3.23"
|
||||
version = "0.3.22"
|
||||
dependencies = [
|
||||
"frame-support",
|
||||
"sp-runtime 31.0.1",
|
||||
|
||||
@ -17,7 +17,7 @@ homepage.workspace = true
|
||||
[workspace.package]
|
||||
license = "GPL-3.0-only"
|
||||
authors = ["571nky", "57r37ch", "f4750"]
|
||||
version = "0.7.203"
|
||||
version = "0.7.200"
|
||||
edition = "2021"
|
||||
homepage = "https://ghostchain.io"
|
||||
repository = "https://git.ghostchain.io/ghostchain/ghost-node"
|
||||
@ -229,7 +229,6 @@ ghost-traits = { path = "pallets/traits", default-features = false }
|
||||
ghost-networks = { path = "pallets/networks", default-features = false }
|
||||
ghost-claims = { path = "pallets/claims", default-features = false }
|
||||
ghost-slow-clap = { path = "pallets/slow-clap", default-features = false }
|
||||
ghost-sudo = { path = "pallets/sudo", default-features = false }
|
||||
ghost-runtime-constants = { package = "ghost-runtime-constants", path = "runtime/ghost/constants", default-features = false }
|
||||
casper-runtime = { path = "runtime/casper", default-features = false }
|
||||
casper-runtime-constants = { package = "casper-runtime-constants", path = "runtime/casper/constants", default-features = false }
|
||||
@ -272,7 +271,6 @@ members = [
|
||||
"pallets/networks",
|
||||
"pallets/claims",
|
||||
"pallets/slow-clap",
|
||||
"pallets/sudo",
|
||||
"utils/bags-list",
|
||||
"utils/chain-spec-builder",
|
||||
"utils/generate-bags",
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "ghost-claims"
|
||||
version = "0.2.4"
|
||||
version = "0.2.3"
|
||||
description = "Ghost balance and rank claims based on EVM actions"
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
|
||||
@ -6,14 +6,14 @@ use frame_benchmarking::v2::*;
|
||||
#[instance_benchmarks]
|
||||
mod benchmarks {
|
||||
use super::*;
|
||||
use frame_support::dispatch::RawOrigin;
|
||||
use pallet_ranked_collective::Pallet as Club;
|
||||
use frame_support::dispatch::RawOrigin;
|
||||
|
||||
#[benchmark]
|
||||
fn claim() {
|
||||
let i = 1337u32;
|
||||
let ethereum_secret_key =
|
||||
libsecp256k1::SecretKey::parse(&keccak_256(&i.to_le_bytes())).unwrap();
|
||||
let ethereum_secret_key = libsecp256k1::SecretKey::parse(
|
||||
&keccak_256(&i.to_le_bytes())).unwrap();
|
||||
let eth_address = crate::secp_utils::eth(ðereum_secret_key);
|
||||
|
||||
let balance = CurrencyOf::<T, I>::minimum_balance();
|
||||
@ -22,30 +22,23 @@ mod benchmarks {
|
||||
Total::<T, I>::put(balance);
|
||||
|
||||
let pseudo_rank = 5u16;
|
||||
let _ = Club::<T, I>::do_add_member_to_rank(pseudo_account.clone(), pseudo_rank, false);
|
||||
let _ = Club::<T, I>::do_add_member_to_rank(
|
||||
pseudo_account.clone(),
|
||||
pseudo_rank,
|
||||
false,
|
||||
);
|
||||
|
||||
let user_account: T::AccountId = account("user", i, 0);
|
||||
let signature =
|
||||
crate::secp_utils::sig::<T, I>(ðereum_secret_key, &user_account.encode());
|
||||
|
||||
let signature = crate::secp_utils::sig::<T, I>(ðereum_secret_key, &user_account.encode());
|
||||
|
||||
let prev_balance = CurrencyOf::<T, I>::free_balance(&user_account);
|
||||
let prev_rank = Club::<T, I>::rank_of(&user_account);
|
||||
|
||||
#[extrinsic_call]
|
||||
claim(
|
||||
RawOrigin::Signed(user_account.clone()),
|
||||
eth_address,
|
||||
signature,
|
||||
);
|
||||
claim(RawOrigin::Signed(user_account.clone()), eth_address, signature);
|
||||
|
||||
assert_eq!(
|
||||
CurrencyOf::<T, I>::free_balance(&user_account),
|
||||
prev_balance + balance
|
||||
);
|
||||
assert_eq!(
|
||||
CurrencyOf::<T, I>::free_balance(&pseudo_account),
|
||||
balance - balance
|
||||
);
|
||||
assert_eq!(CurrencyOf::<T, I>::free_balance(&user_account), prev_balance + balance);
|
||||
assert_eq!(CurrencyOf::<T, I>::free_balance(&pseudo_account), balance - balance);
|
||||
|
||||
let rank = match prev_rank {
|
||||
Some(current_rank) if pseudo_rank <= current_rank => Some(current_rank),
|
||||
@ -55,5 +48,9 @@ mod benchmarks {
|
||||
assert_eq!(Club::<T, I>::rank_of(&pseudo_account), None);
|
||||
}
|
||||
|
||||
impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test,);
|
||||
impl_benchmark_test_suite!(
|
||||
Pallet,
|
||||
crate::mock::new_test_ext(),
|
||||
crate::mock::Test,
|
||||
);
|
||||
}
|
||||
|
||||
@ -1,20 +1,19 @@
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
use frame_support::{
|
||||
ensure,
|
||||
pallet_prelude::*,
|
||||
ensure, pallet_prelude::*,
|
||||
traits::{
|
||||
Currency, ExistenceRequirement, Get, RankedMembers, RankedMembersSwapHandler,
|
||||
VestingSchedule,
|
||||
Currency, ExistenceRequirement, Get, RankedMembers,
|
||||
RankedMembersSwapHandler, VestingSchedule,
|
||||
},
|
||||
DefaultNoBound,
|
||||
};
|
||||
use frame_system::pallet_prelude::*;
|
||||
pub use pallet::*;
|
||||
use serde::{self, Deserialize, Deserializer, Serialize, Serializer};
|
||||
pub use pallet::*;
|
||||
|
||||
use sp_io::{crypto::secp256k1_ecdsa_recover, hashing::keccak_256};
|
||||
use sp_runtime::traits::{BlockNumberProvider, CheckedDiv, CheckedSub};
|
||||
use sp_runtime::traits::{CheckedSub, CheckedDiv, BlockNumberProvider};
|
||||
use sp_std::prelude::*;
|
||||
|
||||
extern crate alloc;
|
||||
@ -24,10 +23,10 @@ use alloc::{format, string::String};
|
||||
mod weights;
|
||||
pub use crate::weights::WeightInfo;
|
||||
|
||||
mod benchmarking;
|
||||
mod mock;
|
||||
mod secp_utils;
|
||||
mod tests;
|
||||
mod mock;
|
||||
mod benchmarking;
|
||||
mod secp_utils;
|
||||
|
||||
/// An ethereum address (i.e. 20 bytes, used to represent an Ethereum account).
|
||||
///
|
||||
@ -57,7 +56,7 @@ impl<'de> Deserialize<'de> for EthereumAddress {
|
||||
Err(serde::de::Error::custom(
|
||||
"Bad length of Ethereum address (should be 42 including `0x`)",
|
||||
))?;
|
||||
}
|
||||
}
|
||||
let raw: Vec<u8> = rustc_hex::FromHex::from_hex(s)
|
||||
.map_err(|e| serde::de::Error::custom(format!("{:?}", e)))?;
|
||||
let mut r = Self::default();
|
||||
@ -82,14 +81,15 @@ impl sp_std::fmt::Debug for EcdsaSignature {
|
||||
}
|
||||
|
||||
type CurrencyOf<T, I> = <<T as Config<I>>::VestingSchedule as VestingSchedule<
|
||||
<T as frame_system::Config>::AccountId,
|
||||
<T as frame_system::Config>::AccountId
|
||||
>>::Currency;
|
||||
|
||||
type BalanceOf<T, I> =
|
||||
<CurrencyOf<T, I> as Currency<<T as frame_system::Config>::AccountId>>::Balance;
|
||||
type BalanceOf<T, I> = <CurrencyOf<T, I> as Currency<
|
||||
<T as frame_system::Config>::AccountId>
|
||||
>::Balance;
|
||||
|
||||
type RankOf<T, I> = <pallet_ranked_collective::Pallet<T, I> as RankedMembers>::Rank;
|
||||
type AccountIdOf<T, I> = <pallet_ranked_collective::Pallet<T, I> as RankedMembers>::AccountId;
|
||||
type RankOf<T, I> = <pallet_ranked_collective::Pallet::<T, I> as RankedMembers>::Rank;
|
||||
type AccountIdOf<T, I> = <pallet_ranked_collective::Pallet::<T, I> as RankedMembers>::AccountId;
|
||||
|
||||
#[frame_support::pallet]
|
||||
pub mod pallet {
|
||||
@ -100,11 +100,8 @@ pub mod pallet {
|
||||
pub struct Pallet<T, I = ()>(_);
|
||||
|
||||
#[pallet::config]
|
||||
pub trait Config<I: 'static = ()>:
|
||||
frame_system::Config + pallet_ranked_collective::Config<I>
|
||||
{
|
||||
type RuntimeEvent: From<Event<Self, I>>
|
||||
+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
pub trait Config<I: 'static = ()>: frame_system::Config + pallet_ranked_collective::Config<I> {
|
||||
type RuntimeEvent: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
|
||||
type VestingSchedule: VestingSchedule<Self::AccountId, Moment = BlockNumberFor<Self>>;
|
||||
type BlockNumberProvider: BlockNumberProvider<BlockNumber = BlockNumberFor<Self>>;
|
||||
@ -121,13 +118,13 @@ pub mod pallet {
|
||||
|
||||
type WeightInfo: WeightInfo;
|
||||
}
|
||||
|
||||
|
||||
#[pallet::event]
|
||||
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
||||
pub enum Event<T: Config<I>, I: 'static = ()> {
|
||||
Claimed {
|
||||
receiver: T::AccountId,
|
||||
donor: T::AccountId,
|
||||
receiver: T::AccountId,
|
||||
donor: T::AccountId,
|
||||
amount: BalanceOf<T, I>,
|
||||
rank: Option<RankOf<T, I>>,
|
||||
},
|
||||
@ -162,16 +159,12 @@ pub mod pallet {
|
||||
.map(|(account_id, rank)| {
|
||||
assert!(
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_add_member_to_rank(
|
||||
account_id.clone(),
|
||||
*rank,
|
||||
false
|
||||
)
|
||||
.is_ok(),
|
||||
"error during adding and promotion"
|
||||
account_id.clone(), *rank, false).is_ok(),
|
||||
"error during adding and promotion"
|
||||
);
|
||||
account_id
|
||||
})
|
||||
.collect();
|
||||
.collect();
|
||||
|
||||
assert!(
|
||||
self.members_and_ranks.len() == cult_accounts.len(),
|
||||
@ -193,13 +186,13 @@ pub mod pallet {
|
||||
) -> DispatchResult {
|
||||
let who = ensure_signed(origin)?;
|
||||
let data = who.using_encoded(to_ascii_hex);
|
||||
let recovered_address = Self::recover_ethereum_address(ðereum_signature, &data)
|
||||
.ok_or(Error::<T, I>::InvalidEthereumSignature)?;
|
||||
let recovered_address = Self::recover_ethereum_address(
|
||||
ðereum_signature,
|
||||
&data,
|
||||
).ok_or(Error::<T, I>::InvalidEthereumSignature)?;
|
||||
|
||||
ensure!(
|
||||
recovered_address == ethereum_address,
|
||||
Error::<T, I>::InvalidEthereumAddress
|
||||
);
|
||||
ensure!(recovered_address == ethereum_address,
|
||||
Error::<T, I>::InvalidEthereumAddress);
|
||||
|
||||
Self::do_claim(who, ethereum_address)
|
||||
}
|
||||
@ -207,37 +200,37 @@ pub mod pallet {
|
||||
}
|
||||
|
||||
fn to_ascii_hex(data: &[u8]) -> Vec<u8> {
|
||||
let mut r = Vec::with_capacity(data.len() * 2);
|
||||
let mut push_nibble = |n| r.push(if n < 10 { b'0' + n } else { b'a' - 10 + n });
|
||||
for &b in data.iter() {
|
||||
push_nibble(b / 16);
|
||||
push_nibble(b % 16);
|
||||
}
|
||||
r
|
||||
let mut r = Vec::with_capacity(data.len() * 2);
|
||||
let mut push_nibble = |n| r.push(if n < 10 { b'0' + n } else { b'a' - 10 + n });
|
||||
for &b in data.iter() {
|
||||
push_nibble(b / 16);
|
||||
push_nibble(b % 16);
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
impl<T: Config<I>, I: 'static> Pallet<T, I> {
|
||||
fn ethereum_signable_message(what: &[u8]) -> Vec<u8> {
|
||||
let prefix = T::Prefix::get();
|
||||
let mut l = prefix.len() + what.len();
|
||||
let mut rev = Vec::new();
|
||||
while l > 0 {
|
||||
rev.push(b'0' + (l % 10) as u8);
|
||||
l /= 10;
|
||||
}
|
||||
let mut v = b"\x19Ethereum Signed Message:\n".to_vec();
|
||||
v.extend(rev.into_iter().rev());
|
||||
v.extend_from_slice(prefix);
|
||||
v.extend_from_slice(what);
|
||||
v
|
||||
let mut l = prefix.len() + what.len();
|
||||
let mut rev = Vec::new();
|
||||
while l > 0 {
|
||||
rev.push(b'0' + (l % 10) as u8);
|
||||
l /= 10;
|
||||
}
|
||||
let mut v = b"\x19Ethereum Signed Message:\n".to_vec();
|
||||
v.extend(rev.into_iter().rev());
|
||||
v.extend_from_slice(prefix);
|
||||
v.extend_from_slice(what);
|
||||
v
|
||||
}
|
||||
|
||||
fn recover_ethereum_address(s: &EcdsaSignature, what: &[u8]) -> Option<EthereumAddress> {
|
||||
let msg = keccak_256(&Self::ethereum_signable_message(what));
|
||||
let mut res = EthereumAddress::default();
|
||||
res.0
|
||||
.copy_from_slice(&keccak_256(&secp256k1_ecdsa_recover(&s.0, &msg).ok()?[..])[12..]);
|
||||
Some(res)
|
||||
let mut res = EthereumAddress::default();
|
||||
res.0
|
||||
.copy_from_slice(&keccak_256(&secp256k1_ecdsa_recover(&s.0, &msg).ok()?[..])[12..]);
|
||||
Some(res)
|
||||
}
|
||||
|
||||
fn into_account_id(address: EthereumAddress) -> Result<T::AccountId, codec::Error> {
|
||||
@ -250,24 +243,21 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
|
||||
}
|
||||
|
||||
fn do_claim(receiver: T::AccountId, ethereum_address: EthereumAddress) -> DispatchResult {
|
||||
let donor = Self::into_account_id(ethereum_address)
|
||||
.ok()
|
||||
let donor = Self::into_account_id(ethereum_address).ok()
|
||||
.ok_or(Error::<T, I>::AddressDecodingFailed)?;
|
||||
|
||||
let balance_due = CurrencyOf::<T, I>::free_balance(&donor);
|
||||
ensure!(
|
||||
balance_due >= CurrencyOf::<T, I>::minimum_balance(),
|
||||
Error::<T, I>::NoBalanceToClaim
|
||||
);
|
||||
ensure!(balance_due >= CurrencyOf::<T, I>::minimum_balance(),
|
||||
Error::<T, I>::NoBalanceToClaim);
|
||||
|
||||
let new_total = Total::<T, I>::get()
|
||||
.checked_sub(&balance_due)
|
||||
.ok_or(Error::<T, I>::PotUnderflow)?;
|
||||
|
||||
CurrencyOf::<T, I>::transfer(
|
||||
&donor,
|
||||
&receiver,
|
||||
balance_due,
|
||||
&donor,
|
||||
&receiver,
|
||||
balance_due,
|
||||
ExistenceRequirement::AllowDeath,
|
||||
)?;
|
||||
|
||||
@ -283,40 +273,28 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
|
||||
.ok_or(Error::<T, I>::ArithmeticError)?;
|
||||
|
||||
T::VestingSchedule::add_vesting_schedule(
|
||||
&receiver,
|
||||
&receiver,
|
||||
vesting_balance,
|
||||
per_block_balance,
|
||||
T::BlockNumberProvider::current_block_number(),
|
||||
)?;
|
||||
}
|
||||
|
||||
let rank = if let Some(rank) =
|
||||
<pallet_ranked_collective::Pallet<T, I> as RankedMembers>::rank_of(&donor)
|
||||
{
|
||||
let rank = if let Some(rank) = <pallet_ranked_collective::Pallet::<T, I> as RankedMembers>::rank_of(&donor) {
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_remove_member_from_rank(&donor, rank)?;
|
||||
let new_rank =
|
||||
match <pallet_ranked_collective::Pallet<T, I> as RankedMembers>::rank_of(&receiver)
|
||||
{
|
||||
Some(current_rank) if current_rank >= rank => current_rank,
|
||||
Some(current_rank) if current_rank < rank => {
|
||||
for _ in 0..rank - current_rank {
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_promote_member(
|
||||
receiver.clone(),
|
||||
None,
|
||||
false,
|
||||
)?;
|
||||
}
|
||||
rank
|
||||
let new_rank = match <pallet_ranked_collective::Pallet::<T, I> as RankedMembers>::rank_of(&receiver) {
|
||||
Some(current_rank) if current_rank >= rank => current_rank,
|
||||
Some(current_rank) if current_rank < rank => {
|
||||
for _ in 0..rank - current_rank {
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_promote_member(receiver.clone(), None, false)?;
|
||||
}
|
||||
_ => {
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_add_member_to_rank(
|
||||
receiver.clone(),
|
||||
rank,
|
||||
false,
|
||||
)?;
|
||||
rank
|
||||
}
|
||||
};
|
||||
rank
|
||||
},
|
||||
_ => {
|
||||
pallet_ranked_collective::Pallet::<T, I>::do_add_member_to_rank(receiver.clone(), rank, false)?;
|
||||
rank
|
||||
},
|
||||
};
|
||||
<T as pallet::Config<I>>::MemberSwappedHandler::swapped(&donor, &receiver, new_rank);
|
||||
Some(new_rank)
|
||||
} else {
|
||||
@ -325,7 +303,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
|
||||
|
||||
Total::<T, I>::put(new_total);
|
||||
Self::deposit_event(Event::<T, I>::Claimed {
|
||||
receiver,
|
||||
receiver,
|
||||
donor,
|
||||
amount: balance_due,
|
||||
rank,
|
||||
|
||||
@ -4,113 +4,51 @@ use super::*;
|
||||
|
||||
pub use crate as ghost_claims;
|
||||
use frame_support::{
|
||||
derive_impl, parameter_types,
|
||||
traits::{ConstU16, ConstU64, PollStatus, Polling, WithdrawReasons},
|
||||
parameter_types, derive_impl,
|
||||
traits::{PollStatus, Polling, WithdrawReasons, ConstU16, ConstU64},
|
||||
};
|
||||
use frame_system::EnsureRootWithSuccess;
|
||||
pub use pallet_ranked_collective::{Rank, TallyOf};
|
||||
use sp_runtime::{traits::Convert, BuildStorage};
|
||||
use sp_runtime::{BuildStorage, traits::Convert};
|
||||
pub use pallet_ranked_collective::{TallyOf, Rank};
|
||||
|
||||
pub mod eth_keys {
|
||||
use crate::{mock::Test, EcdsaSignature, EthereumAddress};
|
||||
use codec::Encode;
|
||||
use crate::{
|
||||
mock::Test,
|
||||
EcdsaSignature, EthereumAddress,
|
||||
};
|
||||
use hex_literal::hex;
|
||||
use codec::Encode;
|
||||
|
||||
pub fn total_claims() -> u64 {
|
||||
10 + 100 + 1000
|
||||
}
|
||||
pub fn alice_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
69
|
||||
}
|
||||
pub fn bob_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
1337
|
||||
}
|
||||
pub fn total_claims() -> u64 { 10 + 100 + 1000 }
|
||||
pub fn alice_account_id() -> <Test as frame_system::Config>::AccountId { 69 }
|
||||
pub fn bob_account_id() -> <Test as frame_system::Config>::AccountId { 1337 }
|
||||
|
||||
pub fn first_eth_public_known() -> EthereumAddress {
|
||||
EthereumAddress(hex!("1A69d2D5568D1878023EeB121a73d33B9116A760"))
|
||||
}
|
||||
pub fn second_eth_public_known() -> EthereumAddress {
|
||||
EthereumAddress(hex!("2f86cfBED3fbc1eCf2989B9aE5fc019a837A9C12"))
|
||||
}
|
||||
pub fn third_eth_public_known() -> EthereumAddress {
|
||||
EthereumAddress(hex!("e83f67361Ac74D42A48E2DAfb6706eb047D8218D"))
|
||||
}
|
||||
pub fn fourth_eth_public_known() -> EthereumAddress {
|
||||
EthereumAddress(hex!("827ee4ad9b259b6fa1390ed60921508c78befd63"))
|
||||
}
|
||||
pub fn first_eth_public_known() -> EthereumAddress { EthereumAddress(hex!("1A69d2D5568D1878023EeB121a73d33B9116A760")) }
|
||||
pub fn second_eth_public_known() -> EthereumAddress { EthereumAddress(hex!("2f86cfBED3fbc1eCf2989B9aE5fc019a837A9C12")) }
|
||||
pub fn third_eth_public_known() -> EthereumAddress { EthereumAddress(hex!("e83f67361Ac74D42A48E2DAfb6706eb047D8218D")) }
|
||||
pub fn fourth_eth_public_known() -> EthereumAddress { EthereumAddress(hex!("827ee4ad9b259b6fa1390ed60921508c78befd63")) }
|
||||
|
||||
fn first_eth_private_key() -> libsecp256k1::SecretKey {
|
||||
libsecp256k1::SecretKey::parse(&hex!(
|
||||
"01c928771aea942a1e7ac06adf2b73dfbc9a25d9eaa516e3673116af7f345198"
|
||||
))
|
||||
.unwrap()
|
||||
}
|
||||
fn second_eth_private_key() -> libsecp256k1::SecretKey {
|
||||
libsecp256k1::SecretKey::parse(&hex!(
|
||||
"b19a435901872f817185f7234a1484eae837613f9d10cf21927a23c2d8cb9139"
|
||||
))
|
||||
.unwrap()
|
||||
}
|
||||
fn third_eth_private_key() -> libsecp256k1::SecretKey {
|
||||
libsecp256k1::SecretKey::parse(&hex!(
|
||||
"d3baf57b74d65719b2dc33f5a464176022d0cc5edbca002234229f3e733875fc"
|
||||
))
|
||||
.unwrap()
|
||||
}
|
||||
fn fourth_eth_private_key() -> libsecp256k1::SecretKey {
|
||||
libsecp256k1::SecretKey::parse(&hex!(
|
||||
"c4683d566436af6b58b4a59c8f501319226e85b21869bf93d5eeb4596d4791d4"
|
||||
))
|
||||
.unwrap()
|
||||
}
|
||||
fn wrong_eth_private_key() -> libsecp256k1::SecretKey {
|
||||
libsecp256k1::SecretKey::parse(&hex!(
|
||||
"deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
|
||||
))
|
||||
.unwrap()
|
||||
}
|
||||
fn first_eth_private_key() -> libsecp256k1::SecretKey { libsecp256k1::SecretKey::parse(&hex!("01c928771aea942a1e7ac06adf2b73dfbc9a25d9eaa516e3673116af7f345198")).unwrap() }
|
||||
fn second_eth_private_key() -> libsecp256k1::SecretKey { libsecp256k1::SecretKey::parse(&hex!("b19a435901872f817185f7234a1484eae837613f9d10cf21927a23c2d8cb9139")).unwrap() }
|
||||
fn third_eth_private_key() -> libsecp256k1::SecretKey { libsecp256k1::SecretKey::parse(&hex!("d3baf57b74d65719b2dc33f5a464176022d0cc5edbca002234229f3e733875fc")).unwrap() }
|
||||
fn fourth_eth_private_key() -> libsecp256k1::SecretKey { libsecp256k1::SecretKey::parse(&hex!("c4683d566436af6b58b4a59c8f501319226e85b21869bf93d5eeb4596d4791d4")).unwrap() }
|
||||
fn wrong_eth_private_key() -> libsecp256k1::SecretKey { libsecp256k1::SecretKey::parse(&hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")).unwrap() }
|
||||
|
||||
pub fn first_eth_public_key() -> EthereumAddress {
|
||||
crate::secp_utils::eth(&first_eth_private_key())
|
||||
}
|
||||
pub fn second_eth_public_key() -> EthereumAddress {
|
||||
crate::secp_utils::eth(&second_eth_private_key())
|
||||
}
|
||||
pub fn third_eth_public_key() -> EthereumAddress {
|
||||
crate::secp_utils::eth(&third_eth_private_key())
|
||||
}
|
||||
pub fn fourth_eth_public_key() -> EthereumAddress {
|
||||
crate::secp_utils::eth(&fourth_eth_private_key())
|
||||
}
|
||||
pub fn first_eth_public_key() -> EthereumAddress { crate::secp_utils::eth(&first_eth_private_key()) }
|
||||
pub fn second_eth_public_key() -> EthereumAddress { crate::secp_utils::eth(&second_eth_private_key()) }
|
||||
pub fn third_eth_public_key() -> EthereumAddress { crate::secp_utils::eth(&third_eth_private_key()) }
|
||||
pub fn fourth_eth_public_key() -> EthereumAddress { crate::secp_utils::eth(&fourth_eth_private_key()) }
|
||||
|
||||
pub fn first_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
crate::secp_utils::into_account_id::<Test, ()>(first_eth_public_key())
|
||||
}
|
||||
pub fn second_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
crate::secp_utils::into_account_id::<Test, ()>(second_eth_public_key())
|
||||
}
|
||||
pub fn third_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
crate::secp_utils::into_account_id::<Test, ()>(third_eth_public_key())
|
||||
}
|
||||
pub fn fourth_account_id() -> <Test as frame_system::Config>::AccountId {
|
||||
crate::secp_utils::into_account_id::<Test, ()>(fourth_eth_public_key())
|
||||
}
|
||||
pub fn first_account_id() -> <Test as frame_system::Config>::AccountId { crate::secp_utils::into_account_id::<Test, ()>(first_eth_public_key()) }
|
||||
pub fn second_account_id() -> <Test as frame_system::Config>::AccountId { crate::secp_utils::into_account_id::<Test, ()>(second_eth_public_key()) }
|
||||
pub fn third_account_id() -> <Test as frame_system::Config>::AccountId { crate::secp_utils::into_account_id::<Test, ()>(third_eth_public_key()) }
|
||||
pub fn fourth_account_id() -> <Test as frame_system::Config>::AccountId { crate::secp_utils::into_account_id::<Test, ()>(fourth_eth_public_key()) }
|
||||
|
||||
pub fn first_signature() -> EcdsaSignature {
|
||||
crate::secp_utils::sig::<Test, ()>(&first_eth_private_key(), &alice_account_id().encode())
|
||||
}
|
||||
pub fn second_signature() -> EcdsaSignature {
|
||||
crate::secp_utils::sig::<Test, ()>(&second_eth_private_key(), &alice_account_id().encode())
|
||||
}
|
||||
pub fn third_signature() -> EcdsaSignature {
|
||||
crate::secp_utils::sig::<Test, ()>(&third_eth_private_key(), &alice_account_id().encode())
|
||||
}
|
||||
pub fn fourth_signature() -> EcdsaSignature {
|
||||
crate::secp_utils::sig::<Test, ()>(&fourth_eth_private_key(), &bob_account_id().encode())
|
||||
}
|
||||
pub fn wrong_signature() -> EcdsaSignature {
|
||||
crate::secp_utils::sig::<Test, ()>(&wrong_eth_private_key(), &alice_account_id().encode())
|
||||
}
|
||||
pub fn first_signature() -> EcdsaSignature { crate::secp_utils::sig::<Test, ()>(&first_eth_private_key(), &alice_account_id().encode()) }
|
||||
pub fn second_signature() -> EcdsaSignature { crate::secp_utils::sig::<Test, ()>(&second_eth_private_key(), &alice_account_id().encode()) }
|
||||
pub fn third_signature() -> EcdsaSignature { crate::secp_utils::sig::<Test, ()>(&third_eth_private_key(), &alice_account_id().encode()) }
|
||||
pub fn fourth_signature() -> EcdsaSignature { crate::secp_utils::sig::<Test, ()>(&fourth_eth_private_key(), &bob_account_id().encode()) }
|
||||
pub fn wrong_signature() -> EcdsaSignature { crate::secp_utils::sig::<Test, ()>(&wrong_eth_private_key(), &alice_account_id().encode()) }
|
||||
}
|
||||
|
||||
#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
|
||||
@ -128,9 +66,10 @@ impl pallet_balances::Config for Test {
|
||||
type AccountStore = System;
|
||||
}
|
||||
|
||||
|
||||
parameter_types! {
|
||||
pub const MinVestedTransfer: u64 = 1;
|
||||
pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
|
||||
pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
|
||||
WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
|
||||
}
|
||||
|
||||
@ -140,8 +79,9 @@ impl pallet_vesting::Config for Test {
|
||||
type BlockNumberToBalance = sp_runtime::traits::ConvertInto;
|
||||
type MinVestedTransfer = MinVestedTransfer;
|
||||
type WeightInfo = ();
|
||||
type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
|
||||
|
||||
type UnvestedFundsAllowedWithdrawReasons =
|
||||
UnvestedFundsAllowedWithdrawReasons;
|
||||
|
||||
type BlockNumberProvider = System;
|
||||
const MAX_VESTING_SCHEDULES: u32 = 28;
|
||||
}
|
||||
@ -208,7 +148,7 @@ impl pallet_ranked_collective::Config for Test {
|
||||
type PromoteOrigin = EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>;
|
||||
type DemoteOrigin = EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>;
|
||||
type ExchangeOrigin = EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>;
|
||||
|
||||
|
||||
type Polls = TestPolls;
|
||||
type MemberSwappedHandler = ();
|
||||
type MinRankOfClass = MinRankOfClass<MinRankOfClassDelta>;
|
||||
@ -260,8 +200,8 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
|
||||
(crate::mock::eth_keys::third_account_id(), 1000),
|
||||
],
|
||||
}
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
|
||||
ghost_claims::GenesisConfig::<Test> {
|
||||
total: crate::mock::eth_keys::total_claims(),
|
||||
@ -270,8 +210,8 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
|
||||
(crate::mock::eth_keys::third_account_id(), 3),
|
||||
],
|
||||
}
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
|
||||
let mut ext = sp_io::TestExternalities::new(t);
|
||||
ext.execute_with(|| {
|
||||
|
||||
@ -8,8 +8,7 @@ pub fn public(secret: &libsecp256k1::SecretKey) -> libsecp256k1::PublicKey {
|
||||
|
||||
pub fn eth(secret: &libsecp256k1::SecretKey) -> EthereumAddress {
|
||||
let mut res = EthereumAddress::default();
|
||||
res.0
|
||||
.copy_from_slice(&keccak_256(&public(secret).serialize()[1..65])[12..]);
|
||||
res.0.copy_from_slice(&keccak_256(&public(secret).serialize()[1..65])[12..]);
|
||||
res
|
||||
}
|
||||
|
||||
@ -19,14 +18,17 @@ pub fn into_account_id<T: Config<I>, I: 'static>(address: EthereumAddress) -> T:
|
||||
}
|
||||
|
||||
pub fn sig<T: Config<I>, I: 'static>(
|
||||
secret: &libsecp256k1::SecretKey,
|
||||
secret: &libsecp256k1::SecretKey,
|
||||
what: &[u8],
|
||||
) -> EcdsaSignature {
|
||||
let msg = keccak_256(&super::Pallet::<T, I>::ethereum_signable_message(
|
||||
&crate::to_ascii_hex(what)[..],
|
||||
&crate::to_ascii_hex(what)[..],
|
||||
));
|
||||
|
||||
let (sig, recovery_id) = libsecp256k1::sign(&libsecp256k1::Message::parse(&msg), secret);
|
||||
let (sig, recovery_id) = libsecp256k1::sign(
|
||||
&libsecp256k1::Message::parse(&msg),
|
||||
secret,
|
||||
);
|
||||
|
||||
let mut r = [0u8; 65];
|
||||
r[0..64].copy_from_slice(&sig.serialize()[..]);
|
||||
|
||||
@ -1,19 +1,21 @@
|
||||
#![cfg(test)]
|
||||
|
||||
use super::*;
|
||||
use frame_support::{assert_err, assert_ok};
|
||||
use hex_literal::hex;
|
||||
use mock::{
|
||||
new_test_ext, ghost_claims,
|
||||
Test, System, Balances, Club, Vesting, Claims, RuntimeOrigin, RuntimeEvent,
|
||||
eth_keys::{
|
||||
alice_account_id, bob_account_id, first_account_id, first_eth_public_key,
|
||||
first_eth_public_known, first_signature, fourth_account_id, fourth_eth_public_key,
|
||||
fourth_eth_public_known, fourth_signature, second_account_id, second_eth_public_key,
|
||||
second_eth_public_known, second_signature, third_account_id, third_eth_public_key,
|
||||
third_eth_public_known, third_signature, total_claims, wrong_signature,
|
||||
},
|
||||
ghost_claims, new_test_ext, Balances, Claims, Club, RuntimeEvent, RuntimeOrigin, System, Test,
|
||||
Vesting,
|
||||
alice_account_id, total_claims, first_eth_public_known,
|
||||
first_eth_public_key, first_account_id, first_signature,
|
||||
second_eth_public_known, second_eth_public_key, second_account_id,
|
||||
second_signature, third_eth_public_known, third_eth_public_key,
|
||||
third_account_id, third_signature, fourth_eth_public_known,
|
||||
fourth_eth_public_key, fourth_account_id, fourth_signature,
|
||||
wrong_signature, bob_account_id,
|
||||
}
|
||||
};
|
||||
use hex_literal::hex;
|
||||
use frame_support::{assert_err, assert_ok};
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn serde_works() {
|
||||
@ -39,12 +41,12 @@ fn basic_setup_works() {
|
||||
assert_eq!(Balances::usable_balance(&first_account_id()), 10);
|
||||
assert_eq!(Balances::usable_balance(&second_account_id()), 100);
|
||||
assert_eq!(Balances::usable_balance(&third_account_id()), 1000);
|
||||
|
||||
|
||||
assert_eq!(Club::rank_of(&alice_account_id()), None);
|
||||
assert_eq!(Club::rank_of(&first_account_id()), None);
|
||||
assert_eq!(Club::rank_of(&second_account_id()), Some(1));
|
||||
assert_eq!(Club::rank_of(&third_account_id()), Some(3));
|
||||
|
||||
|
||||
assert_eq!(Vesting::vesting_balance(&alice_account_id()), None);
|
||||
assert_eq!(ghost_claims::Total::<Test, ()>::get(), total_claims());
|
||||
});
|
||||
@ -54,10 +56,9 @@ fn basic_setup_works() {
|
||||
fn small_claiming_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature()
|
||||
));
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature()));
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 10);
|
||||
assert_eq!(Balances::usable_balance(&first_account_id()), 0);
|
||||
@ -76,9 +77,9 @@ fn small_claiming_works() {
|
||||
fn medium_claiming_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
));
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 100);
|
||||
@ -98,9 +99,9 @@ fn medium_claiming_works() {
|
||||
fn big_claiming_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
));
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 200);
|
||||
@ -112,15 +113,11 @@ fn big_claiming_works() {
|
||||
assert_eq!(Club::rank_of(&third_account_id()), None);
|
||||
|
||||
assert_eq!(Vesting::vesting_balance(&alice_account_id()), Some(800));
|
||||
assert_eq!(
|
||||
ghost_claims::Total::<Test, ()>::get(),
|
||||
total_claims() - 1000
|
||||
);
|
||||
assert_eq!(ghost_claims::Total::<Test, ()>::get(), total_claims() - 1000);
|
||||
assert_ok!(Balances::transfer_allow_death(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
bob_account_id(),
|
||||
200
|
||||
));
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
bob_account_id(),
|
||||
200));
|
||||
})
|
||||
}
|
||||
|
||||
@ -128,19 +125,19 @@ fn big_claiming_works() {
|
||||
fn multiple_accounts_claiming_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature(),
|
||||
));
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
));
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
));
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 310);
|
||||
@ -160,19 +157,19 @@ fn multiple_accounts_claiming_works() {
|
||||
fn multiple_accounts_reverese_claiming_works() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
));
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
second_eth_public_key(),
|
||||
second_signature(),
|
||||
));
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature(),
|
||||
));
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 310);
|
||||
@ -191,14 +188,11 @@ fn multiple_accounts_reverese_claiming_works() {
|
||||
#[test]
|
||||
fn cannot_claim_with_bad_signature() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_err!(
|
||||
Claims::claim(
|
||||
assert_err!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
first_eth_public_key(),
|
||||
wrong_signature()
|
||||
),
|
||||
crate::Error::<Test>::InvalidEthereumAddress
|
||||
);
|
||||
wrong_signature()),
|
||||
crate::Error::<Test>::InvalidEthereumAddress);
|
||||
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 0);
|
||||
assert_eq!(Balances::usable_balance(&first_account_id()), 10);
|
||||
@ -218,14 +212,11 @@ fn cannot_claim_with_bad_signature() {
|
||||
#[test]
|
||||
fn cannot_claim_with_wrong_address() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_err!(
|
||||
Claims::claim(
|
||||
assert_err!(Claims::claim(
|
||||
RuntimeOrigin::signed(bob_account_id()),
|
||||
first_eth_public_key(),
|
||||
first_signature()
|
||||
),
|
||||
crate::Error::<Test>::InvalidEthereumAddress
|
||||
);
|
||||
first_signature()),
|
||||
crate::Error::<Test>::InvalidEthereumAddress);
|
||||
|
||||
assert_eq!(Balances::usable_balance(&bob_account_id()), 0);
|
||||
assert_eq!(Balances::usable_balance(&alice_account_id()), 0);
|
||||
@ -246,14 +237,11 @@ fn cannot_claim_with_wrong_address() {
|
||||
#[test]
|
||||
fn cannot_claim_nothing() {
|
||||
new_test_ext().execute_with(|| {
|
||||
assert_err!(
|
||||
Claims::claim(
|
||||
assert_err!(Claims::claim(
|
||||
RuntimeOrigin::signed(bob_account_id()),
|
||||
fourth_eth_public_key(),
|
||||
fourth_signature()
|
||||
),
|
||||
crate::Error::<Test>::NoBalanceToClaim
|
||||
);
|
||||
fourth_signature()),
|
||||
crate::Error::<Test>::NoBalanceToClaim);
|
||||
assert_eq!(Balances::usable_balance(&bob_account_id()), 0);
|
||||
assert_eq!(Balances::usable_balance(&fourth_account_id()), 0);
|
||||
assert_eq!(Vesting::vesting_balance(&bob_account_id()), None);
|
||||
@ -271,15 +259,16 @@ fn event_emitted_during_claim() {
|
||||
System::reset_events();
|
||||
assert_eq!(System::event_count(), 0);
|
||||
assert_ok!(Claims::claim(
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
RuntimeOrigin::signed(alice_account_id()),
|
||||
third_eth_public_key(),
|
||||
third_signature(),
|
||||
));
|
||||
System::assert_has_event(RuntimeEvent::Claims(crate::Event::Claimed {
|
||||
receiver: alice_account_id(),
|
||||
donor: account,
|
||||
amount,
|
||||
rank,
|
||||
}));
|
||||
System::assert_has_event(RuntimeEvent::Claims(
|
||||
crate::Event::Claimed {
|
||||
receiver: alice_account_id(),
|
||||
donor: account,
|
||||
amount,
|
||||
rank,
|
||||
}));
|
||||
})
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "ghost-networks"
|
||||
version = "0.1.12"
|
||||
version = "0.1.10"
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
edition.workspace = true
|
||||
|
||||
@ -8,38 +8,26 @@ use sp_runtime::Saturating;
|
||||
|
||||
const MAX_NAME_LEN: u32 = 20;
|
||||
const MAX_ENDPOINT_LEN: u32 = 150;
|
||||
const MAX_ENDPOINT_NUMBER: u32 = 20;
|
||||
|
||||
fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
|
||||
frame_system::Pallet::<T>::assert_last_event(generic_event.into());
|
||||
}
|
||||
|
||||
fn prepare_network<T: Config>(
|
||||
n: u32,
|
||||
m: u32,
|
||||
k: u32,
|
||||
n: u32, m: u32,
|
||||
) -> (<T as module::Config>::NetworkId, NetworkData) {
|
||||
let chain_id: <T as module::Config>::NetworkId = Default::default();
|
||||
let chain_id = chain_id.saturating_add((n + m).into());
|
||||
|
||||
let mut gatekeeper = b"0x".to_vec();
|
||||
for i in 0..40 {
|
||||
gatekeeper.push(i);
|
||||
}
|
||||
for i in 0..40 { gatekeeper.push(i); }
|
||||
|
||||
let mut topic_name = b"0x".to_vec();
|
||||
for i in 0..64 {
|
||||
topic_name.push(i);
|
||||
}
|
||||
|
||||
let mut default_endpoints = sp_std::vec![];
|
||||
for _ in 0..(k as usize) {
|
||||
default_endpoints.push(sp_std::vec![0x69; m as usize]);
|
||||
}
|
||||
for i in 0..64 { topic_name.push(i); }
|
||||
|
||||
let network = NetworkData {
|
||||
chain_name: sp_std::vec![0x69; n as usize],
|
||||
default_endpoints,
|
||||
default_endpoint: sp_std::vec![0x69; m as usize],
|
||||
gatekeeper,
|
||||
topic_name,
|
||||
network_type: NetworkType::Evm,
|
||||
@ -63,11 +51,8 @@ fn create_network<T: Config>(
|
||||
let authority = T::RegisterOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
GhostNetworks::<T>::register_network(
|
||||
authority.clone(),
|
||||
chain_id.clone(),
|
||||
network.clone(),
|
||||
)
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
authority.clone(), chain_id.clone(), network.clone()
|
||||
).map_err(|_| BenchmarkError::Weightless)?;
|
||||
network
|
||||
}
|
||||
};
|
||||
@ -79,9 +64,8 @@ benchmarks! {
|
||||
register_network {
|
||||
let i in 1 .. MAX_NAME_LEN;
|
||||
let j in 1 .. MAX_ENDPOINT_LEN;
|
||||
let k in 1 .. MAX_ENDPOINT_NUMBER;
|
||||
|
||||
let (chain_id, network) = prepare_network::<T>(i, j, k);
|
||||
let (chain_id, network) = prepare_network::<T>(i, j);
|
||||
let authority = T::RegisterOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = GhostNetworks::<T>::networks(chain_id.clone());
|
||||
@ -96,7 +80,7 @@ benchmarks! {
|
||||
update_network_name {
|
||||
let n in 1 .. MAX_NAME_LEN;
|
||||
let name = sp_std::vec![0x42; n as usize];
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -110,25 +94,22 @@ benchmarks! {
|
||||
|
||||
update_network_endpoint {
|
||||
let n in 1 .. MAX_ENDPOINT_LEN;
|
||||
let index_to_update = 0u32;
|
||||
let endpoint = sp_std::vec![0x42; n as usize];
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
}: _<T::RuntimeOrigin>(authority, chain_id.clone(), Some(index_to_update), Some(endpoint.clone()))
|
||||
}: _<T::RuntimeOrigin>(authority, chain_id.clone(), endpoint.clone())
|
||||
verify {
|
||||
assert_last_event::<T>(Event::NetworkEndpointUpdated {
|
||||
chain_id: chain_id.clone(),
|
||||
index: index_to_update,
|
||||
endpoint,
|
||||
chain_id: chain_id.clone(), default_endpoint: endpoint,
|
||||
}.into());
|
||||
assert_ne!(GhostNetworks::<T>::networks(chain_id.clone()), prev_network);
|
||||
}
|
||||
|
||||
update_network_finality_delay {
|
||||
let delay = 1337;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -142,7 +123,7 @@ benchmarks! {
|
||||
|
||||
update_network_rate_limit_delay {
|
||||
let rate_limit = 1337;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -156,7 +137,7 @@ benchmarks! {
|
||||
|
||||
update_network_block_distance {
|
||||
let block_distance = 1337;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -170,7 +151,7 @@ benchmarks! {
|
||||
|
||||
update_network_type {
|
||||
let network_type = NetworkType::Utxo;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -185,7 +166,7 @@ benchmarks! {
|
||||
update_network_gatekeeper {
|
||||
let mut gatekeeper = b"0x".to_vec();
|
||||
for i in 0..40 { gatekeeper.push(i + 1); }
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -199,7 +180,7 @@ benchmarks! {
|
||||
|
||||
update_network_topic_name {
|
||||
let topic_name = b"0x9876543219876543219876543219876543219876543219876543219876543219".to_vec();
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -213,7 +194,7 @@ benchmarks! {
|
||||
|
||||
update_incoming_network_fee {
|
||||
let incoming_fee = 1337;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -227,7 +208,7 @@ benchmarks! {
|
||||
|
||||
update_outgoing_network_fee {
|
||||
let outgoing_fee = 1337;
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::UpdateOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
@ -240,7 +221,7 @@ benchmarks! {
|
||||
}
|
||||
|
||||
remove_network {
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1, 1);
|
||||
let (chain_id, network) = prepare_network::<T>(1, 1);
|
||||
let authority = T::RemoveOrigin::try_successful_origin()
|
||||
.map_err(|_| BenchmarkError::Weightless)?;
|
||||
let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
|
||||
|
||||
@ -4,27 +4,27 @@
|
||||
|
||||
use frame_support::{
|
||||
pallet_prelude::*,
|
||||
storage::PrefixIterator,
|
||||
traits::{tokens::fungible::Inspect, EnsureOrigin},
|
||||
storage::PrefixIterator, traits::{tokens::fungible::Inspect, EnsureOrigin},
|
||||
};
|
||||
use frame_system::pallet_prelude::*;
|
||||
use scale_info::TypeInfo;
|
||||
|
||||
use sp_runtime::{
|
||||
traits::{CheckedSub, CheckedAdd, AtLeast32BitUnsigned, Member},
|
||||
curve::PiecewiseLinear,
|
||||
traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, Member},
|
||||
DispatchResult,
|
||||
};
|
||||
use sp_std::{convert::TryInto, prelude::*};
|
||||
use sp_std::{prelude::*, convert::TryInto};
|
||||
|
||||
pub use ghost_traits::networks::{
|
||||
NetworkDataBasicHandler, NetworkDataInspectHandler, NetworkDataMutateHandler,
|
||||
NetworkDataBasicHandler, NetworkDataInspectHandler,
|
||||
NetworkDataMutateHandler,
|
||||
};
|
||||
|
||||
mod weights;
|
||||
|
||||
pub use crate::weights::WeightInfo;
|
||||
pub use module::*;
|
||||
pub use crate::weights::WeightInfo;
|
||||
|
||||
#[cfg(any(feature = "runtime-benchmarks", test))]
|
||||
mod benchmarking;
|
||||
@ -33,8 +33,9 @@ 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;
|
||||
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 {
|
||||
@ -44,15 +45,13 @@ pub enum NetworkType {
|
||||
}
|
||||
|
||||
impl Default for NetworkType {
|
||||
fn default() -> Self {
|
||||
NetworkType::Evm
|
||||
}
|
||||
fn default() -> Self { NetworkType::Evm }
|
||||
}
|
||||
|
||||
#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
|
||||
pub struct NetworkData {
|
||||
pub chain_name: Vec<u8>,
|
||||
pub default_endpoints: Vec<Vec<u8>>,
|
||||
pub default_endpoint: Vec<u8>,
|
||||
pub gatekeeper: Vec<u8>,
|
||||
pub topic_name: Vec<u8>,
|
||||
pub network_type: NetworkType,
|
||||
@ -70,8 +69,7 @@ pub struct BridgeAdjustment<Balance> {
|
||||
}
|
||||
|
||||
pub struct BridgedInflationCurve<RewardCurve, T>(core::marker::PhantomData<(RewardCurve, T)>);
|
||||
impl<Balance, RewardCurve, T> pallet_staking::EraPayout<Balance>
|
||||
for BridgedInflationCurve<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>>,
|
||||
@ -101,11 +99,10 @@ where
|
||||
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()),
|
||||
}
|
||||
.and_then(|product| product.checked_div(&adjusted_issuance)) {
|
||||
Some(payout) => (payout, accumulated_balance.saturating_sub(payout)),
|
||||
None => (Balance::default(), Balance::default()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -131,7 +128,7 @@ pub mod module {
|
||||
+ TypeInfo
|
||||
+ MaybeSerializeDeserialize
|
||||
+ MaxEncodedLen;
|
||||
|
||||
|
||||
/// The origin required to register new network.
|
||||
type RegisterOrigin: EnsureOrigin<Self::RuntimeOrigin>;
|
||||
/// The origin required to update network information.
|
||||
@ -158,62 +155,18 @@ pub mod module {
|
||||
#[pallet::event]
|
||||
#[pallet::generate_deposit(pub(crate) fn deposit_event)]
|
||||
pub enum Event<T: Config> {
|
||||
NetworkRegistered {
|
||||
chain_id: T::NetworkId,
|
||||
network: NetworkData,
|
||||
},
|
||||
NetworkNameUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
chain_name: Vec<u8>,
|
||||
},
|
||||
NetworkEndpointUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
index: u32,
|
||||
endpoint: Vec<u8>,
|
||||
},
|
||||
NetworkEndpointRemoved {
|
||||
chain_id: T::NetworkId,
|
||||
index: u32,
|
||||
},
|
||||
NetworkEndpointAdded {
|
||||
chain_id: T::NetworkId,
|
||||
endpoint: Vec<u8>,
|
||||
},
|
||||
NetworkFinalityDelayUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
finality_delay: u64,
|
||||
},
|
||||
NetworkRateLimitDelayUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
rate_limit_delay: u64,
|
||||
},
|
||||
NetworkBlockDistanceUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
block_distance: u64,
|
||||
},
|
||||
NetworkTypeUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
network_type: NetworkType,
|
||||
},
|
||||
NetworkGatekeeperUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
gatekeeper: Vec<u8>,
|
||||
},
|
||||
NetworkTopicNameUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
topic_name: Vec<u8>,
|
||||
},
|
||||
NetworkIncomingFeeUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
incoming_fee: u32,
|
||||
},
|
||||
NetworkOutgoingFeeUpdated {
|
||||
chain_id: T::NetworkId,
|
||||
outgoing_fee: u32,
|
||||
},
|
||||
NetworkRemoved {
|
||||
chain_id: T::NetworkId,
|
||||
},
|
||||
NetworkRegistered { chain_id: T::NetworkId, network: NetworkData },
|
||||
NetworkNameUpdated { chain_id: T::NetworkId, chain_name: Vec<u8> },
|
||||
NetworkEndpointUpdated { chain_id: T::NetworkId, default_endpoint: Vec<u8> },
|
||||
NetworkFinalityDelayUpdated { chain_id: T::NetworkId, finality_delay: u64 },
|
||||
NetworkRateLimitDelayUpdated { chain_id: T::NetworkId, rate_limit_delay: u64 },
|
||||
NetworkBlockDistanceUpdated { chain_id: T::NetworkId, block_distance: u64 },
|
||||
NetworkTypeUpdated { chain_id: T::NetworkId, network_type: NetworkType },
|
||||
NetworkGatekeeperUpdated { chain_id: T::NetworkId, gatekeeper: Vec<u8> },
|
||||
NetworkTopicNameUpdated { chain_id: T::NetworkId, topic_name: Vec<u8> },
|
||||
NetworkIncomingFeeUpdated { chain_id: T::NetworkId, incoming_fee: u32 },
|
||||
NetworkOutgoingFeeUpdated { chain_id: T::NetworkId, outgoing_fee: u32 },
|
||||
NetworkRemoved { chain_id: T::NetworkId },
|
||||
}
|
||||
|
||||
#[pallet::storage]
|
||||
@ -227,7 +180,8 @@ pub mod module {
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn accumulated_commission)]
|
||||
pub type AccumulatedCommission<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
|
||||
pub type AccumulatedCommission<T: Config> =
|
||||
StorageValue<_, BalanceOf<T>, ValueQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn networks)]
|
||||
@ -236,8 +190,13 @@ pub mod module {
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn gatekeeper_amount)]
|
||||
pub type GatekeeperAmount<T: Config> =
|
||||
StorageMap<_, Twox64Concat, T::NetworkId, BalanceOf<T>, ValueQuery>;
|
||||
pub type GatekeeperAmount<T: Config> = StorageMap<
|
||||
_,
|
||||
Twox64Concat,
|
||||
T::NetworkId,
|
||||
BalanceOf<T>,
|
||||
ValueQuery,
|
||||
>;
|
||||
|
||||
#[pallet::genesis_config]
|
||||
pub struct GenesisConfig<T: Config> {
|
||||
@ -246,7 +205,7 @@ pub mod module {
|
||||
|
||||
impl<T: Config> Default for GenesisConfig<T> {
|
||||
fn default() -> Self {
|
||||
Self { networks: vec![] }
|
||||
Self { networks: vec![] }
|
||||
}
|
||||
}
|
||||
|
||||
@ -254,13 +213,12 @@ pub mod module {
|
||||
impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
|
||||
fn build(&self) {
|
||||
if !self.networks.is_empty() {
|
||||
self.networks
|
||||
.iter()
|
||||
.for_each(|(chain_id, network_metadata)| {
|
||||
let network = NetworkData::decode(&mut &network_metadata[..])
|
||||
.expect("Error decoding NetworkData");
|
||||
Pallet::<T>::do_register_network(chain_id.clone(), network)
|
||||
.expect("Error registering network");
|
||||
self.networks.iter().for_each(|(chain_id, network_metadata)| {
|
||||
let network =
|
||||
NetworkData::decode(&mut &network_metadata[..])
|
||||
.expect("Error decoding NetworkData");
|
||||
Pallet::<T>::do_register_network(chain_id.clone(), network)
|
||||
.expect("Error registering network");
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -289,10 +247,7 @@ pub mod module {
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight(T::WeightInfo::register_network(
|
||||
network.chain_name.len() as u32,
|
||||
network.default_endpoints
|
||||
.iter()
|
||||
.map(|endpoint| endpoint.len())
|
||||
.sum::<usize>() as u32,
|
||||
network.default_endpoint.len() as u32,
|
||||
))]
|
||||
pub fn register_network(
|
||||
origin: OriginFor<T>,
|
||||
@ -313,24 +268,26 @@ pub mod module {
|
||||
chain_name: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_name(chain_id, chain_name)
|
||||
Self::do_update_network_name(
|
||||
chain_id,
|
||||
chain_name,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(2)]
|
||||
#[pallet::weight(T::WeightInfo::update_network_endpoint(
|
||||
maybe_endpoint
|
||||
.as_ref()
|
||||
.map(|endpoint| endpoint.len())
|
||||
.unwrap_or_default() as u32
|
||||
default_endpoint.len() as u32
|
||||
))]
|
||||
pub fn update_network_endpoint(
|
||||
origin: OriginFor<T>,
|
||||
chain_id: T::NetworkId,
|
||||
maybe_index: Option<u32>,
|
||||
maybe_endpoint: Option<Vec<u8>>,
|
||||
default_endpoint: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_endpoint(chain_id, maybe_index, maybe_endpoint)
|
||||
Self::do_update_network_endpoint(
|
||||
chain_id,
|
||||
default_endpoint,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(3)]
|
||||
@ -341,7 +298,10 @@ pub mod module {
|
||||
finality_delay: u64,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_finality_delay(chain_id, finality_delay)
|
||||
Self::do_update_network_finality_delay(
|
||||
chain_id,
|
||||
finality_delay,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(4)]
|
||||
@ -352,7 +312,10 @@ pub mod module {
|
||||
rate_limit_delay: u64,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_rate_limit_delay(chain_id, rate_limit_delay)
|
||||
Self::do_update_network_rate_limit_delay(
|
||||
chain_id,
|
||||
rate_limit_delay,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(5)]
|
||||
@ -363,7 +326,10 @@ pub mod module {
|
||||
block_distance: u64,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_block_distance(chain_id, block_distance)
|
||||
Self::do_update_network_block_distance(
|
||||
chain_id,
|
||||
block_distance,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(6)]
|
||||
@ -374,7 +340,10 @@ pub mod module {
|
||||
network_type: NetworkType,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_type(chain_id, network_type)
|
||||
Self::do_update_network_type(
|
||||
chain_id,
|
||||
network_type,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(7)]
|
||||
@ -385,7 +354,10 @@ pub mod module {
|
||||
gatekeeper: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_gatekeeper(chain_id, gatekeeper)
|
||||
Self::do_update_network_gatekeeper(
|
||||
chain_id,
|
||||
gatekeeper,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(8)]
|
||||
@ -396,7 +368,10 @@ pub mod module {
|
||||
topic_name: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_network_topic_name(chain_id, topic_name)
|
||||
Self::do_update_network_topic_name(
|
||||
chain_id,
|
||||
topic_name,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(9)]
|
||||
@ -407,7 +382,10 @@ pub mod module {
|
||||
incoming_fee: u32,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_incoming_network_fee(chain_id, incoming_fee)
|
||||
Self::do_update_incoming_network_fee(
|
||||
chain_id,
|
||||
incoming_fee,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(10)]
|
||||
@ -418,12 +396,18 @@ pub mod module {
|
||||
outgoing_fee: u32,
|
||||
) -> DispatchResult {
|
||||
T::UpdateOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_update_outgoing_network_fee(chain_id, outgoing_fee)
|
||||
Self::do_update_outgoing_network_fee(
|
||||
chain_id,
|
||||
outgoing_fee,
|
||||
)
|
||||
}
|
||||
|
||||
#[pallet::call_index(11)]
|
||||
#[pallet::weight(T::WeightInfo::remove_network())]
|
||||
pub fn remove_network(origin: OriginFor<T>, chain_id: T::NetworkId) -> DispatchResult {
|
||||
pub fn remove_network(
|
||||
origin: OriginFor<T>,
|
||||
chain_id: T::NetworkId,
|
||||
) -> DispatchResult {
|
||||
T::RemoveOrigin::ensure_origin_or_root(origin)?;
|
||||
Self::do_remove_network(chain_id)
|
||||
}
|
||||
@ -432,12 +416,12 @@ pub mod module {
|
||||
|
||||
impl<T: Config> Pallet<T> {
|
||||
/// Register a new network.
|
||||
pub fn do_register_network(chain_id: T::NetworkId, network: NetworkData) -> DispatchResult {
|
||||
pub fn do_register_network(
|
||||
chain_id: T::NetworkId,
|
||||
network: NetworkData,
|
||||
) -> DispatchResult {
|
||||
Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
|
||||
ensure!(
|
||||
maybe_network.is_none(),
|
||||
Error::<T>::NetworkAlreadyRegistered
|
||||
);
|
||||
ensure!(maybe_network.is_none(), Error::<T>::NetworkAlreadyRegistered);
|
||||
*maybe_network = Some(network.clone());
|
||||
Ok(())
|
||||
})?;
|
||||
@ -459,7 +443,10 @@ impl<T: Config> Pallet<T> {
|
||||
}
|
||||
|
||||
/// Update existent network name.
|
||||
pub fn do_update_network_name(chain_id: T::NetworkId, chain_name: Vec<u8>) -> DispatchResult {
|
||||
pub fn do_update_network_name(
|
||||
chain_id: T::NetworkId,
|
||||
chain_name: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
|
||||
ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);
|
||||
let net = maybe_network.as_mut().unwrap();
|
||||
@ -478,38 +465,19 @@ impl<T: Config> Pallet<T> {
|
||||
/// Update existent network default endpoint.
|
||||
pub fn do_update_network_endpoint(
|
||||
chain_id: T::NetworkId,
|
||||
maybe_index: Option<u32>,
|
||||
maybe_endpoint: Option<Vec<u8>>,
|
||||
default_endpoint: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
|
||||
ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);
|
||||
let updated_network = maybe_network.as_mut().unwrap();
|
||||
match (maybe_index, maybe_endpoint) {
|
||||
(Some(index), Some(endpoint)) => {
|
||||
if let Some(previous_endpoint) =
|
||||
updated_network.default_endpoints.get_mut(index as usize)
|
||||
{
|
||||
*previous_endpoint = endpoint.clone();
|
||||
Self::deposit_event(Event::<T>::NetworkEndpointUpdated {
|
||||
chain_id,
|
||||
index,
|
||||
endpoint,
|
||||
});
|
||||
}
|
||||
}
|
||||
(None, Some(endpoint)) => {
|
||||
updated_network.default_endpoints.push(endpoint.clone());
|
||||
Self::deposit_event(Event::<T>::NetworkEndpointAdded { chain_id, endpoint });
|
||||
}
|
||||
(Some(index), None) => {
|
||||
updated_network.default_endpoints.remove(index as usize);
|
||||
Self::deposit_event(Event::<T>::NetworkEndpointRemoved { chain_id, index });
|
||||
}
|
||||
(None, None) => {}
|
||||
}
|
||||
*maybe_network = Some(updated_network.clone());
|
||||
let net = maybe_network.as_mut().unwrap();
|
||||
net.default_endpoint = default_endpoint.clone();
|
||||
*maybe_network = Some(net.clone());
|
||||
Ok(())
|
||||
})?;
|
||||
Self::deposit_event(Event::<T>::NetworkEndpointUpdated {
|
||||
chain_id,
|
||||
default_endpoint,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@ -594,10 +562,8 @@ impl<T: Config> Pallet<T> {
|
||||
chain_id: T::NetworkId,
|
||||
gatekeeper: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
ensure!(
|
||||
gatekeeper.len() == 42 && gatekeeper[0] == 48 && gatekeeper[1] == 120,
|
||||
Error::<T>::WrongGatekeeperAddress
|
||||
);
|
||||
ensure!(gatekeeper.len() == 42 && gatekeeper[0] == 48 && gatekeeper[1] == 120,
|
||||
Error::<T>::WrongGatekeeperAddress);
|
||||
Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
|
||||
ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);
|
||||
let net = maybe_network.as_mut().unwrap();
|
||||
@ -617,10 +583,8 @@ impl<T: Config> Pallet<T> {
|
||||
chain_id: T::NetworkId,
|
||||
topic_name: Vec<u8>,
|
||||
) -> DispatchResult {
|
||||
ensure!(
|
||||
topic_name.len() == 66 && topic_name[0] == 48 && topic_name[1] == 120,
|
||||
Error::<T>::WrongTopicName
|
||||
);
|
||||
ensure!(topic_name.len() == 66 && topic_name[0] == 48 && topic_name[1] == 120,
|
||||
Error::<T>::WrongTopicName);
|
||||
Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
|
||||
ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);
|
||||
let net = maybe_network.as_mut().unwrap();
|
||||
@ -703,16 +667,15 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
|
||||
network_id: &T::NetworkId,
|
||||
amount: &BalanceOf<T>,
|
||||
) -> Result<BalanceOf<T>, ()> {
|
||||
let new_gatekeeper_amount =
|
||||
GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| match gatekeeper_amount
|
||||
.checked_add(amount)
|
||||
{
|
||||
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(()),
|
||||
})?;
|
||||
},
|
||||
None => Err(())
|
||||
}
|
||||
})?;
|
||||
|
||||
Ok(new_gatekeeper_amount)
|
||||
}
|
||||
@ -721,29 +684,28 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
|
||||
network_id: &T::NetworkId,
|
||||
amount: &BalanceOf<T>,
|
||||
) -> Result<BalanceOf<T>, ()> {
|
||||
let new_gatekeeper_amount =
|
||||
GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| match gatekeeper_amount
|
||||
.checked_sub(amount)
|
||||
{
|
||||
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(()),
|
||||
})?;
|
||||
},
|
||||
None => Err(())
|
||||
}
|
||||
})?;
|
||||
|
||||
Ok(new_gatekeeper_amount)
|
||||
}
|
||||
|
||||
fn accumulate_outgoing_imbalance(amount: &BalanceOf<T>) -> Result<BalanceOf<T>, ()> {
|
||||
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(()),
|
||||
}
|
||||
match bridged_imbalance.bridged_out.checked_add(amount) {
|
||||
Some(value) => {
|
||||
(*bridged_imbalance).bridged_out = value;
|
||||
Ok(value)
|
||||
},
|
||||
None => Err(())
|
||||
}
|
||||
})?;
|
||||
|
||||
Ok(new_bridged_out_amount)
|
||||
@ -755,8 +717,8 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
|
||||
Some(value) => {
|
||||
(*bridged_imbalance).bridged_in = value;
|
||||
Ok(value)
|
||||
}
|
||||
None => Err(()),
|
||||
},
|
||||
None => Err(())
|
||||
}
|
||||
})?;
|
||||
|
||||
@ -769,7 +731,7 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
|
||||
Some(value) => {
|
||||
*accumulated = value;
|
||||
Ok(value)
|
||||
}
|
||||
},
|
||||
None => Err(()),
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,16 +1,17 @@
|
||||
use crate::{self as ghost_networks};
|
||||
use frame_system::EnsureSignedBy;
|
||||
use frame_support::{
|
||||
construct_runtime, ord_parameter_types, parameter_types,
|
||||
traits::{ConstU128, ConstU32, Everything},
|
||||
};
|
||||
use frame_system::EnsureSignedBy;
|
||||
pub use primitives::{
|
||||
AccountId, Balance, BlockNumber, FreezeIdentifier, Hash, Nonce, ReserveIdentifier,
|
||||
AccountId, Balance, Nonce, BlockNumber, Hash,
|
||||
ReserveIdentifier, FreezeIdentifier,
|
||||
};
|
||||
use sp_runtime::{
|
||||
curve::PiecewiseLinear,
|
||||
traits::{AccountIdLookup, BlakeTwo256},
|
||||
BuildStorage,
|
||||
BuildStorage
|
||||
};
|
||||
|
||||
parameter_types! {
|
||||
@ -95,9 +96,9 @@ 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>;
|
||||
type RemoveOrigin = EnsureSignedBy<RemoverAccount, AccountId>;
|
||||
type RegisterOrigin = EnsureSignedBy::<RegistererAccount, AccountId>;
|
||||
type UpdateOrigin = EnsureSignedBy::<UpdaterAccount, AccountId>;
|
||||
type RemoveOrigin = EnsureSignedBy::<RemoverAccount, AccountId>;
|
||||
type WeightInfo = crate::weights::SubstrateWeight<Test>;
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "ghost-slow-clap"
|
||||
version = "0.3.33"
|
||||
version = "0.3.30"
|
||||
description = "Applause protocol for the EVM bridge"
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
|
||||
@ -3,8 +3,8 @@
|
||||
use super::*;
|
||||
use frame_benchmarking::v1::*;
|
||||
|
||||
use frame_support::traits::fungible::Inspect;
|
||||
use frame_system::RawOrigin;
|
||||
use frame_support::traits::fungible::Inspect;
|
||||
|
||||
pub fn create_account<T: Config>() -> T::AccountId {
|
||||
let account_bytes = Vec::from([1u8; 32]);
|
||||
|
||||
@ -1,57 +0,0 @@
|
||||
use crate::{Deserialize, Deserializer, Vec, H256};
|
||||
|
||||
pub fn de_string_to_bytes<'de, D>(de: D) -> Result<Option<Vec<u8>>, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let s: &str = Deserialize::deserialize(de)?;
|
||||
Ok(Some(s.as_bytes().to_vec()))
|
||||
}
|
||||
|
||||
pub fn de_string_to_u64<'de, D>(de: D) -> Result<Option<u64>, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let s: &str = Deserialize::deserialize(de)?;
|
||||
let s = if s.starts_with("0x") { &s[2..] } else { &s };
|
||||
Ok(u64::from_str_radix(s, 16).ok())
|
||||
}
|
||||
|
||||
pub fn de_string_to_u64_pure<'de, D>(de: D) -> Result<u64, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let s: &str = Deserialize::deserialize(de)?;
|
||||
let s = if s.starts_with("0x") { &s[2..] } else { &s };
|
||||
Ok(u64::from_str_radix(s, 16).unwrap_or_default())
|
||||
}
|
||||
|
||||
pub fn de_string_to_h256<'de, D>(de: D) -> Result<Option<H256>, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let s: &str = Deserialize::deserialize(de)?;
|
||||
let start_index = if s.starts_with("0x") { 2 } else { 0 };
|
||||
let h256: Vec<_> = (start_index..s.len())
|
||||
.step_by(2)
|
||||
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).expect("valid u8 symbol; qed"))
|
||||
.collect();
|
||||
Ok(Some(H256::from_slice(&h256)))
|
||||
}
|
||||
|
||||
pub fn de_string_to_vec_of_bytes<'de, D>(de: D) -> Result<Vec<Vec<u8>>, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let strings: Vec<&str> = Deserialize::deserialize(de)?;
|
||||
Ok(strings
|
||||
.iter()
|
||||
.map(|s| {
|
||||
let start_index = if s.starts_with("0x") { 2 } else { 0 };
|
||||
(start_index..s.len())
|
||||
.step_by(2)
|
||||
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).expect("valid u8 symbol; qed"))
|
||||
.collect::<Vec<u8>>()
|
||||
})
|
||||
.collect::<Vec<Vec<u8>>>())
|
||||
}
|
||||
@ -1,49 +0,0 @@
|
||||
use crate::{
|
||||
deserialisations::{
|
||||
de_string_to_bytes, de_string_to_h256, de_string_to_u64, de_string_to_u64_pure,
|
||||
de_string_to_vec_of_bytes,
|
||||
},
|
||||
Decode, Deserialize, Encode, RuntimeDebug, Vec, H256,
|
||||
};
|
||||
|
||||
const NUMBER_OF_TOPICS: usize = 3;
|
||||
|
||||
#[derive(RuntimeDebug, Clone, PartialEq, Deserialize, Encode, Decode)]
|
||||
pub struct EvmResponse {
|
||||
#[serde(default)]
|
||||
id: Option<u32>,
|
||||
#[serde(default, deserialize_with = "de_string_to_bytes")]
|
||||
jsonrpc: Option<Vec<u8>>,
|
||||
#[serde(default, deserialize_with = "de_string_to_bytes")]
|
||||
pub error: Option<Vec<u8>>,
|
||||
#[serde(default)]
|
||||
pub result: Option<EvmResponseType>,
|
||||
}
|
||||
|
||||
#[derive(RuntimeDebug, Clone, PartialEq, Deserialize, Encode, Decode)]
|
||||
#[serde(untagged)]
|
||||
pub enum EvmResponseType {
|
||||
#[serde(deserialize_with = "de_string_to_u64_pure")]
|
||||
BlockNumber(u64),
|
||||
TransactionLogs(Vec<Log>),
|
||||
}
|
||||
|
||||
#[derive(RuntimeDebug, Clone, Eq, PartialEq, Ord, PartialOrd, Deserialize, Encode, Decode)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Log {
|
||||
#[serde(default, deserialize_with = "de_string_to_h256")]
|
||||
pub transaction_hash: Option<H256>,
|
||||
#[serde(default, deserialize_with = "de_string_to_u64")]
|
||||
pub block_number: Option<u64>,
|
||||
#[serde(default, deserialize_with = "de_string_to_vec_of_bytes")]
|
||||
pub topics: Vec<Vec<u8>>,
|
||||
pub removed: bool,
|
||||
}
|
||||
|
||||
impl Log {
|
||||
pub fn is_sufficient(&self) -> bool {
|
||||
self.transaction_hash.is_some()
|
||||
&& self.block_number.is_some()
|
||||
&& self.topics.len() == NUMBER_OF_TOPICS
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,15 +2,13 @@
|
||||
|
||||
use frame_support::{
|
||||
derive_impl, parameter_types,
|
||||
traits::{ConstU32, ConstU64},
|
||||
weights::Weight,
|
||||
traits::{ConstU32, ConstU64}, weights::Weight,
|
||||
};
|
||||
use frame_system::EnsureRoot;
|
||||
use pallet_session::historical as pallet_session_historical;
|
||||
use sp_runtime::{
|
||||
curve::PiecewiseLinear,
|
||||
testing::{TestXt, UintAuthorityId},
|
||||
traits::ConvertInto,
|
||||
traits::ConvertInto, curve::PiecewiseLinear,
|
||||
Permill,
|
||||
};
|
||||
use sp_staking::{
|
||||
@ -38,8 +36,8 @@ frame_support::construct_runtime!(
|
||||
|
||||
parameter_types! {
|
||||
pub static Validators: Option<Vec<u64>> = Some(vec![
|
||||
1,
|
||||
2,
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
]);
|
||||
}
|
||||
@ -55,10 +53,13 @@ impl pallet_session::SessionManager<u64> for TestSessionManager {
|
||||
|
||||
impl pallet_session::historical::SessionManager<u64, u64> for TestSessionManager {
|
||||
fn new_session(_new_index: SessionIndex) -> Option<Vec<(u64, u64)>> {
|
||||
Validators::mutate(|l| {
|
||||
l.take()
|
||||
.map(|validators| validators.iter().map(|v| (*v, *v)).collect())
|
||||
})
|
||||
Validators::mutate(|l| l
|
||||
.take()
|
||||
.map(|validators| validators
|
||||
.iter()
|
||||
.map(|v| (*v, *v))
|
||||
.collect())
|
||||
)
|
||||
}
|
||||
fn end_session(_: SessionIndex) {}
|
||||
fn start_session(_: SessionIndex) {}
|
||||
@ -93,10 +94,11 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
|
||||
result.execute_with(|| {
|
||||
for i in 1..=3 {
|
||||
System::inc_providers(&i);
|
||||
assert_eq!(
|
||||
Session::set_keys(RuntimeOrigin::signed(i), i.into(), vec![],),
|
||||
Ok(())
|
||||
);
|
||||
assert_eq!(Session::set_keys(
|
||||
RuntimeOrigin::signed(i),
|
||||
i.into(),
|
||||
vec![],
|
||||
), Ok(()));
|
||||
}
|
||||
});
|
||||
|
||||
@ -148,7 +150,7 @@ impl frame_support::traits::EstimateNextSessionRotation<u64> for TestNextSession
|
||||
}
|
||||
|
||||
fn estimate_current_session_progress(now: u64) -> (Option<Permill>, Weight) {
|
||||
let (estimate, weight) =
|
||||
let (estimate, weight) =
|
||||
pallet_session::PeriodicSessions::<Period, Offset>::estimate_current_session_progress(
|
||||
now,
|
||||
);
|
||||
@ -255,7 +257,8 @@ pub fn advance_session_with_authority(authority: u64) {
|
||||
UintAuthorityId::from(69),
|
||||
UintAuthorityId::from(420),
|
||||
UintAuthorityId::from(1337),
|
||||
],
|
||||
]
|
||||
);
|
||||
assert_eq!(session_index, (now / Period::get()) as u32);
|
||||
|
||||
}
|
||||
|
||||
@ -7,9 +7,9 @@ use frame_support::{assert_err, assert_ok, dispatch};
|
||||
use sp_core::offchain::{
|
||||
testing,
|
||||
testing::{TestOffchainExt, TestTransactionPoolExt},
|
||||
OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
|
||||
OffchainWorkerExt, OffchainDbExt, TransactionPoolExt,
|
||||
};
|
||||
use sp_runtime::{testing::UintAuthorityId, DispatchError};
|
||||
use sp_runtime::{DispatchError, testing::UintAuthorityId};
|
||||
|
||||
use ghost_networks::BridgedInflationCurve;
|
||||
use pallet_staking::EraPayout;
|
||||
@ -36,8 +36,7 @@ fn prepare_evm_network(
|
||||
assert_ok!(Networks::register_network(
|
||||
RuntimeOrigin::root(),
|
||||
maybe_network_id.unwrap_or(1u32),
|
||||
network_data.clone()
|
||||
));
|
||||
network_data.clone()));
|
||||
|
||||
network_data
|
||||
}
|
||||
@ -71,8 +70,8 @@ fn do_clap_from_first_authority(
|
||||
}
|
||||
|
||||
fn do_clap_from(
|
||||
session_index: u32,
|
||||
network_id: u32,
|
||||
session_index: u32,
|
||||
network_id: u32,
|
||||
authority_index: u32,
|
||||
transaction_removed: bool,
|
||||
) -> dispatch::DispatchResult {
|
||||
@ -89,7 +88,7 @@ fn do_clap_from(
|
||||
};
|
||||
let authority = UintAuthorityId::from((authority_index + 1) as u64);
|
||||
let signature = authority.sign(&clap.encode()).unwrap();
|
||||
|
||||
|
||||
SlowClap::pre_dispatch(&crate::Call::slow_clap {
|
||||
clap: clap.clone(),
|
||||
signature: signature.clone(),
|
||||
@ -109,14 +108,8 @@ fn test_throttling_slash_function() {
|
||||
|
||||
assert_eq!(dummy_offence.slash_fraction(1), Perbill::zero());
|
||||
assert_eq!(dummy_offence.slash_fraction(5), Perbill::zero());
|
||||
assert_eq!(
|
||||
dummy_offence.slash_fraction(7),
|
||||
Perbill::from_parts(4200000)
|
||||
);
|
||||
assert_eq!(
|
||||
dummy_offence.slash_fraction(17),
|
||||
Perbill::from_parts(46200000)
|
||||
);
|
||||
assert_eq!(dummy_offence.slash_fraction(7), Perbill::from_parts(4200000));
|
||||
assert_eq!(dummy_offence.slash_fraction(17), Perbill::from_parts(46200000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -128,10 +121,8 @@ fn request_body_is_correct_for_get_block_number() {
|
||||
t.execute_with(|| {
|
||||
let network_data = prepare_evm_network(Some(1), None);
|
||||
let request_body = SlowClap::prepare_request_body_for_latest_block(&network_data);
|
||||
assert_eq!(
|
||||
core::str::from_utf8(&request_body).unwrap(),
|
||||
r#"{"id":0,"jsonrpc":"2.0","method":"eth_blockNumber"}"#
|
||||
);
|
||||
assert_eq!(core::str::from_utf8(&request_body).unwrap(),
|
||||
r#"{"id":0,"jsonrpc":"2.0","method":"eth_blockNumber"}"#);
|
||||
});
|
||||
}
|
||||
|
||||
@ -186,10 +177,7 @@ fn should_make_http_call_for_logs() {
|
||||
|
||||
let network_data = prepare_evm_network(Some(1), None);
|
||||
let request_body = SlowClap::prepare_request_body_for_latest_transfers(
|
||||
from_block,
|
||||
to_block,
|
||||
&network_data,
|
||||
);
|
||||
from_block, to_block, &network_data);
|
||||
let raw_response = SlowClap::fetch_from_remote(&rpc_endpoint, &request_body)?;
|
||||
assert_eq!(raw_response.len(), 1805); // precalculated
|
||||
Ok(())
|
||||
@ -210,8 +198,7 @@ fn should_make_http_call_and_parse_block_number() {
|
||||
|
||||
let request_body = SlowClap::prepare_request_body_for_latest_block(&network_data);
|
||||
let raw_response = SlowClap::fetch_from_remote(&rpc_endpoint, &request_body)?;
|
||||
let maybe_evm_block_number =
|
||||
SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
|
||||
let maybe_evm_block_number = SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
|
||||
|
||||
assert_eq!(maybe_evm_block_number, Some(20335745));
|
||||
Ok(())
|
||||
@ -240,10 +227,7 @@ fn should_make_http_call_and_parse_logs() {
|
||||
|
||||
let network_data = prepare_evm_network(Some(network_id), None);
|
||||
let request_body = SlowClap::prepare_request_body_for_latest_transfers(
|
||||
from_block,
|
||||
to_block,
|
||||
&network_data,
|
||||
);
|
||||
from_block, to_block, &network_data);
|
||||
|
||||
let raw_response = SlowClap::fetch_from_remote(&rpc_endpoint, &request_body)?;
|
||||
match SlowClap::parse_evm_response(&raw_response)? {
|
||||
@ -275,30 +259,21 @@ fn should_clear_sesions_based_on_history_depth() {
|
||||
let storage_key = (session_index, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
assert_ok!(do_clap_from(session_index, network_id, 2, false));
|
||||
|
||||
assert_claps_info_correct(&storage_key, &session_index, 3);
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
|
||||
|
||||
for _ in 0..history_depth {
|
||||
advance_session();
|
||||
}
|
||||
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
});
|
||||
}
|
||||
|
||||
@ -337,10 +312,7 @@ fn should_increase_gatkeeper_amount_accordingly() {
|
||||
assert_ok!(do_clap_from(session_index, network_id, 2, false));
|
||||
|
||||
assert_eq!(Networks::gatekeeper_amount(network_id), amount);
|
||||
assert_eq!(
|
||||
Networks::bridged_imbalance().bridged_in,
|
||||
amount.saturating_div(2)
|
||||
);
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_in, amount.saturating_div(2));
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_out, 0);
|
||||
});
|
||||
}
|
||||
@ -374,29 +346,18 @@ fn should_applause_and_take_next_claps() {
|
||||
let session_index = advance_session_and_get_index();
|
||||
let storage_key = (session_index, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
|
||||
assert_eq!(Balances::balance(&receiver), amount);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 2, false));
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
|
||||
assert_eq!(Balances::balance(&receiver), amount);
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
@ -412,10 +373,8 @@ fn should_throw_error_on_clap_duplication() {
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
assert_claps_info_correct(&storage_key, &session_index, 1);
|
||||
assert_err!(
|
||||
do_clap_from(session_index, network_id, 0, false),
|
||||
Error::<Runtime>::AlreadyClapped
|
||||
);
|
||||
assert_err!(do_clap_from(session_index, network_id, 0, false),
|
||||
Error::<Runtime>::AlreadyClapped);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 1);
|
||||
});
|
||||
}
|
||||
@ -430,10 +389,8 @@ fn should_throw_error_on_removal_of_unregistered_clap() {
|
||||
let storage_key = (session_index, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_err!(
|
||||
do_clap_from(session_index, network_id, 0, true),
|
||||
Error::<Runtime>::UnregisteredClapRemove
|
||||
);
|
||||
assert_err!(do_clap_from(session_index, network_id, 0, true),
|
||||
Error::<Runtime>::UnregisteredClapRemove);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
});
|
||||
}
|
||||
@ -463,21 +420,9 @@ fn should_throw_error_if_session_index_is_not_current() {
|
||||
let session_index_prev = chunk[0].1;
|
||||
let session_index_next = chunk[2].1;
|
||||
|
||||
let storage_key_curr = (
|
||||
session_index_curr,
|
||||
transaction_hash,
|
||||
unique_transaction_hash,
|
||||
);
|
||||
let storage_key_prev = (
|
||||
session_index_prev,
|
||||
transaction_hash,
|
||||
unique_transaction_hash,
|
||||
);
|
||||
let storage_key_next = (
|
||||
session_index_next,
|
||||
transaction_hash,
|
||||
unique_transaction_hash,
|
||||
);
|
||||
let storage_key_curr = (session_index_curr, transaction_hash, unique_transaction_hash);
|
||||
let storage_key_prev = (session_index_prev, transaction_hash, unique_transaction_hash);
|
||||
let storage_key_next = (session_index_next, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_claps_info_correct(&storage_key_curr, &session_index_curr, 0);
|
||||
assert_claps_info_correct(&storage_key_prev, &session_index_prev, 0);
|
||||
@ -504,25 +449,14 @@ fn should_throw_error_if_session_index_is_not_current() {
|
||||
assert_claps_info_correct(&storage_key_prev, &session_index_prev, 0);
|
||||
assert_claps_info_correct(&storage_key_next, &session_index_next, 0);
|
||||
|
||||
assert_ok!(do_clap_from_first_authority(
|
||||
session_index_curr,
|
||||
network_id,
|
||||
authority_curr
|
||||
));
|
||||
assert_ok!(do_clap_from_first_authority(
|
||||
session_index_prev,
|
||||
network_id,
|
||||
authority_prev
|
||||
));
|
||||
assert_ok!(do_clap_from_first_authority(
|
||||
session_index_next,
|
||||
network_id,
|
||||
authority_next
|
||||
));
|
||||
assert_ok!(do_clap_from_first_authority(session_index_curr, network_id, authority_curr));
|
||||
assert_ok!(do_clap_from_first_authority(session_index_prev, network_id, authority_prev));
|
||||
assert_ok!(do_clap_from_first_authority(session_index_next, network_id, authority_next));
|
||||
|
||||
assert_claps_info_correct(&storage_key_curr, &session_index_curr, 1);
|
||||
assert_claps_info_correct(&storage_key_prev, &session_index_prev, 1);
|
||||
assert_claps_info_correct(&storage_key_next, &session_index_next, 1);
|
||||
|
||||
}
|
||||
});
|
||||
}
|
||||
@ -549,10 +483,8 @@ fn should_throw_error_if_signer_has_incorrect_index() {
|
||||
};
|
||||
let authority = UintAuthorityId::from((1) as u64);
|
||||
let signature = authority.sign(&clap.encode()).unwrap();
|
||||
assert_err!(
|
||||
SlowClap::slow_clap(RuntimeOrigin::none(), clap, signature),
|
||||
Error::<Runtime>::NotAnAuthority
|
||||
);
|
||||
assert_err!(SlowClap::slow_clap(RuntimeOrigin::none(), clap, signature),
|
||||
Error::<Runtime>::NotAnAuthority);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
});
|
||||
}
|
||||
@ -568,41 +500,27 @@ fn should_throw_error_if_validator_disabled_and_ignore_later() {
|
||||
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_eq!(Session::disable_index(0), true);
|
||||
assert_err!(
|
||||
do_clap_from(session_index, network_id, 0, false),
|
||||
Error::<Runtime>::CurrentValidatorIsDisabled
|
||||
);
|
||||
assert_err!(do_clap_from(session_index, network_id, 0, false),
|
||||
Error::<Runtime>::CurrentValidatorIsDisabled);
|
||||
|
||||
assert_eq!(pallet::ReceivedClaps::<Runtime>::get(&storage_key).len(), 0);
|
||||
assert_eq!(
|
||||
pallet::ClapsInSession::<Runtime>::get(&session_index).len(),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
pallet::ClapsInSession::<Runtime>::get(&session_index)
|
||||
.into_iter()
|
||||
.filter(|(_, v)| !v.disabled)
|
||||
.collect::<Vec<_>>()
|
||||
.len(),
|
||||
0
|
||||
);
|
||||
assert_eq!(pallet::ClapsInSession::<Runtime>::get(&session_index).len(), 1);
|
||||
assert_eq!(pallet::ClapsInSession::<Runtime>::get(&session_index)
|
||||
.into_iter()
|
||||
.filter(|(_, v)| !v.disabled)
|
||||
.collect::<Vec<_>>()
|
||||
.len(), 0);
|
||||
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
assert_eq!(Session::disable_index(1), true);
|
||||
|
||||
assert_eq!(pallet::ReceivedClaps::<Runtime>::get(&storage_key).len(), 1);
|
||||
assert_eq!(
|
||||
pallet::ClapsInSession::<Runtime>::get(&session_index).len(),
|
||||
2
|
||||
);
|
||||
assert_eq!(
|
||||
pallet::ClapsInSession::<Runtime>::get(&session_index)
|
||||
.into_iter()
|
||||
.filter(|(_, v)| !v.disabled)
|
||||
.collect::<Vec<_>>()
|
||||
.len(),
|
||||
0
|
||||
);
|
||||
assert_eq!(pallet::ClapsInSession::<Runtime>::get(&session_index).len(), 2);
|
||||
assert_eq!(pallet::ClapsInSession::<Runtime>::get(&session_index)
|
||||
.into_iter()
|
||||
.filter(|(_, v)| !v.disabled)
|
||||
.collect::<Vec<_>>()
|
||||
.len(), 0);
|
||||
});
|
||||
}
|
||||
|
||||
@ -635,10 +553,7 @@ fn should_clap_without_applause_on_gatekeeper_amount_overflow() {
|
||||
}
|
||||
|
||||
assert_claps_info_correct(&storage_key_first, &session_index, 3);
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key_first),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key_first), true);
|
||||
assert_eq!(Balances::balance(&first_receiver), big_amount);
|
||||
assert_eq!(Balances::balance(&second_receiver), 0);
|
||||
|
||||
@ -699,10 +614,7 @@ fn should_clap_without_applause_on_commission_overflow() {
|
||||
}
|
||||
|
||||
assert_claps_info_correct(&storage_key_first, &session_index, 3);
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key_first),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key_first), true);
|
||||
assert_eq!(Balances::balance(&first_receiver), big_amount);
|
||||
assert_eq!(Balances::balance(&second_receiver), 0);
|
||||
|
||||
@ -750,14 +662,10 @@ fn should_nullify_commission_on_finalize() {
|
||||
assert_eq!(Networks::accumulated_commission(), amount);
|
||||
assert_eq!(Networks::is_nullification_period(), false);
|
||||
|
||||
assert_eq!(
|
||||
BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
|
||||
assert_eq!(BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
|
||||
total_staked,
|
||||
total_issuance,
|
||||
0
|
||||
),
|
||||
(420000000000000, 0)
|
||||
); // precomputed values
|
||||
0), (420000000000000, 0)); // precomputed values
|
||||
assert_eq!(Networks::is_nullification_period(), true);
|
||||
Networks::on_finalize(System::block_number());
|
||||
|
||||
@ -781,14 +689,10 @@ fn should_avoid_applause_during_nullification_period() {
|
||||
let session_index = advance_session_and_get_index();
|
||||
|
||||
assert_eq!(Networks::is_nullification_period(), false);
|
||||
assert_eq!(
|
||||
BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
|
||||
assert_eq!(BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
|
||||
total_staked,
|
||||
total_issuance,
|
||||
0
|
||||
),
|
||||
(0, 0)
|
||||
);
|
||||
0), (0, 0));
|
||||
assert_eq!(Networks::is_nullification_period(), true);
|
||||
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
@ -814,66 +718,49 @@ fn should_self_applause_if_enough_received_claps() {
|
||||
let session_index = advance_session_and_get_index();
|
||||
let storage_key = (session_index, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_err!(
|
||||
SlowClap::self_applause(
|
||||
assert_err!(SlowClap::self_applause(
|
||||
RuntimeOrigin::signed(receiver),
|
||||
network_id,
|
||||
session_index,
|
||||
transaction_hash,
|
||||
receiver,
|
||||
amount,
|
||||
),
|
||||
Error::<Runtime>::NotEnoughClaps
|
||||
);
|
||||
), Error::<Runtime>::NotEnoughClaps);
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
assert_eq!(
|
||||
BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(0, 0, 0),
|
||||
(0, 0)
|
||||
);
|
||||
assert_eq!(BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
|
||||
0, 0, 0), (0, 0));
|
||||
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
assert_ok!(do_clap_from(session_index, network_id, 2, false));
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
|
||||
assert_ok!(SlowClap::self_applause(
|
||||
RuntimeOrigin::signed(receiver),
|
||||
network_id,
|
||||
session_index,
|
||||
transaction_hash,
|
||||
receiver,
|
||||
amount,
|
||||
RuntimeOrigin::signed(receiver),
|
||||
network_id,
|
||||
session_index,
|
||||
transaction_hash,
|
||||
receiver,
|
||||
amount,
|
||||
));
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
|
||||
Networks::on_finalize(System::block_number());
|
||||
|
||||
assert_ok!(SlowClap::self_applause(
|
||||
RuntimeOrigin::signed(receiver),
|
||||
network_id,
|
||||
session_index,
|
||||
transaction_hash,
|
||||
receiver,
|
||||
amount,
|
||||
RuntimeOrigin::signed(receiver),
|
||||
network_id,
|
||||
session_index,
|
||||
transaction_hash,
|
||||
receiver,
|
||||
amount,
|
||||
));
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
|
||||
assert_eq!(Balances::balance(&receiver), amount);
|
||||
});
|
||||
}
|
||||
@ -892,67 +779,60 @@ fn should_emit_event_on_each_clap_and_on_applause() {
|
||||
let session_index = advance_session_and_get_index();
|
||||
let storage_key = (session_index, transaction_hash, unique_transaction_hash);
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 0);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
System::assert_last_event(RuntimeEvent::SlowClap(crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 0,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
}));
|
||||
System::assert_last_event(RuntimeEvent::SlowClap(
|
||||
crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 0,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
}));
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 1);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
let binding = System::events();
|
||||
let last_two_events = binding.iter().rev().take(5).collect::<Vec<_>>();
|
||||
assert_eq!(
|
||||
last_two_events[0].event,
|
||||
RuntimeEvent::SlowClap(crate::Event::Applaused {
|
||||
network_id,
|
||||
receiver: receiver.clone(),
|
||||
received_amount: amount_after_commission,
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
last_two_events[4].event,
|
||||
RuntimeEvent::SlowClap(crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 1,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
})
|
||||
);
|
||||
let last_two_events = binding
|
||||
.iter()
|
||||
.rev()
|
||||
.take(5)
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(last_two_events[0].event, RuntimeEvent::SlowClap(
|
||||
crate::Event::Applaused {
|
||||
network_id,
|
||||
receiver: receiver.clone(),
|
||||
received_amount: amount_after_commission,
|
||||
}));
|
||||
assert_eq!(last_two_events[4].event, RuntimeEvent::SlowClap(
|
||||
crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 1,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
}));
|
||||
|
||||
assert_eq!(
|
||||
pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
|
||||
assert_claps_info_correct(&storage_key, &session_index, 2);
|
||||
assert_ok!(do_clap_from(session_index, network_id, 2, false));
|
||||
System::assert_last_event(RuntimeEvent::SlowClap(crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 2,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
}));
|
||||
System::assert_last_event(RuntimeEvent::SlowClap(
|
||||
crate::Event::Clapped {
|
||||
receiver: receiver.clone(),
|
||||
authority_id: 2,
|
||||
network_id,
|
||||
transaction_hash,
|
||||
amount,
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_not_fail_on_sub_existential_balance() {
|
||||
let (network_id, transaction_hash, unique_transaction_hash) =
|
||||
generate_unique_hash(None, None, None, None);
|
||||
let (network_id, transaction_hash, unique_transaction_hash)
|
||||
= generate_unique_hash(None, None, None, None);
|
||||
let (_, receiver, amount) = get_mocked_metadata();
|
||||
|
||||
new_test_ext().execute_with(|| {
|
||||
@ -965,10 +845,7 @@ fn should_not_fail_on_sub_existential_balance() {
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_in, 0);
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_out, 0);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
assert_eq!(
|
||||
SlowClap::applauses_for_transaction(&received_claps_key),
|
||||
false
|
||||
);
|
||||
assert_eq!(SlowClap::applauses_for_transaction(&received_claps_key), false);
|
||||
|
||||
assert_ok!(do_clap_from(session_index, network_id, 0, false));
|
||||
assert_ok!(do_clap_from(session_index, network_id, 1, false));
|
||||
@ -979,10 +856,7 @@ fn should_not_fail_on_sub_existential_balance() {
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_in, 0);
|
||||
assert_eq!(Networks::bridged_imbalance().bridged_out, 0);
|
||||
assert_eq!(Balances::balance(&receiver), 0);
|
||||
assert_eq!(
|
||||
SlowClap::applauses_for_transaction(&received_claps_key),
|
||||
true
|
||||
);
|
||||
assert_eq!(SlowClap::applauses_for_transaction(&received_claps_key), true);
|
||||
});
|
||||
}
|
||||
|
||||
@ -1007,34 +881,40 @@ fn generate_unique_hash(
|
||||
let receiver = maybe_receiver.unwrap_or(receiver);
|
||||
let amount = maybe_amount.unwrap_or(amount);
|
||||
|
||||
let unique_transaction_hash = SlowClap::generate_unique_hash(&receiver, &amount, &network_id);
|
||||
let unique_transaction_hash = SlowClap::generate_unique_hash(
|
||||
&receiver,
|
||||
&amount,
|
||||
&network_id,
|
||||
);
|
||||
|
||||
(network_id, transaction_hash, unique_transaction_hash)
|
||||
}
|
||||
|
||||
fn assert_claps_info_correct(storage_key: &(u32, H256, H256), session_index: &u32, index: usize) {
|
||||
assert_eq!(
|
||||
pallet::ReceivedClaps::<Runtime>::get(storage_key).len(),
|
||||
index
|
||||
);
|
||||
assert_eq!(
|
||||
pallet::ClapsInSession::<Runtime>::get(session_index).len(),
|
||||
index
|
||||
);
|
||||
fn assert_claps_info_correct(
|
||||
storage_key: &(u32, H256, H256),
|
||||
session_index: &u32,
|
||||
index: usize,
|
||||
) {
|
||||
assert_eq!(pallet::ReceivedClaps::<Runtime>::get(storage_key).len(), index);
|
||||
assert_eq!(pallet::ClapsInSession::<Runtime>::get(session_index).len(), index);
|
||||
}
|
||||
|
||||
fn assert_transaction_has_bad_signature(session_index: u32, network_id: u32, authority: u64) {
|
||||
assert_err!(
|
||||
do_clap_from_first_authority(session_index, network_id, authority),
|
||||
DispatchError::Other("Transaction has a bad signature")
|
||||
);
|
||||
fn assert_transaction_has_bad_signature(
|
||||
session_index: u32,
|
||||
network_id: u32,
|
||||
authority: u64,
|
||||
) {
|
||||
assert_err!(do_clap_from_first_authority(session_index, network_id, authority),
|
||||
DispatchError::Other("Transaction has a bad signature"));
|
||||
}
|
||||
|
||||
fn assert_invalid_signing_address(session_index: u32, network_id: u32, authority_index: u32) {
|
||||
assert_err!(
|
||||
do_clap_from(session_index, network_id, authority_index, false),
|
||||
DispatchError::Other("Invalid signing address")
|
||||
);
|
||||
fn assert_invalid_signing_address(
|
||||
session_index: u32,
|
||||
network_id: u32,
|
||||
authority_index: u32,
|
||||
) {
|
||||
assert_err!(do_clap_from(session_index, network_id, authority_index, false),
|
||||
DispatchError::Other("Invalid signing address"));
|
||||
}
|
||||
|
||||
fn get_rpc_endpoint() -> Vec<u8> {
|
||||
|
||||
@ -1,45 +0,0 @@
|
||||
[package]
|
||||
name = "ghost-sudo"
|
||||
version = "0.0.1"
|
||||
description = "Port of the sudo pallet because of dependencies issue"
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
edition.workspace = true
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
|
||||
[dependencies]
|
||||
docify = "0.2.8"
|
||||
codec = { workspace = true, features = ["derive"] }
|
||||
frame-benchmarking = { workspace = true, optional = true }
|
||||
scale-info = { workspace = true, features = ["derive"] }
|
||||
frame-support = { workspace = true }
|
||||
frame-system = { workspace = true }
|
||||
|
||||
sp-io = { workspace = true }
|
||||
sp-runtime = { workspace = true }
|
||||
sp-std = { workspace = true }
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = [
|
||||
"codec/std",
|
||||
"frame-benchmarking?/std",
|
||||
"frame-support/std",
|
||||
"frame-system/std",
|
||||
"scale-info/std",
|
||||
"sp-io/std",
|
||||
"sp-runtime/std",
|
||||
"sp-std/std",
|
||||
]
|
||||
runtime-benchmarks = [
|
||||
"frame-benchmarking/runtime-benchmarks",
|
||||
"frame-support/runtime-benchmarks",
|
||||
"frame-system/runtime-benchmarks",
|
||||
"sp-runtime/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
"frame-support/try-runtime",
|
||||
"frame-system/try-runtime",
|
||||
"sp-runtime/try-runtime",
|
||||
]
|
||||
@ -1,70 +0,0 @@
|
||||
use super::*;
|
||||
use crate::Pallet;
|
||||
use frame_benchmarking::v2::*;
|
||||
use frame_system::RawOrigin;
|
||||
|
||||
fn assert_last_event<T: Config>(generic_event: crate::Event<T>) {
|
||||
let re: <T as Config>::RuntimeEvent = generic_event.into();
|
||||
frame_system::Pallet::<T>::assert_last_event(re.into());
|
||||
}
|
||||
|
||||
#[benchmarks(where <T as Config>::RuntimeCall: From<frame_system::Call<T>>)]
|
||||
mod benchmarks {
|
||||
use super::*;
|
||||
|
||||
#[benchmark]
|
||||
fn set_key() {
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
Key::<T>::put(&caller);
|
||||
|
||||
let new_sudoer: T::AccountId = account("sudoer", 0, 0);
|
||||
let new_sudoer_lookup = T::Lookup::unlookup(new_sudoer.clone());
|
||||
|
||||
#[extrinsic_call]
|
||||
_(RawOrigin::Signed(caller.clone()), new_sudoer_lookup);
|
||||
|
||||
assert_last_event::<T>(Event::KeyChanged { old: Some(caller), new: new_sudoer });
|
||||
}
|
||||
|
||||
#[benchmark]
|
||||
fn sudo() {
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
Key::<T>::put(&caller);
|
||||
|
||||
let call = frame_system::Call::remark { remark: vec![] }.into();
|
||||
|
||||
#[extrinsic_call]
|
||||
_(RawOrigin::Signed(caller), Box::new(call));
|
||||
|
||||
assert_last_event::<T>(Event::Sudid { sudo_result: Ok(()) })
|
||||
}
|
||||
|
||||
#[benchmark]
|
||||
fn sudo_as() {
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
Key::<T>::put(caller.clone());
|
||||
|
||||
let call = frame_system::Call::remark { remark: vec![] }.into();
|
||||
|
||||
let who: T::AccountId = account("as", 0, 0);
|
||||
let who_lookup = T::Lookup::unlookup(who);
|
||||
|
||||
#[extrinsic_call]
|
||||
_(RawOrigin::Signed(caller), who_lookup, Box::new(call));
|
||||
|
||||
assert_last_event::<T>(Event::SudoAsDone { sudo_result: Ok(()) })
|
||||
}
|
||||
|
||||
#[benchmark]
|
||||
fn remove_key() {
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
Key::<T>::put(&caller);
|
||||
|
||||
#[extrinsic_call]
|
||||
_(RawOrigin::Signed(caller.clone()));
|
||||
|
||||
assert_last_event::<T>(Event::KeyRemoved {});
|
||||
}
|
||||
|
||||
impl_benchmark_test_suite!(Pallet, crate::mock::new_bench_ext(), crate::mock::Test);
|
||||
}
|
||||
@ -1,82 +0,0 @@
|
||||
use crate::{Config, Key};
|
||||
use codec::{Decode, Encode};
|
||||
use frame_support::{dispatch::DispatchInfo, ensure};
|
||||
use scale_info::TypeInfo;
|
||||
use sp_runtime::{
|
||||
traits::{DispatchInfoOf, Dispatchable, SignedExtension},
|
||||
transaction_validity::{
|
||||
InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,
|
||||
UnknownTransaction, ValidTransaction,
|
||||
},
|
||||
};
|
||||
use sp_std::{fmt, marker::PhantomData};
|
||||
|
||||
#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo)]
|
||||
#[scale_info(skip_type_params(T))]
|
||||
pub struct CheckOnlySudoAccount<T: Config + Send + Sync>(PhantomData<T>);
|
||||
|
||||
impl<T: Config + Send + Sync> Default for CheckOnlySudoAccount<T> {
|
||||
fn default() -> Self {
|
||||
Self(Default::default())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config + Send + Sync> fmt::Debug for CheckOnlySudoAccount<T> {
|
||||
#[cfg(feature = "std")]
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "CheckOnlySudoAccount")
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "std"))]
|
||||
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config + Send + Sync> CheckOnlySudoAccount<T> {
|
||||
/// Creates new `SignedExtension` to check sudo key.
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config + Send + Sync> SignedExtension for CheckOnlySudoAccount<T>
|
||||
where
|
||||
<T as Config>::RuntimeCall: Dispatchable<Info = DispatchInfo>,
|
||||
{
|
||||
const IDENTIFIER: &'static str = "CheckOnlySudoAccount";
|
||||
type AccountId = T::AccountId;
|
||||
type Call = <T as Config>::RuntimeCall;
|
||||
type AdditionalSigned = ();
|
||||
type Pre = ();
|
||||
|
||||
fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn validate(
|
||||
&self,
|
||||
who: &Self::AccountId,
|
||||
_call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
_len: usize,
|
||||
) -> TransactionValidity {
|
||||
let sudo_key: T::AccountId = Key::<T>::get().ok_or(UnknownTransaction::CannotLookup)?;
|
||||
ensure!(*who == sudo_key, InvalidTransaction::BadSigner);
|
||||
|
||||
Ok(ValidTransaction {
|
||||
priority: info.weight.ref_time() as TransactionPriority,
|
||||
..Default::default()
|
||||
})
|
||||
}
|
||||
|
||||
fn pre_dispatch(
|
||||
self,
|
||||
who: &Self::AccountId,
|
||||
call: &Self::Call,
|
||||
info: &DispatchInfoOf<Self::Call>,
|
||||
len: usize,
|
||||
) -> Result<Self::Pre, TransactionValidityError> {
|
||||
self.validate(who, call, info, len).map(|_| ())
|
||||
}
|
||||
}
|
||||
@ -1,203 +0,0 @@
|
||||
#![cfg_attr(not(feature = "std"), no_std)]
|
||||
|
||||
use sp_runtime::{traits::StaticLookup, DispatchResult};
|
||||
use sp_std::prelude::*;
|
||||
|
||||
use frame_support::{dispatch::GetDispatchInfo, traits::UnfilteredDispatchable};
|
||||
|
||||
mod extension;
|
||||
#[cfg(test)]
|
||||
mod mock;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
mod benchmarking;
|
||||
pub mod weights;
|
||||
pub use weights::WeightInfo;
|
||||
|
||||
pub use extension::CheckOnlySudoAccount;
|
||||
pub use pallet::*;
|
||||
|
||||
type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
|
||||
|
||||
#[frame_support::pallet]
|
||||
pub mod pallet {
|
||||
use super::{DispatchResult, *};
|
||||
use frame_support::pallet_prelude::*;
|
||||
use frame_system::{pallet_prelude::*, RawOrigin};
|
||||
|
||||
pub mod config_preludes {
|
||||
use super::*;
|
||||
use frame_support::derive_impl;
|
||||
|
||||
pub struct TestDefaultConfig;
|
||||
|
||||
#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
|
||||
impl frame_system::DefaultConfig for TestDefaultConfig {}
|
||||
|
||||
#[frame_support::register_default_impl(TestDefaultConfig)]
|
||||
impl DefaultConfig for TestDefaultConfig {
|
||||
type WeightInfo = ();
|
||||
#[inject_runtime_type]
|
||||
type RuntimeEvent = ();
|
||||
#[inject_runtime_type]
|
||||
type RuntimeCall = ();
|
||||
}
|
||||
}
|
||||
#[pallet::config(with_default)]
|
||||
pub trait Config: frame_system::Config {
|
||||
#[pallet::no_default_bounds]
|
||||
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
|
||||
#[pallet::no_default_bounds]
|
||||
type RuntimeCall: Parameter
|
||||
+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
|
||||
+ GetDispatchInfo;
|
||||
|
||||
type WeightInfo: WeightInfo;
|
||||
}
|
||||
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight({
|
||||
let dispatch_info = call.get_dispatch_info();
|
||||
(
|
||||
T::WeightInfo::sudo().saturating_add(dispatch_info.weight),
|
||||
dispatch_info.class
|
||||
)
|
||||
})]
|
||||
pub fn sudo(
|
||||
origin: OriginFor<T>,
|
||||
call: Box<<T as Config>::RuntimeCall>,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
Self::ensure_sudo(origin)?;
|
||||
|
||||
let res = call.dispatch_bypass_filter(RawOrigin::Root.into());
|
||||
Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
|
||||
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
#[pallet::call_index(1)]
|
||||
#[pallet::weight((*weight, call.get_dispatch_info().class))]
|
||||
pub fn sudo_unchecked_weight(
|
||||
origin: OriginFor<T>,
|
||||
call: Box<<T as Config>::RuntimeCall>,
|
||||
weight: Weight,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
Self::ensure_sudo(origin)?;
|
||||
let _ = weight;
|
||||
|
||||
let res = call.dispatch_bypass_filter(RawOrigin::Root.into());
|
||||
Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
|
||||
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
#[pallet::call_index(2)]
|
||||
#[pallet::weight(T::WeightInfo::set_key())]
|
||||
pub fn set_key(
|
||||
origin: OriginFor<T>,
|
||||
new: AccountIdLookupOf<T>,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
Self::ensure_sudo(origin)?;
|
||||
|
||||
let new = T::Lookup::lookup(new)?;
|
||||
Self::deposit_event(Event::KeyChanged { old: Key::<T>::get(), new: new.clone() });
|
||||
Key::<T>::put(new);
|
||||
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
#[pallet::call_index(3)]
|
||||
#[pallet::weight({
|
||||
let dispatch_info = call.get_dispatch_info();
|
||||
(
|
||||
T::WeightInfo::sudo_as().saturating_add(dispatch_info.weight),
|
||||
dispatch_info.class,
|
||||
)
|
||||
})]
|
||||
pub fn sudo_as(
|
||||
origin: OriginFor<T>,
|
||||
who: AccountIdLookupOf<T>,
|
||||
call: Box<<T as Config>::RuntimeCall>,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
Self::ensure_sudo(origin)?;
|
||||
|
||||
let who = T::Lookup::lookup(who)?;
|
||||
let res = call.dispatch_bypass_filter(RawOrigin::Signed(who).into());
|
||||
Self::deposit_event(Event::SudoAsDone {
|
||||
sudo_result: res.map(|_| ()).map_err(|e| e.error),
|
||||
});
|
||||
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
|
||||
#[pallet::call_index(4)]
|
||||
#[pallet::weight(T::WeightInfo::remove_key())]
|
||||
pub fn remove_key(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
|
||||
Self::ensure_sudo(origin)?;
|
||||
|
||||
Self::deposit_event(Event::KeyRemoved {});
|
||||
Key::<T>::kill();
|
||||
|
||||
Ok(Pays::No.into())
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::event]
|
||||
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
||||
pub enum Event<T: Config> {
|
||||
Sudid {
|
||||
sudo_result: DispatchResult,
|
||||
},
|
||||
KeyChanged {
|
||||
old: Option<T::AccountId>,
|
||||
new: T::AccountId,
|
||||
},
|
||||
KeyRemoved,
|
||||
SudoAsDone { sudo_result: DispatchResult },
|
||||
}
|
||||
|
||||
#[pallet::error]
|
||||
pub enum Error<T> {
|
||||
RequireSudo,
|
||||
}
|
||||
|
||||
#[pallet::storage]
|
||||
pub(super) type Key<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
|
||||
|
||||
#[pallet::genesis_config]
|
||||
#[derive(frame_support::DefaultNoBound)]
|
||||
pub struct GenesisConfig<T: Config> {
|
||||
pub key: Option<T::AccountId>,
|
||||
}
|
||||
|
||||
#[pallet::genesis_build]
|
||||
impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
|
||||
fn build(&self) {
|
||||
Key::<T>::set(self.key.clone());
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Config> Pallet<T> {
|
||||
pub(crate) fn ensure_sudo(origin: OriginFor<T>) -> DispatchResult {
|
||||
let sender = ensure_signed_or_root(origin)?;
|
||||
|
||||
if let Some(sender) = sender {
|
||||
if Key::<T>::get().map_or(false, |k| k == sender) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(Error::<T>::RequireSudo.into())
|
||||
}
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
use super::*;
|
||||
use crate as sudo;
|
||||
use frame_support::derive_impl;
|
||||
use sp_io;
|
||||
use sp_runtime::BuildStorage;
|
||||
|
||||
#[frame_support::pallet]
|
||||
pub mod logger {
|
||||
use frame_support::pallet_prelude::*;
|
||||
use frame_system::pallet_prelude::*;
|
||||
|
||||
#[pallet::config]
|
||||
pub trait Config: frame_system::Config {
|
||||
type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
|
||||
}
|
||||
|
||||
#[pallet::pallet]
|
||||
pub struct Pallet<T>(_);
|
||||
|
||||
#[pallet::call]
|
||||
impl<T: Config> Pallet<T> {
|
||||
#[pallet::call_index(0)]
|
||||
#[pallet::weight(*weight)]
|
||||
pub fn privileged_i32_log(
|
||||
origin: OriginFor<T>,
|
||||
i: i32,
|
||||
weight: Weight,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
ensure_root(origin)?;
|
||||
<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
|
||||
Self::deposit_event(Event::AppendI32 { value: i, weight });
|
||||
Ok(().into())
|
||||
}
|
||||
|
||||
#[pallet::call_index(1)]
|
||||
#[pallet::weight(*weight)]
|
||||
pub fn non_privileged_log(
|
||||
origin: OriginFor<T>,
|
||||
i: i32,
|
||||
weight: Weight,
|
||||
) -> DispatchResultWithPostInfo {
|
||||
let sender = ensure_signed(origin)?;
|
||||
<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
|
||||
<AccountLog<T>>::try_append(sender.clone()).map_err(|_| "could not append")?;
|
||||
Self::deposit_event(Event::AppendI32AndAccount { sender, value: i, weight });
|
||||
Ok(().into())
|
||||
}
|
||||
}
|
||||
|
||||
#[pallet::event]
|
||||
#[pallet::generate_deposit(pub(super) fn deposit_event)]
|
||||
pub enum Event<T: Config> {
|
||||
AppendI32 { value: i32, weight: Weight },
|
||||
AppendI32AndAccount { sender: T::AccountId, value: i32, weight: Weight },
|
||||
}
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn account_log)]
|
||||
pub(super) type AccountLog<T: Config> =
|
||||
StorageValue<_, BoundedVec<T::AccountId, ConstU32<1_000>>, ValueQuery>;
|
||||
|
||||
#[pallet::storage]
|
||||
#[pallet::getter(fn i32_log)]
|
||||
pub(super) type I32Log<T> = StorageValue<_, BoundedVec<i32, ConstU32<1_000>>, ValueQuery>;
|
||||
}
|
||||
|
||||
type Block = frame_system::mocking::MockBlock<Test>;
|
||||
|
||||
frame_support::construct_runtime!(
|
||||
pub enum Test
|
||||
{
|
||||
System: frame_system,
|
||||
Sudo: sudo,
|
||||
Logger: logger,
|
||||
}
|
||||
);
|
||||
|
||||
#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
|
||||
impl frame_system::Config for Test {
|
||||
type Block = Block;
|
||||
}
|
||||
|
||||
impl logger::Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
}
|
||||
|
||||
impl Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type WeightInfo = ();
|
||||
}
|
||||
|
||||
pub type SudoCall = sudo::Call<Test>;
|
||||
pub type LoggerCall = logger::Call<Test>;
|
||||
|
||||
pub fn new_test_ext(root_key: u64) -> sp_io::TestExternalities {
|
||||
let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
|
||||
sudo::GenesisConfig::<Test> { key: Some(root_key) }
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
let mut ext: sp_io::TestExternalities = t.into();
|
||||
ext.execute_with(|| System::set_block_number(1));
|
||||
ext
|
||||
}
|
||||
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
pub fn new_bench_ext() -> sp_io::TestExternalities {
|
||||
frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
|
||||
}
|
||||
@ -1,188 +0,0 @@
|
||||
use super::*;
|
||||
use frame_support::{assert_noop, assert_ok, weights::Weight};
|
||||
use mock::{
|
||||
new_test_ext, Logger, LoggerCall, RuntimeCall, RuntimeEvent as TestEvent, RuntimeOrigin, Sudo,
|
||||
SudoCall, System, Test,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn test_setup_works() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_eq!(Key::<Test>::get(), Some(1u64));
|
||||
assert!(Logger::i32_log().is_empty());
|
||||
assert!(Logger::account_log().is_empty());
|
||||
});
|
||||
}
|
||||
|
||||
#[docify::export]
|
||||
#[test]
|
||||
fn sudo_basics() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
|
||||
assert_eq!(Logger::i32_log(), vec![42i32]);
|
||||
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
}));
|
||||
assert_noop!(Sudo::sudo(RuntimeOrigin::signed(2), call), Error::<Test>::RequireSudo);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sudo_emits_events_correctly() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
|
||||
System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sudo_unchecked_weight_basics() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo_unchecked_weight(
|
||||
RuntimeOrigin::signed(1),
|
||||
call,
|
||||
Weight::from_parts(1_000, 0)
|
||||
));
|
||||
assert_eq!(Logger::i32_log(), vec![42i32]);
|
||||
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
}));
|
||||
assert_noop!(
|
||||
Sudo::sudo_unchecked_weight(
|
||||
RuntimeOrigin::signed(2),
|
||||
call,
|
||||
Weight::from_parts(1_000, 0)
|
||||
),
|
||||
Error::<Test>::RequireSudo,
|
||||
);
|
||||
assert_eq!(Logger::i32_log(), vec![42i32]);
|
||||
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
let sudo_unchecked_weight_call =
|
||||
SudoCall::sudo_unchecked_weight { call, weight: Weight::from_parts(1_000, 0) };
|
||||
let info = sudo_unchecked_weight_call.get_dispatch_info();
|
||||
assert_eq!(info.weight, Weight::from_parts(1_000, 0));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sudo_unchecked_weight_emits_events_correctly() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo_unchecked_weight(
|
||||
RuntimeOrigin::signed(1),
|
||||
call,
|
||||
Weight::from_parts(1_000, 0)
|
||||
));
|
||||
System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
|
||||
})
|
||||
}
|
||||
|
||||
#[docify::export]
|
||||
#[test]
|
||||
fn set_key_basics() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
|
||||
assert_eq!(Key::<Test>::get(), Some(2u64));
|
||||
});
|
||||
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_noop!(Sudo::set_key(RuntimeOrigin::signed(2), 3), Error::<Test>::RequireSudo);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_key_emits_events_correctly() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
|
||||
System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old: Some(1), new: 2 }));
|
||||
assert_ok!(Sudo::set_key(RuntimeOrigin::signed(2), 4));
|
||||
System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old: Some(2), new: 4 }));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_key_works() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_ok!(Sudo::remove_key(RuntimeOrigin::signed(1)));
|
||||
assert!(Key::<Test>::get().is_none());
|
||||
System::assert_has_event(TestEvent::Sudo(Event::KeyRemoved {}));
|
||||
|
||||
assert_noop!(Sudo::remove_key(RuntimeOrigin::signed(1)), Error::<Test>::RequireSudo);
|
||||
assert_noop!(Sudo::set_key(RuntimeOrigin::signed(1), 1), Error::<Test>::RequireSudo);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn using_root_origin_works() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
assert_ok!(Sudo::remove_key(RuntimeOrigin::root()));
|
||||
assert!(Key::<Test>::get().is_none());
|
||||
System::assert_has_event(TestEvent::Sudo(Event::KeyRemoved {}));
|
||||
|
||||
assert_ok!(Sudo::set_key(RuntimeOrigin::root(), 1));
|
||||
assert_eq!(Some(1), Key::<Test>::get());
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sudo_as_basics() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1_000, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
|
||||
assert!(Logger::i32_log().is_empty());
|
||||
assert!(Logger::account_log().is_empty());
|
||||
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
assert_noop!(Sudo::sudo_as(RuntimeOrigin::signed(3), 2, call), Error::<Test>::RequireSudo);
|
||||
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
|
||||
assert_eq!(Logger::i32_log(), vec![42i32]);
|
||||
assert_eq!(Logger::account_log(), vec![2]);
|
||||
});
|
||||
}
|
||||
|
||||
#[docify::export]
|
||||
#[test]
|
||||
fn sudo_as_emits_events_correctly() {
|
||||
new_test_ext(1).execute_with(|| {
|
||||
let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
|
||||
i: 42,
|
||||
weight: Weight::from_parts(1, 0),
|
||||
}));
|
||||
assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
|
||||
System::assert_has_event(TestEvent::Sudo(Event::SudoAsDone { sudo_result: Ok(()) }));
|
||||
});
|
||||
}
|
||||
@ -1,156 +0,0 @@
|
||||
// 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_sudo`
|
||||
//!
|
||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
|
||||
//! DATE: 2025-07-28, 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-sudo
|
||||
// --extrinsic=*
|
||||
// --wasm-execution=compiled
|
||||
// --heap-pages=4096
|
||||
// --header=./file_header.txt
|
||||
// --output=./runtime/casper/src/weights/ghost_sudo.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 `pallet_sudo`.
|
||||
pub trait WeightInfo {
|
||||
fn set_key() -> Weight;
|
||||
fn sudo() -> Weight;
|
||||
fn sudo_as() -> Weight;
|
||||
fn remove_key() -> Weight;
|
||||
}
|
||||
|
||||
/// Weight functions for `ghost_sudo`.
|
||||
pub struct SubstrateWeight<T>(PhantomData<T>);
|
||||
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn set_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 40_014_000 picoseconds.
|
||||
Weight::from_parts(40_856_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
.saturating_add(T::DbWeight::get().writes(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_086_000 picoseconds.
|
||||
Weight::from_parts(45_920_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo_as() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_106_000 picoseconds.
|
||||
Weight::from_parts(44_650_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn remove_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 36_416_000 picoseconds.
|
||||
Weight::from_parts(37_373_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
.saturating_add(T::DbWeight::get().writes(1))
|
||||
}
|
||||
}
|
||||
|
||||
// For backwards compatibility and tests.
|
||||
impl WeightInfo for () {
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn set_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 40_014_000 picoseconds.
|
||||
Weight::from_parts(40_856_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(RocksDbWeight::get().reads(1))
|
||||
.saturating_add(RocksDbWeight::get().writes(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_086_000 picoseconds.
|
||||
Weight::from_parts(45_920_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(RocksDbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo_as() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_106_000 picoseconds.
|
||||
Weight::from_parts(44_650_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(RocksDbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn remove_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 36_416_000 picoseconds.
|
||||
Weight::from_parts(37_373_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(RocksDbWeight::get().reads(1))
|
||||
.saturating_add(RocksDbWeight::get().writes(1))
|
||||
}
|
||||
}
|
||||
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "ghost-traits"
|
||||
version = "0.3.23"
|
||||
version = "0.3.22"
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
edition.workspace = true
|
||||
|
||||
@ -1,7 +1,10 @@
|
||||
use frame_support::{pallet_prelude::*, storage::PrefixIterator};
|
||||
use frame_support::{
|
||||
pallet_prelude::*,
|
||||
storage::PrefixIterator,
|
||||
};
|
||||
use sp_runtime::{
|
||||
traits::{AtLeast32BitUnsigned, Member},
|
||||
DispatchResult,
|
||||
traits::{AtLeast32BitUnsigned, Member},
|
||||
};
|
||||
|
||||
pub trait NetworkDataBasicHandler {
|
||||
@ -25,14 +28,8 @@ pub trait NetworkDataMutateHandler<Network, Balance>: NetworkDataInspectHandler<
|
||||
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, ()>;
|
||||
fn decrease_gatekeeper_amount(
|
||||
chain_id: &Self::NetworkId,
|
||||
amount: &Balance,
|
||||
) -> Result<Balance, ()>;
|
||||
fn increase_gatekeeper_amount(chain_id: &Self::NetworkId, amount: &Balance) -> Result<Balance, ()>;
|
||||
fn decrease_gatekeeper_amount(chain_id: &Self::NetworkId, amount: &Balance) -> Result<Balance, ()>;
|
||||
|
||||
fn accumulate_outgoing_imbalance(amount: &Balance) -> Result<Balance, ()>;
|
||||
fn accumulate_incoming_imbalance(amount: &Balance) -> Result<Balance, ()>;
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "casper-runtime"
|
||||
version = "3.5.27"
|
||||
version = "3.5.25"
|
||||
build = "build.rs"
|
||||
description = "Runtime of the Casper Network"
|
||||
edition.workspace = true
|
||||
@ -87,7 +87,6 @@ pallet-whitelist = { workspace = true }
|
||||
ghost-networks = { workspace = true }
|
||||
ghost-claims = { workspace = true }
|
||||
ghost-slow-clap = { workspace = true }
|
||||
ghost-sudo = { workspace = true }
|
||||
casper-runtime-constants = { workspace = true }
|
||||
runtime-common = { workspace = true }
|
||||
primitives = { workspace = true }
|
||||
@ -206,7 +205,6 @@ std = [
|
||||
"ghost-networks/std",
|
||||
"ghost-claims/std",
|
||||
"ghost-slow-clap/std",
|
||||
"ghost-sudo/std",
|
||||
"casper-runtime-constants/std",
|
||||
"runtime-common/std",
|
||||
"primitives/std",
|
||||
@ -254,7 +252,6 @@ runtime-benchmarks = [
|
||||
"ghost-networks/runtime-benchmarks",
|
||||
"ghost-claims/runtime-benchmarks",
|
||||
"ghost-slow-clap/runtime-benchmarks",
|
||||
"ghost-sudo/runtime-benchmarks",
|
||||
"runtime-common/runtime-benchmarks",
|
||||
]
|
||||
try-runtime = [
|
||||
@ -300,6 +297,5 @@ try-runtime = [
|
||||
"ghost-networks/try-runtime",
|
||||
"ghost-claims/try-runtime",
|
||||
"ghost-slow-clap/try-runtime",
|
||||
"ghost-sudo/try-runtime",
|
||||
"runtime-common/try-runtime",
|
||||
]
|
||||
|
||||
@ -28,6 +28,3 @@ std = [
|
||||
"sp-runtime/std",
|
||||
"sp-weights/std",
|
||||
]
|
||||
|
||||
# Set timing constants (e.g session period) to faster versions to speed up testing.
|
||||
fast-runtime = []
|
||||
|
||||
@ -1105,12 +1105,6 @@ impl ghost_slow_clap::Config for Runtime {
|
||||
type WeightInfo = weights::ghost_slow_clap::WeightInfo<Runtime>;
|
||||
}
|
||||
|
||||
impl ghost_sudo::Config for Runtime {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type WeightInfo = weights::ghost_sudo::WeightInfo<Runtime>;
|
||||
}
|
||||
|
||||
construct_runtime! {
|
||||
pub enum Runtime
|
||||
{
|
||||
@ -1138,7 +1132,6 @@ construct_runtime! {
|
||||
Session: pallet_session = 9,
|
||||
Grandpa: pallet_grandpa = 11,
|
||||
AuthorityDiscovery: pallet_authority_discovery = 12,
|
||||
GhostSudo: ghost_sudo = 13,
|
||||
|
||||
// Governance stuff.
|
||||
Treasury: pallet_treasury = 19,
|
||||
@ -1267,7 +1260,6 @@ mod benches {
|
||||
[ghost_networks, GhostNetworks]
|
||||
[ghost_claims, GhostClaims]
|
||||
[ghost_slow_clap, GhostSlowClaps]
|
||||
[ghost_sudo, GhostSudo]
|
||||
);
|
||||
}
|
||||
|
||||
@ -1574,7 +1566,6 @@ sp_api::impl_runtime_apis! {
|
||||
(list, storage_info)
|
||||
}
|
||||
|
||||
#[allow(non_local_definitions)]
|
||||
fn dispatch_benchmark(
|
||||
config: frame_benchmarking::BenchmarkConfig,
|
||||
) -> Result<
|
||||
|
||||
@ -1,95 +0,0 @@
|
||||
// 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_sudo`
|
||||
//!
|
||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
|
||||
//! DATE: 2025-07-28, 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-sudo
|
||||
// --extrinsic=*
|
||||
// --wasm-execution=compiled
|
||||
// --heap-pages=4096
|
||||
// --header=./file_header.txt
|
||||
// --output=./runtime/casper/src/weights/ghost_sudo.rs
|
||||
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)]
|
||||
#![allow(unused_parens)]
|
||||
#![allow(unused_imports)]
|
||||
#![allow(missing_docs)]
|
||||
|
||||
use frame_support::{traits::Get, weights::Weight};
|
||||
use core::marker::PhantomData;
|
||||
|
||||
/// Weight functions for `ghost_sudo`.
|
||||
pub struct WeightInfo<T>(PhantomData<T>);
|
||||
impl<T: frame_system::Config> ghost_sudo::WeightInfo for WeightInfo<T> {
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn set_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 40_014_000 picoseconds.
|
||||
Weight::from_parts(40_856_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
.saturating_add(T::DbWeight::get().writes(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_086_000 picoseconds.
|
||||
Weight::from_parts(45_920_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:0)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn sudo_as() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 44_106_000 picoseconds.
|
||||
Weight::from_parts(44_650_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
}
|
||||
/// Storage: `GhostSudo::Key` (r:1 w:1)
|
||||
/// Proof: `GhostSudo::Key` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`)
|
||||
fn remove_key() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `165`
|
||||
// Estimated: `1517`
|
||||
// Minimum execution time: 36_416_000 picoseconds.
|
||||
Weight::from_parts(37_373_000, 0)
|
||||
.saturating_add(Weight::from_parts(0, 1517))
|
||||
.saturating_add(T::DbWeight::get().reads(1))
|
||||
.saturating_add(T::DbWeight::get().writes(1))
|
||||
}
|
||||
}
|
||||
@ -3,7 +3,6 @@ pub mod frame_system;
|
||||
pub mod ghost_claims;
|
||||
pub mod ghost_networks;
|
||||
pub mod ghost_slow_clap;
|
||||
pub mod ghost_sudo;
|
||||
pub mod pallet_alliance;
|
||||
pub mod pallet_bags_list;
|
||||
pub mod pallet_balances;
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
set -Ee
|
||||
|
||||
HARD_RESET=false
|
||||
CHECK_KEYS=false
|
||||
INSERT_KEYS=false
|
||||
UNIT_FILE=false
|
||||
@ -97,7 +96,6 @@ help() {
|
||||
echo -e "-s, --base-path\n\tPath to the folder with chain database ('/var/lib/ghost' is default)."
|
||||
echo -e "-c, --specification-path\n\tPath to specification ('/etc/ghost' is default)."
|
||||
echo -e "-n, --specification-name\n\tSpecification name to be used ('casper' is default)."
|
||||
echo -e "--hard-reset-i-know-what-im-doing\n\tWill completely remove ledger along with associated session keys."
|
||||
echo -e "-h, --help\n\tPrints help information."
|
||||
}
|
||||
|
||||
@ -165,9 +163,6 @@ while [ $# -gt 0 ]; do
|
||||
if [[ "$1" != *=* ]]; then shift; fi
|
||||
SPECIFICATION_NAME="${1#*=}"
|
||||
;;
|
||||
--hard-reset-i-know-what-im-doing)
|
||||
HARD_RESET=true
|
||||
;;
|
||||
--help|-h)
|
||||
help
|
||||
exit 0
|
||||
@ -180,60 +175,6 @@ while [ $# -gt 0 ]; do
|
||||
shift
|
||||
done
|
||||
|
||||
if [[ $HARD_RESET = true ]]; then
|
||||
echo -e "\n"
|
||||
echo "WARNING!!! THIS ACTION WILL COMPLETELY PURGE THE LEDGER AND REBUILD THE NODE USING THE LATEST"
|
||||
echo "REPOSITORY VERSION. NOTE THAT THE VALIDATION PROCESS WILL BE LOST BECAUSE SESSION OF KEYS."
|
||||
echo "THERE ARE TWO SCENARIOS IN WHICH YOU MIGHT NEED TO PROCEED:"
|
||||
echo -e "\t- A new version of the network hsa been released, and a restart is neccessary"
|
||||
echo -e "\t- There is a critical issue, and you require a hard reset of the node in a single command"
|
||||
echo -e "\n"
|
||||
if prompt "[?] do you understand all risks?"; then
|
||||
echo "[+] you were warned, I hope you know what you're doing"
|
||||
else
|
||||
echo "[-] aborting hard reset"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
cd $PROJECT_FOLDER
|
||||
# TODO: uncomment later
|
||||
# echo "[+] fetching the latest ghost-node source code"
|
||||
# git switch main
|
||||
# git pull origin main
|
||||
|
||||
# rustc version control, this works fine
|
||||
# cargo --version | cut -d'.' -f2, if higher then do
|
||||
# rustup default 1.83.0
|
||||
# rustup target add wasm32-unknown-unknown --toolchain 1.83.0-x86_64-unknown-linux-gnu
|
||||
# rustup component add rust-src --toolchain 1.83.0-x86_64-unknown-linux-gnu
|
||||
#
|
||||
# I think we need to do clean before recompilation
|
||||
# cargo clean
|
||||
|
||||
cd $PROJECT_FOLDER
|
||||
echo "[+] starting build in 3 seconds..."
|
||||
sleep 3
|
||||
cargo build $RELEASE $FEATURES
|
||||
|
||||
echo "[+] trying to stop current ghost-node"
|
||||
sudo systemctl stop ghost-node
|
||||
echo "[+] trying to remove locally stored ledger"
|
||||
sudo rm -rf "$BASE_PATH/chains/*"
|
||||
|
||||
cd $PROJECT_FOLDER
|
||||
echo "[+] trying to copy executable to '$EXECUTABLE_PATH'"
|
||||
sudo cp target/$TARGET/ghost $EXECUTABLE_PATH
|
||||
cp service/chain-specs/$SPECIFICATION_NAME.json $SPECIFICATION_PATH
|
||||
|
||||
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
|
||||
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if [[ $SET_ENVIRONMENT = true ]]; then
|
||||
echo -e "\n"
|
||||
echo "WARNING!!! THIS IS HIGHLY EXPERIMENTAL FLAG, USE IT ONLY ON YOUR"
|
||||
@ -321,7 +262,7 @@ fi
|
||||
if [[ ! -z $RELEASE ]]; then
|
||||
if prompt "[?] 'cargo build $RELEASE $FEATURES' is what you want?"; then
|
||||
cd $PROJECT_FOLDER
|
||||
echo "[+] starting build in 3 seconds..."
|
||||
echo "[+] Starting build in 3 seconds..."
|
||||
sleep 3
|
||||
cargo build $RELEASE $FEATURES
|
||||
fi
|
||||
@ -406,6 +347,7 @@ if [[ $ARGUMENTS = true ]]; then
|
||||
CLI_ARGS+=("--public-addr=$public_addr")
|
||||
fi
|
||||
|
||||
|
||||
# default for now
|
||||
CLI_ARGS+=("--telemetry-url='wss://telemetry.ghostchain.io/submit/ 9'")
|
||||
CLI_ARGS+=("--base-path=$BASE_PATH")
|
||||
|
||||
@ -176,11 +176,9 @@ fn casper_testnet_evm_networks() -> Vec<(u32, Vec<u8>)> {
|
||||
vec![
|
||||
(1, ghost_networks::NetworkData {
|
||||
chain_name: "ethereum-mainnet".into(),
|
||||
default_endpoint: vec![
|
||||
"https://nd-422-757-666.p2pify.com/0a9d79d93fb2f4a4b1e04695da2b77a7/".into(),
|
||||
],
|
||||
default_endpoint: "https://nd-422-757-666.p2pify.com/0a9d79d93fb2f4a4b1e04695da2b77a7/".into(),
|
||||
finality_delay: 40u64,
|
||||
rate_limit_delay: 1_000u64,
|
||||
rate_limit_delay: 1u64,
|
||||
block_distance: 50u64,
|
||||
network_type: ghost_networks::NetworkType::Evm,
|
||||
gatekeeper: "0x4d224452801aced8b2f0aebe155379bb5d594381".into(),
|
||||
@ -190,11 +188,9 @@ fn casper_testnet_evm_networks() -> Vec<(u32, Vec<u8>)> {
|
||||
}.encode()),
|
||||
(56, ghost_networks::NetworkData {
|
||||
chain_name: "bnb-mainnet".into(),
|
||||
default_endpoint: vec![
|
||||
"https://bsc-mainnet.core.chainstack.com/35848e183f3e3303c8cfeacbea831cab/".into(),
|
||||
],
|
||||
default_endpoint: "https://bsc-mainnet.core.chainstack.com/35848e183f3e3303c8cfeacbea831cab/".into(),
|
||||
finality_delay: 20u64,
|
||||
rate_limit_delay: 1_000u64,
|
||||
rate_limit_delay: 1u64,
|
||||
block_distance: 50u64,
|
||||
network_type: ghost_networks::NetworkType::Evm,
|
||||
gatekeeper: "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82".into(),
|
||||
@ -276,11 +272,6 @@ pub fn testnet_config_genesis(
|
||||
"babe": {
|
||||
"epochConfig": Some(casper::BABE_GENESIS_EPOCH_CONFIG),
|
||||
},
|
||||
"ghostSudo": {
|
||||
"key": endowed_accounts
|
||||
.first()
|
||||
.cloned(),
|
||||
},
|
||||
"ghostNetworks": {
|
||||
"networks": evm_networks,
|
||||
},
|
||||
@ -718,11 +709,6 @@ fn casper_staging_config_genesis() -> serde_json::Value {
|
||||
"babe": {
|
||||
"epochConfig": Some(casper::BABE_GENESIS_EPOCH_CONFIG),
|
||||
},
|
||||
"ghostSudo": {
|
||||
"key": endowed_accounts
|
||||
.first()
|
||||
.cloned(),
|
||||
},
|
||||
"ghostNetworks": {
|
||||
"networks": evm_networks,
|
||||
},
|
||||
|
||||
Loading…
Reference in New Issue
Block a user