Runtime lib restructure (#202)

* impl apis exported

* runtime version test moved to constants

* constants exported

* constant related errors fixed

* pallet configs exported

* xmc_config moved to configs

* types extracted

generic-template/runtime/src/constants.rs

@@ -1,5 +1,11 @@
+use frame_support::weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight};
+use sp_runtime::{create_runtime_str, Perbill};
+use sp_version::RuntimeVersion;
+
+use crate::{apis, types::BlockNumber};
+
 pub mod currency {
-    use crate::Balance;
+    use crate::types::Balance;
 
     pub const MICROCENTS: Balance = 1_000_000;
     pub const MILLICENTS: Balance = 1_000_000_000;
@@ -13,3 +19,70 @@ pub mod currency {
         items as Balance * 15 * CENTS + (bytes as Balance) * 6 * CENTS
     }
 }
+
+pub const P_FACTOR: u128 = 10;
+pub const Q_FACTOR: u128 = 100;
+pub const POLY_DEGREE: u8 = 1;
+
+#[sp_version::runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+    spec_name: create_runtime_str!("template-parachain"),
+    impl_name: create_runtime_str!("template-parachain"),
+    authoring_version: 1,
+    spec_version: 1,
+    impl_version: 0,
+    apis: apis::RUNTIME_API_VERSIONS,
+    transaction_version: 1,
+    state_version: 1,
+};
+
+/// 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 `pallet_timestamp` which is in turn picked
+/// up by `pallet_aura` to implement `fn slot_duration()`.
+///
+/// Change this to adjust the block time.
+#[cfg(feature = "async-backing")]
+pub const MILLISECS_PER_BLOCK: u64 = 6000;
+#[cfg(not(feature = "async-backing"))]
+pub const MILLISECS_PER_BLOCK: u64 = 12000;
+
+// NOTE: Currently it is not possible to change the slot duration after the
+// chain has started. Attempting to do so will brick block production.
+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 of a second of compute with a 12 second average block time.
+pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(
+    #[cfg(feature = "async-backing")]
+    WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2),
+    #[cfg(not(feature = "async-backing"))]
+    WEIGHT_REF_TIME_PER_SECOND.saturating_div(2),
+    cumulus_primitives_core::relay_chain::MAX_POV_SIZE as u64,
+);
+
+/// Maximum number of blocks simultaneously accepted by the Runtime, not yet
+/// included into the relay chain.
+#[cfg(feature = "async-backing")]
+pub const UNINCLUDED_SEGMENT_CAPACITY: u32 = 3;
+#[cfg(not(feature = "async-backing"))]
+pub const UNINCLUDED_SEGMENT_CAPACITY: u32 = 1;
+/// How many parachain blocks are processed by the relay chain per parent.
+/// Limits the number of blocks authored per slot.
+pub const BLOCK_PROCESSING_VELOCITY: u32 = 1;
+/// Relay chain slot duration, in milliseconds.
+pub const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000;
+/// Maximum length for a block.
+pub const MAX_BLOCK_LENGTH: u32 = 5 * 1024 * 1024;