pezkuwichain
b6d35f6faf
Updated 4763 files with dual copyright: - Parity Technologies (UK) Ltd. - Dijital Kurdistan Tech Institute
140 lines
5.1 KiB
Rust
140 lines
5.1 KiB
Rust
// Copyright (C) Parity Technologies (UK) Ltd. and Dijital Kurdistan Tech Institute
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
extern crate alloc;
|
|
|
|
pub mod impls;
|
|
pub mod message_queue;
|
|
pub mod pay;
|
|
pub mod xcm_config;
|
|
pub use constants::*;
|
|
pub use opaque::*;
|
|
pub use types::*;
|
|
|
|
/// Common types of teyrchains.
|
|
mod types {
|
|
use pezsp_runtime::traits::{IdentifyAccount, Verify};
|
|
|
|
/// An index to a block.
|
|
pub type BlockNumber = u32;
|
|
|
|
/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
|
|
pub type Signature = pezsp_runtime::MultiSignature;
|
|
|
|
/// Some way of identifying an account on the chain. We intentionally make it equivalent
|
|
/// to the public key of our transaction signing scheme.
|
|
pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
|
|
|
|
/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
|
|
/// never know...
|
|
pub type AccountIndex = u32;
|
|
|
|
/// Balance of an account.
|
|
pub type Balance = u128;
|
|
|
|
/// Index of a transaction in the chain.
|
|
pub type Nonce = u32;
|
|
|
|
/// A hash of some data used by the chain.
|
|
pub type Hash = pezsp_core::H256;
|
|
|
|
/// Digest item type.
|
|
pub type DigestItem = pezsp_runtime::generic::DigestItem;
|
|
|
|
// Aura consensus authority.
|
|
pub type AuraId = pezsp_consensus_aura::sr25519::AuthorityId;
|
|
|
|
// Aura consensus authority used by Asset Hub Pezkuwi.
|
|
//
|
|
// Because of registering the authorities with an ed25519 key before switching from Shell
|
|
// to Asset Hub Pezkuwi, we were required to deploy a hotfix that changed Asset Hub Pezkuwi's
|
|
// Aura keys to ed22519. In the future that may change again.
|
|
pub type AssetHubPezkuwiAuraId = pezsp_consensus_aura::ed25519::AuthorityId;
|
|
|
|
// Id used for identifying assets.
|
|
pub type AssetIdForTrustBackedAssets = u32;
|
|
|
|
// Id used for identifying non-fungible collections.
|
|
pub type CollectionId = u32;
|
|
|
|
// Id used for identifying non-fungible items.
|
|
pub type ItemId = u32;
|
|
}
|
|
|
|
/// Common constants of teyrchains.
|
|
mod constants {
|
|
use super::types::BlockNumber;
|
|
use pezframe_support::{
|
|
weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},
|
|
PalletId,
|
|
};
|
|
use pezsp_runtime::Perbill;
|
|
|
|
/// This determines the average expected block time that we are targeting. Blocks will be
|
|
/// produced at a minimum duration defined by `SLOT_DURATION`. `SLOT_DURATION` is picked up by
|
|
/// `pezpallet_timestamp` which is in turn picked up by `pezpallet_aura` to implement `fn
|
|
/// slot_duration()`.
|
|
///
|
|
/// Change this to adjust the block time.
|
|
pub const MILLISECS_PER_BLOCK: u64 = 12000;
|
|
pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
|
|
|
|
// Time is measured by number of blocks.
|
|
pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
|
|
pub const HOURS: BlockNumber = MINUTES * 60;
|
|
pub const DAYS: BlockNumber = HOURS * 24;
|
|
|
|
/// We assume that ~5% of the block weight is consumed by `on_initialize` handlers. This is
|
|
/// used to limit the maximal weight of a single extrinsic.
|
|
pub const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(5);
|
|
/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used by
|
|
/// Operational extrinsics.
|
|
pub const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
|
|
|
|
/// We allow for 0.5 seconds of compute with a 6 second average block time.
|
|
pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(
|
|
WEIGHT_REF_TIME_PER_SECOND.saturating_div(2),
|
|
pezkuwi_primitives::MAX_POV_SIZE as u64,
|
|
);
|
|
|
|
/// We allow for 2 seconds of compute with a 6 second average block.
|
|
pub const MAXIMUM_BLOCK_WEIGHT_FOR_ASYNC_BACKING: Weight = Weight::from_parts(
|
|
WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2),
|
|
pezkuwi_primitives::MAX_POV_SIZE as u64,
|
|
);
|
|
|
|
/// Treasury pezpallet id of the local chain, used to convert into AccountId
|
|
pub const TREASURY_PALLET_ID: PalletId = PalletId(*b"py/trsry");
|
|
}
|
|
|
|
/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
|
|
/// the specifics of the runtime. They can then be made to be agnostic over specific formats
|
|
/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
|
|
/// to even the core data structures.
|
|
pub mod opaque {
|
|
use super::*;
|
|
use pezsp_runtime::{generic, traits::BlakeTwo256};
|
|
|
|
pub use pezsp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
|
|
/// Opaque block header type.
|
|
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
|
|
/// Opaque block type.
|
|
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
|
|
/// Opaque block identifier type.
|
|
pub type BlockId = generic::BlockId<Block>;
|
|
}
|