subspace_runtime_primitives/
lib.rs

1//! Runtime primitives for Subspace Network.
2#![feature(let_chains)]
3#![cfg_attr(not(feature = "std"), no_std)]
4
5pub mod extension;
6pub mod utility;
7pub mod weights;
8
9#[cfg(not(feature = "std"))]
10extern crate alloc;
11
12use crate::time::{BLOCKS_IN_A_DAY, BLOCKS_IN_AN_MINUTE};
13#[cfg(not(feature = "std"))]
14use alloc::vec::Vec;
15use core::marker::PhantomData;
16use frame_support::dispatch::DispatchResult;
17use frame_support::pallet_prelude::Weight;
18use frame_support::traits::tokens;
19use frame_support::weights::WeightToFee;
20use frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND;
21use frame_support::{Deserialize, Serialize};
22use frame_system::limits::BlockLength;
23use frame_system::offchain::CreateTransactionBase;
24use frame_system::pallet_prelude::BlockNumberFor;
25use pallet_transaction_payment::{
26    Multiplier, NextFeeMultiplier, OnChargeTransaction, TargetedFeeAdjustment,
27};
28use parity_scale_codec::{Codec, Decode, Encode, MaxEncodedLen};
29use scale_info::TypeInfo;
30use sp_core::parameter_types;
31use sp_runtime::traits::{Block as BlockT, Bounded, Header as HeaderT, IdentifyAccount, Verify};
32use sp_runtime::{FixedPointNumber, MultiSignature, Perbill, Perquintill};
33pub use subspace_core_primitives::BlockNumber;
34
35/// Minimum desired number of replicas of the blockchain to be stored by the network,
36/// impacts storage fees.
37pub const MIN_REPLICATION_FACTOR: u16 = 25;
38
39/// The smallest unit of the token is called Shannon.
40pub const SHANNON: Balance = 1;
41/// Subspace Credits have 18 decimal places.
42pub const DECIMAL_PLACES: u8 = 18;
43/// One Subspace Credit.
44pub const AI3: Balance = (10 * SHANNON).pow(DECIMAL_PLACES as u32);
45/// A ratio of `Normal` dispatch class within block, for `BlockWeight` and `BlockLength`.
46pub const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
47/// 1 in 6 slots (on average, not counting collisions) will have a block.
48/// Must match ratio between block and slot duration in constants above.
49pub const SLOT_PROBABILITY: (u64, u64) = (1, 6);
50/// The block weight for 2 seconds of compute
51pub const BLOCK_WEIGHT_FOR_2_SEC: Weight =
52    Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2), u64::MAX);
53
54/// Maximum block length for non-`Normal` extrinsic is 5 MiB.
55pub const MAX_BLOCK_LENGTH: u32 = 5 * 1024 * 1024;
56
57/// Pruning depth multiplier for state and blocks pruning.
58pub const DOMAINS_PRUNING_DEPTH_MULTIPLIER: u32 = 2;
59
60/// We allow for 3.75 MiB for `Normal` extrinsic with 5 MiB maximum block length.
61pub fn maximum_normal_block_length() -> BlockLength {
62    BlockLength::max_with_normal_ratio(MAX_BLOCK_LENGTH, NORMAL_DISPATCH_RATIO)
63}
64
65/// The maximum recursion depth we allow when parsing calls.
66/// This is a safety measure to avoid stack overflows.
67///
68/// Deeper nested calls can result in an error, or, if it is secure, the call is skipped.
69/// (Some code does unlimited heap-based recursion via `nested_utility_call_iter()`.)
70pub const MAX_CALL_RECURSION_DEPTH: u32 = 10;
71
72/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
73pub type Signature = MultiSignature;
74
75/// Some way of identifying an account on the chain. We intentionally make it equivalent
76/// to the public key of our transaction signing scheme.
77//
78// Note: sometimes this type alias causes complex trait ambiguity / conflicting implementation errors.
79// As a workaround, `use sp_runtime::AccountId32 as AccountId` instead.
80pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
81
82/// Balance of an account.
83pub type Balance = u128;
84
85/// Index of a transaction in the chain.
86pub type Nonce = u32;
87
88/// A hash of some data used by the chain.
89pub type Hash = sp_core::H256;
90
91/// Type used for expressing timestamp.
92pub type Moment = u64;
93
94/// Type alias for extrinsics.
95pub type ExtrinsicFor<Block> = <Block as BlockT>::Extrinsic;
96
97/// Type alias for block hash.
98pub type BlockHashFor<Block> = <Block as BlockT>::Hash;
99
100/// Type alias for block header.
101pub type HeaderFor<Block> = <Block as BlockT>::Header;
102
103/// Type alias for block hashing.
104pub type BlockHashingFor<Block> = <HeaderFor<Block> as HeaderT>::Hashing;
105
106parameter_types! {
107    /// Event segments are disabled on the consensus chain.
108    pub const ConsensusEventSegmentSize: u32 = 0;
109    /// Event segments are enabled on domain chains, this value was derived from benchmarking.
110    pub const DomainEventSegmentSize: u32 = 100;
111}
112
113/// Opaque types.
114///
115/// These are used by the CLI to instantiate machinery that don't need to know the specifics of the
116/// runtime. They can then be made to be agnostic over specific formats of data like extrinsics,
117/// allowing for them to continue syncing the network through upgrades to even the core data
118/// structures.
119pub mod opaque {
120    use super::BlockNumber;
121    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
122    use sp_runtime::generic;
123    use sp_runtime::traits::BlakeTwo256;
124
125    /// Opaque block header type.
126    pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
127    /// Opaque block type.
128    pub type Block = generic::Block<Header, UncheckedExtrinsic>;
129}
130
131pub mod time {
132    /// Expected block time in milliseconds.
133    ///
134    /// Since Subspace is probabilistic this is the average expected block time that
135    /// we are targeting. Blocks will be produced at a minimum duration defined
136    /// by `SLOT_DURATION`, but some slots will not be allocated to any
137    /// farmer and hence no block will be produced. We expect to have this
138    /// block time on average following the defined slot duration and the value
139    /// of `c` configured for Subspace (where `1 - c` represents the probability of
140    /// a slot being empty).
141    /// This value is only used indirectly to define the unit constants below
142    /// that are expressed in blocks. The rest of the code should use
143    /// `SLOT_DURATION` instead (like the Timestamp pallet for calculating the
144    /// minimum period).
145    ///
146    /// Based on:
147    /// <https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html#-6.-practical-results>
148    pub const MILLISECS_PER_BLOCK: u64 = 6000;
149    /// Approximate number of block in a minute.
150    pub const BLOCKS_IN_AN_MINUTE: u32 = (60 * 1000) / MILLISECS_PER_BLOCK as u32;
151    /// Approximate number of blocks in an hour.
152    pub const BLOCKS_IN_AN_HOUR: u32 = 60 * BLOCKS_IN_AN_MINUTE;
153    /// Approximate number of blocks in a day.
154    pub const BLOCKS_IN_A_DAY: u32 = 24 * BLOCKS_IN_AN_HOUR;
155}
156
157#[derive(Copy, Clone, Encode, Decode, TypeInfo, Serialize, Deserialize, MaxEncodedLen, Debug)]
158pub struct CouncilDemocracyConfigParams<BlockNumber> {
159    /// Council motion duration.
160    pub council_motion_duration: BlockNumber,
161    /// Democracy cooloff period.
162    pub democracy_cooloff_period: BlockNumber,
163    /// Democracy enactment period.
164    pub democracy_enactment_period: BlockNumber,
165    /// Fast track voting period.
166    pub democracy_fast_track_voting_period: BlockNumber,
167    /// Launch period.
168    pub democracy_launch_period: BlockNumber,
169    /// Vote locking period.
170    pub democracy_vote_locking_period: BlockNumber,
171    /// Voting period.
172    pub democracy_voting_period: BlockNumber,
173}
174
175impl<BlockNumber: From<u32>> Default for CouncilDemocracyConfigParams<BlockNumber> {
176    fn default() -> Self {
177        Self {
178            council_motion_duration: BLOCKS_IN_A_DAY.into(),
179            democracy_cooloff_period: BLOCKS_IN_A_DAY.into(),
180            democracy_enactment_period: BLOCKS_IN_A_DAY.into(),
181            democracy_fast_track_voting_period: (2 * BLOCKS_IN_A_DAY).into(),
182            democracy_launch_period: (2 * BLOCKS_IN_A_DAY).into(),
183            democracy_vote_locking_period: BLOCKS_IN_A_DAY.into(),
184            democracy_voting_period: BLOCKS_IN_A_DAY.into(),
185        }
186    }
187}
188
189impl<BlockNumber: From<u32>> CouncilDemocracyConfigParams<BlockNumber> {
190    /// Production params for Council democracy config.
191    pub fn production_params() -> Self {
192        Self::default()
193    }
194
195    /// Fast period params for Council democracy config.
196    pub fn fast_params() -> Self {
197        Self {
198            council_motion_duration: (15 * BLOCKS_IN_AN_MINUTE).into(),
199            democracy_cooloff_period: (5 * BLOCKS_IN_AN_MINUTE).into(),
200            democracy_enactment_period: (15 * BLOCKS_IN_AN_MINUTE).into(),
201            democracy_fast_track_voting_period: (5 * BLOCKS_IN_AN_MINUTE).into(),
202            democracy_launch_period: (15 * BLOCKS_IN_AN_MINUTE).into(),
203            democracy_vote_locking_period: BLOCKS_IN_AN_MINUTE.into(),
204            democracy_voting_period: (15 * BLOCKS_IN_AN_MINUTE).into(),
205        }
206    }
207}
208/// Config parameters for genesis.
209pub struct GenesisConfigParams {
210    /// Confirmation depth K
211    pub confirmation_depth_k: BlockNumber,
212    /// Domain pruning depth.
213    pub domain_block_pruning_depth: BlockNumber,
214    /// Staking withdrawal period.
215    pub staking_withdrawal_period: BlockNumber,
216}
217
218impl GenesisConfigParams {
219    /// Production specific domain parameters.
220    pub const fn production_params() -> Self {
221        Self {
222            confirmation_depth_k: 100u32,
223            domain_block_pruning_depth: 14_400u32,
224            staking_withdrawal_period: 14_400u32,
225        }
226    }
227
228    /// Development specific domain parameters.
229    pub const fn dev_params() -> Self {
230        Self {
231            confirmation_depth_k: 5u32,
232            domain_block_pruning_depth: 5u32,
233            staking_withdrawal_period: 5u32,
234        }
235    }
236}
237
238/// A trait for determining whether rewards are enabled or not
239pub trait RewardsEnabled {
240    /// Determine whether rewards are enabled or not
241    fn rewards_enabled() -> bool;
242}
243
244/// A trait for finding the address for a block reward based on the `PreRuntime` digests contained within it.
245pub trait FindBlockRewardAddress<RewardAddress> {
246    /// Find the address for a block rewards based on the pre-runtime digests.
247    fn find_block_reward_address() -> Option<RewardAddress>;
248}
249
250/// A trait for finding the addresses for voting reward based on transactions found in the block.
251pub trait FindVotingRewardAddresses<RewardAddress> {
252    /// Find the addresses for voting rewards based on transactions found in the block.
253    fn find_voting_reward_addresses() -> Vec<RewardAddress>;
254}
255
256pub trait StorageFee<Balance> {
257    /// Return the consensus transaction byte fee.
258    fn transaction_byte_fee() -> Balance;
259
260    /// Note the charged storage fee.
261    fn note_storage_fees(fee: Balance);
262}
263
264parameter_types! {
265    /// The portion of the `NORMAL_DISPATCH_RATIO` that we adjust the fees with. Blocks filled less
266    /// than this will decrease the weight and more will increase.
267    pub const TargetBlockFullness: Perquintill = Perquintill::from_percent(50);
268    /// The adjustment variable of the runtime. Higher values will cause `TargetBlockFullness` to
269    /// change the fees more rapidly.
270    pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(75, 1_000_000);
271    /// Minimum amount of the multiplier. This value cannot be too low. A test case should ensure
272    /// that combined with `AdjustmentVariable`, we can recover from the minimum.
273    /// See `multiplier_can_grow_from_zero`.
274    pub MinimumMultiplier: Multiplier = Multiplier::saturating_from_rational(1, 10u128);
275    /// The maximum amount of the multiplier.
276    pub MaximumMultiplier: Multiplier = Bounded::max_value();
277}
278
279/// Parameterized slow adjusting fee updated based on
280/// <https://research.web3.foundation/Polkadot/overview/token-economics#2-slow-adjusting-mechanism>
281pub type SlowAdjustingFeeUpdate<R, TargetBlockFullness> = TargetedFeeAdjustment<
282    R,
283    TargetBlockFullness,
284    AdjustmentVariable,
285    MinimumMultiplier,
286    MaximumMultiplier,
287>;
288
289#[derive(Encode, Decode, TypeInfo)]
290pub struct BlockTransactionByteFee<Balance: Codec> {
291    // The value of `transaction_byte_fee` for the current block
292    pub current: Balance,
293    // The value of `transaction_byte_fee` for the next block
294    pub next: Balance,
295}
296
297impl<Balance: Codec + tokens::Balance> Default for BlockTransactionByteFee<Balance> {
298    fn default() -> Self {
299        BlockTransactionByteFee {
300            current: Balance::max_value(),
301            next: Balance::max_value(),
302        }
303    }
304}
305
306parameter_types! {
307    pub const XdmFeeMultipler: u32 = 5;
308}
309
310/// Balance type pointing to the OnChargeTransaction trait.
311pub type OnChargeTransactionBalance<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as OnChargeTransaction<
312    T,
313>>::Balance;
314
315/// Adjusted XDM Weight to fee Conversion.
316pub struct XdmAdjustedWeightToFee<T>(PhantomData<T>);
317impl<T: pallet_transaction_payment::Config> WeightToFee for XdmAdjustedWeightToFee<T> {
318    type Balance = OnChargeTransactionBalance<T>;
319
320    fn weight_to_fee(weight: &Weight) -> Self::Balance {
321        // the adjustable part of the fee.
322        let unadjusted_weight_fee = pallet_transaction_payment::Pallet::<T>::weight_to_fee(*weight);
323        let multiplier = NextFeeMultiplier::<T>::get();
324        // final adjusted weight fee.
325        multiplier.saturating_mul_int(unadjusted_weight_fee)
326    }
327}
328
329#[derive(
330    PartialEq, Eq, Clone, Encode, Decode, TypeInfo, MaxEncodedLen, Ord, PartialOrd, Copy, Debug,
331)]
332pub enum HoldIdentifier {
333    DomainStaking,
334    DomainInstantiation,
335    DomainStorageFund,
336    MessengerChannel,
337    Preimage,
338}
339
340/// Interface for creating an unsigned general extrinsic
341pub trait CreateUnsigned<LocalCall>: CreateTransactionBase<LocalCall> {
342    /// Create an unsigned extrinsic.
343    fn create_unsigned(call: Self::RuntimeCall) -> Self::Extrinsic;
344}
345
346/// Callback to do something before setting code.
347pub trait OnSetCode<Number> {
348    /// Do something before setting code at the block number.
349    fn set_code(block_number: Number) -> DispatchResult;
350}
351
352/// Implements [frame_system::SetCode]
353pub struct SetCode<Runtime, OSC>(PhantomData<(Runtime, OSC)>);
354impl<Runtime, OSC> frame_system::SetCode<Runtime> for SetCode<Runtime, OSC>
355where
356    Runtime: frame_system::Config,
357    OSC: OnSetCode<BlockNumberFor<Runtime>>,
358{
359    fn set_code(code: Vec<u8>) -> DispatchResult {
360        let current_block_number = frame_system::Pallet::<Runtime>::block_number();
361        OSC::set_code(current_block_number)?;
362        frame_system::Pallet::<Runtime>::update_code_in_storage(&code);
363        Ok(())
364    }
365}
366
367#[cfg(feature = "testing")]
368pub mod tests_utils {
369    use frame_support::dispatch::DispatchClass;
370    use frame_support::weights::Weight;
371    use frame_system::limits::BlockWeights;
372    use pallet_transaction_payment::{Multiplier, MultiplierUpdate};
373    use sp_runtime::BuildStorage;
374    use sp_runtime::traits::{Convert, Get};
375    use std::marker::PhantomData;
376
377    pub struct FeeMultiplierUtils<Runtime, BlockWeightsGetter>(
378        PhantomData<(Runtime, BlockWeightsGetter)>,
379    );
380
381    impl<Runtime, BlockWeightsGetter> FeeMultiplierUtils<Runtime, BlockWeightsGetter>
382    where
383        Runtime: frame_system::Config + pallet_transaction_payment::Config,
384        BlockWeightsGetter: Get<BlockWeights>,
385    {
386        fn max_normal() -> Weight {
387            let block_weights = BlockWeightsGetter::get();
388            block_weights
389                .get(DispatchClass::Normal)
390                .max_total
391                .unwrap_or(block_weights.max_block)
392        }
393
394        fn min_multiplier() -> Multiplier {
395            <Runtime as pallet_transaction_payment::Config>::FeeMultiplierUpdate::min()
396        }
397
398        fn target() -> Weight {
399            <Runtime as pallet_transaction_payment::Config>::FeeMultiplierUpdate::target()
400                * Self::max_normal()
401        }
402
403        // update based on runtime impl.
404        fn runtime_multiplier_update(fm: Multiplier) -> Multiplier {
405            <Runtime as pallet_transaction_payment::Config>::FeeMultiplierUpdate::convert(fm)
406        }
407
408        fn run_with_system_weight<F>(w: Weight, assertions: F)
409        where
410            F: Fn(),
411        {
412            let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()
413                .build_storage()
414                .unwrap()
415                .into();
416            t.execute_with(|| {
417                frame_system::Pallet::<Runtime>::set_block_consumed_resources(w, 0);
418                assertions()
419            });
420        }
421
422        // The following function is taken from test with same name from
423        // https://github.com/paritytech/polkadot-sdk/blob/91851951856b8effe627fb1d151fe336a51eef2d/substrate/bin/node/runtime/src/impls.rs#L234
424        // with some small surface changes.
425        pub fn multiplier_can_grow_from_zero()
426        where
427            Runtime: pallet_transaction_payment::Config,
428            BlockWeightsGetter: Get<BlockWeights>,
429        {
430            // if the min is too small, then this will not change, and we are doomed forever.
431            // the block ref time is 1/100th bigger than target.
432            Self::run_with_system_weight(
433                Self::target().set_ref_time((Self::target().ref_time() / 100) * 101),
434                || {
435                    let next = Self::runtime_multiplier_update(Self::min_multiplier());
436                    assert!(
437                        next > Self::min_multiplier(),
438                        "{:?} !> {:?}",
439                        next,
440                        Self::min_multiplier()
441                    );
442                },
443            );
444
445            // the block proof size is 1/100th bigger than target.
446            Self::run_with_system_weight(
447                Self::target().set_proof_size((Self::target().proof_size() / 100) * 101),
448                || {
449                    let next = Self::runtime_multiplier_update(Self::min_multiplier());
450                    assert!(
451                        next > Self::min_multiplier(),
452                        "{:?} !> {:?}",
453                        next,
454                        Self::min_multiplier()
455                    );
456                },
457            )
458        }
459    }
460}
subspace_runtime_primitives/lib.rs

subspace_runtime_primitives/
lib.rs
