Add an initial Substrate instantiation

Consensus has been nuked for an AcceptAny currently routed throough PoW (when it doesn't have to be, doing so just took care of a few pieces of leg work). Updates AGPL handling.
2025-12-09 12:49:23 +00:00 · 2022-07-15 00:05:00 -04:00
parent 5ede5b9e8f
commit 0b879a53fa
22 changed files with 2094 additions and 658 deletions
--- a/substrate/runtime/src/lib.rs
+++ b/substrate/runtime/src/lib.rs
@@ -0,0 +1,379 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "256"]
+
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+use sp_api::impl_runtime_apis;
+use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
+use sp_runtime::{
+  create_runtime_str, generic, impl_opaque_keys,
+  traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, Verify},
+  transaction_validity::{TransactionSource, TransactionValidity},
+  ApplyExtrinsicResult, MultiSignature,
+  Perbill
+};
+use sp_std::prelude::*;
+#[cfg(feature = "std")]
+use sp_version::NativeVersion;
+use sp_version::RuntimeVersion;
+
+use frame_support::{
+  traits::{ConstU8, ConstU32, ConstU64},
+  weights::{constants::{RocksDbWeight, WEIGHT_PER_SECOND}, IdentityFee},
+  parameter_types, construct_runtime
+};
+pub use frame_system::Call as SystemCall;
+pub use pallet_timestamp::Call as TimestampCall;
+pub use pallet_balances::Call as BalancesCall;
+use pallet_transaction_payment::CurrencyAdapter;
+
+/// 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 = 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;
+
+/// Balance of an account
+pub type Balance = u64;
+
+/// Index of a transaction in the chain, for a given account
+pub type Index = u32;
+
+/// A hash of some data used by the chain
+pub type Hash = sp_core::H256;
+
+pub mod opaque {
+  use super::*;
+
+  pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
+
+  pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+  pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+  pub type BlockId = generic::BlockId<Block>;
+
+  impl_opaque_keys! {
+    pub struct SessionKeys {}
+  }
+}
+
+#[sp_version::runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+  spec_name: create_runtime_str!("serai"),
+  impl_name: create_runtime_str!("turoctocrab"),
+  authoring_version: 1,
+  spec_version: 100,
+  impl_version: 1,
+  apis: RUNTIME_API_VERSIONS,
+  transaction_version: 1,
+  state_version: 1
+};
+
+pub const MILLISECS_PER_BLOCK: u64 = 6000;
+pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
+
+/// Measured in blocks
+pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
+pub const HOURS: BlockNumber = MINUTES * 60;
+pub const DAYS: BlockNumber = HOURS * 24;
+
+#[cfg(feature = "std")]
+pub fn native_version() -> NativeVersion {
+  NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+}
+
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+
+parameter_types! {
+  pub const BlockHashCount: BlockNumber = 2400;
+  pub const Version: RuntimeVersion = VERSION;
+  /// Allow for 2 seconds of compute with a 6 second average block time
+  pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights
+    ::with_sensible_defaults(2 * WEIGHT_PER_SECOND, NORMAL_DISPATCH_RATIO);
+  pub BlockLength: frame_system::limits::BlockLength = frame_system::limits::BlockLength
+    ::max_with_normal_ratio(1024 * 1024, NORMAL_DISPATCH_RATIO);
+  pub const SS58Prefix: u8 = 42; // TODO: Remove
+}
+
+impl frame_system::Config for Runtime {
+  type BaseCallFilter = frame_support::traits::Everything;
+  type BlockWeights = BlockWeights;
+  type BlockLength = BlockLength;
+  type AccountId = AccountId;
+  type Call = Call;
+  type Lookup = AccountIdLookup<AccountId, ()>;
+  type Index = Index;
+  type BlockNumber = BlockNumber;
+  type Hash = Hash;
+  type Hashing = BlakeTwo256;
+  type Header = Header;
+  type Event = Event;
+  type Origin = Origin;
+  type BlockHashCount = BlockHashCount;
+  type DbWeight = RocksDbWeight;
+  type Version = Version;
+  type PalletInfo = PalletInfo;
+
+  type OnNewAccount = ();
+  type OnKilledAccount = ();
+  type OnSetCode = ();
+
+  type AccountData = pallet_balances::AccountData<Balance>;
+  type SystemWeightInfo = ();
+  type SS58Prefix = SS58Prefix; // TODO: Remove
+
+  type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_timestamp::Config for Runtime {
+  type Moment = u64;
+  type OnTimestampSet = ();
+  type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
+  type WeightInfo = ();
+}
+
+impl pallet_balances::Config for Runtime {
+  type MaxLocks = ConstU32<50>;
+  type MaxReserves = ();
+  type ReserveIdentifier = [u8; 8];
+  type Balance = Balance;
+  type Event = Event;
+  type DustRemoval = ();
+  type ExistentialDeposit = ConstU64<500>;
+  type AccountStore = System;
+  type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+  type Event = Event;
+  type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
+  type OperationalFeeMultiplier = ConstU8<5>;
+  type WeightToFee = IdentityFee<Balance>;
+  type LengthToFee = IdentityFee<Balance>;
+  type FeeMultiplierUpdate = ();
+}
+
+pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type SignedExtra = (
+  frame_system::CheckNonZeroSender<Runtime>,
+  frame_system::CheckSpecVersion<Runtime>,
+  frame_system::CheckTxVersion<Runtime>,
+  frame_system::CheckGenesis<Runtime>,
+  frame_system::CheckEra<Runtime>,
+  frame_system::CheckNonce<Runtime>,
+  frame_system::CheckWeight<Runtime>,
+  pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+);
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
+pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
+pub type Executive = frame_executive::Executive<
+  Runtime,
+  Block,
+  frame_system::ChainContext<Runtime>,
+  Runtime,
+  AllPalletsWithSystem,
+>;
+
+construct_runtime!(
+  pub enum Runtime where
+    Block = Block,
+    NodeBlock = Block,
+    UncheckedExtrinsic = UncheckedExtrinsic
+  {
+    System: frame_system,
+    Timestamp: pallet_timestamp,
+    Balances: pallet_balances,
+    TransactionPayment: pallet_transaction_payment
+  }
+);
+
+#[cfg(feature = "runtime-benchmarks")]
+#[macro_use]
+extern crate frame_benchmarking;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benches {
+  define_benchmarks!(
+    [frame_benchmarking, BaselineBench::<Runtime>]
+    [frame_system, SystemBench::<Runtime>]
+    [pallet_balances, Balances]
+    [pallet_timestamp, Timestamp]
+  );
+}
+
+impl_runtime_apis! {
+  impl sp_api::Core<Block> for Runtime {
+    fn version() -> RuntimeVersion {
+      VERSION
+    }
+
+    fn execute_block(block: Block) {
+      Executive::execute_block(block);
+    }
+
+    fn initialize_block(header: &<Block as BlockT>::Header) {
+      Executive::initialize_block(header)
+    }
+  }
+
+  impl sp_api::Metadata<Block> for Runtime {
+    fn metadata() -> OpaqueMetadata {
+      OpaqueMetadata::new(Runtime::metadata().into())
+    }
+  }
+
+  impl sp_block_builder::BlockBuilder<Block> for Runtime {
+    fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
+      Executive::apply_extrinsic(extrinsic)
+    }
+
+    fn finalize_block() -> <Block as BlockT>::Header {
+      Executive::finalize_block()
+    }
+
+    fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+      data.create_extrinsics()
+    }
+
+    fn check_inherents(
+      block: Block,
+      data: sp_inherents::InherentData,
+    ) -> sp_inherents::CheckInherentsResult {
+      data.check_extrinsics(&block)
+    }
+  }
+
+  impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+    fn validate_transaction(
+      source: TransactionSource,
+      tx: <Block as BlockT>::Extrinsic,
+      block_hash: <Block as BlockT>::Hash,
+    ) -> TransactionValidity {
+      Executive::validate_transaction(source, tx, block_hash)
+    }
+  }
+
+  impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
+    fn offchain_worker(header: &<Block as BlockT>::Header) {
+      Executive::offchain_worker(header)
+    }
+  }
+
+  impl sp_session::SessionKeys<Block> for Runtime {
+    fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
+      opaque::SessionKeys::generate(seed)
+    }
+
+    fn decode_session_keys(
+      encoded: Vec<u8>,
+    ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
+      opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
+    }
+  }
+
+  impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {
+    fn account_nonce(account: AccountId) -> Index {
+      System::account_nonce(account)
+    }
+  }
+
+  impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
+    Block,
+    Balance
+  > for Runtime {
+    fn query_info(
+      uxt: <Block as BlockT>::Extrinsic,
+      len: u32,
+    ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
+      TransactionPayment::query_info(uxt, len)
+    }
+    fn query_fee_details(
+      uxt: <Block as BlockT>::Extrinsic,
+      len: u32,
+    ) -> pallet_transaction_payment::FeeDetails<Balance> {
+      TransactionPayment::query_fee_details(uxt, len)
+    }
+  }
+
+  #[cfg(feature = "runtime-benchmarks")]
+  impl frame_benchmarking::Benchmark<Block> for Runtime {
+    fn benchmark_metadata(extra: bool) -> (
+      Vec<frame_benchmarking::BenchmarkList>,
+      Vec<frame_support::traits::StorageInfo>,
+    ) {
+      use frame_benchmarking::{baseline, Benchmarking, BenchmarkList};
+      use frame_support::traits::StorageInfoTrait;
+      use frame_system_benchmarking::Pallet as SystemBench;
+      use baseline::Pallet as BaselineBench;
+
+      let mut list = Vec::<BenchmarkList>::new();
+      list_benchmarks!(list, extra);
+
+      let storage_info = AllPalletsWithSystem::storage_info();
+
+      (list, storage_info)
+    }
+
+    fn dispatch_benchmark(
+      config: frame_benchmarking::BenchmarkConfig
+    ) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
+      use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch, TrackedStorageKey};
+
+      use frame_system_benchmarking::Pallet as SystemBench;
+      use baseline::Pallet as BaselineBench;
+
+      impl frame_system_benchmarking::Config for Runtime {}
+      impl baseline::Config for Runtime {}
+
+      let whitelist: Vec<TrackedStorageKey> = vec![
+        // Block Number
+        hex_literal::hex!(
+          "26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac"
+        ).to_vec().into(),
+        // Total Issuance
+        hex_literal::hex!(
+          "c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80"
+        ).to_vec().into(),
+        // Execution Phase
+        hex_literal::hex!(
+          "26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a"
+        ).to_vec().into(),
+        // Event Count
+        hex_literal::hex!(
+          "26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850"
+        ).to_vec().into(),
+        // System Events
+        hex_literal::hex!(
+          "26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+        ).to_vec().into(),
+      ];
+
+      let mut batches = Vec::<BenchmarkBatch>::new();
+      let params = (&config, &whitelist);
+      add_benchmarks!(params, batches);
+
+      Ok(batches)
+    }
+  }
+
+  #[cfg(feature = "try-runtime")]
+  impl frame_try_runtime::TryRuntime<Block> for Runtime {
+    fn on_runtime_upgrade() -> (Weight, Weight) {
+      // NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
+      // have a backtrace here. If any of the pre/post migration checks fail, we shall stop
+      // right here and right now.
+      let weight = Executive::try_runtime_upgrade().unwrap();
+      (weight, BlockWeights::get().max_block)
+    }
+
+    fn execute_block_no_check(block: Block) -> Weight {
+      Executive::execute_block_no_check(block)
+    }
+  }
+}