A0-4216: Does not depend on actual runtime API in aleph-node (#1668)

tl;dr 
Goal of this PR is to have only chainspec generation as only
`aleph-runtime` dependency in `aleph-node`.

In aleph-node, we depend on aleph-runtimes RuntimeAPI type. This is not
required, as per
aleph-zero-foundation/polkadot-sdk@e53d15a
:

> These runtime api implementations are only used to make the compiler
think that we have implemented all required runtime apis. They will
notbe called as we switch the executor to WasmExecutor. In the
nearfuture we will not require these fake implementations anymore
afterSubstrate has shifted away from this compile time requirement.This
brings us the advantage that the polkadot-service doesn't need todepend
on the runtimes for getting the RuntimeApi  also removes around 1min of
build time on my machine ;)

1. To achieve so we need to implement similar idea like
https://github.com/Cardinal-Cryptography/polkadot-sdk/blob/aleph-v1.4.0/polkadot/node/service/src/fake_runtime_api.rs
into our `aleph-node` binary
2. There’s an important remark on how this fake runtime must be
implemented - it does not need to have all the same entries like
[`impl_runtime_apis!`](https://github.com/Cardinal-Cryptography/aleph-node/blob/main/bin/runtime/src/lib.rs#L1001-L1259)
has - in particular, it does not need an implementation for
* `pallet_nomination_pools_runtime_api::NominationPoolsApi`
* `pallet_staking_runtime_api::StakingApi`
* `pallet_contracts::ContractsApi`

ie, code compiles without them, even though real runtime has those. Why?
Because this fake runtime API is only used only for sake of compilation:
* for explicit calls in aleph-node to runtime API, e.g. [this requires
primitives::AlephSessionApi to be implemented for
fake_runtime_api](https://github.com/Cardinal-Cryptography/aleph-node/blob/main/bin/node/src/service.rs#L200)
* [because of trait bounds when creating RPC client in
node](https://github.com/Cardinal-Cryptography/aleph-node/blob/main/bin/node/src/rpc.rs#L49-L51)
* [because of RPC modules to include in
node](https://github.com/Cardinal-Cryptography/aleph-node/blob/main/bin/node/src/rpc.rs#L69-L83)

3. We use runtime’s SessionKeys, not opaque::SessionKeys when impl
sp_session::SessionKeys<Block> for Runtime - this is because Polkadot
and other parachains do the same, and code compiles after the change.
4. Unifications of imports of primitives in aleph-node. 
5. Use fake_runtime in `finality-aleph`'s tests - no more aleph-runtime
dependency!
6. Bumped `version` of `primitives` to be 0.14.0+dev - primitives needs
to be versioned the same as runtime

Author: Marcin-Radecki

Cargo.lock

@@ -28,7 +28,6 @@ static_assertions = { workspace = true }
 thiserror = { workspace = true }
 
 sc-basic-authorship = { workspace = true }
-sc-block-builder = { workspace = true }
 sc-chain-spec = { workspace = true }
 sc-cli = { workspace = true }
 sc-client-api = { workspace = true }
@@ -43,13 +42,12 @@ sc-service = { workspace = true }
 sc-telemetry = { workspace = true }
 sc-transaction-pool = { workspace = true }
 sc-transaction-pool-api = { workspace = true }
-
 sp-application-crypto = { workspace = true }
 sp-arithmetic = { workspace = true }
+sp-block-builder = { workspace = true }
 sp-consensus = { workspace = true }
 sp-consensus-aura = { workspace = true }
 sp-core = { workspace = true }
-sp-inherents = { workspace = true }
 sp-io = { workspace = true }
 sp-keystore = { workspace = true }
 sp-runtime = { workspace = true }
@@ -62,7 +60,9 @@ try-runtime-cli = { workspace = true, optional = true }
 frame-benchmarking-cli = { workspace = true, optional = true }
 frame-benchmarking = { workspace = true, optional = true }
 
+# this is only neeeded for chainspec generation
 aleph-runtime = { workspace = true }
+
 aleph-runtime-interfaces = { workspace = true }
 finality-aleph = { workspace = true }
 primitives = { workspace = true }
@@ -73,7 +73,7 @@ sc-rpc = { workspace = true }
 sc-rpc-api = { workspace = true }
 sp-api = { workspace = true }
 sp-blockchain = { workspace = true }
-sp-block-builder = { workspace = true }
+
 substrate-frame-rpc-system = { workspace = true }
 pallet-transaction-payment-rpc = { workspace = true }
 
@@ -84,7 +84,7 @@ substrate-build-script-utils = { workspace = true }
 default = []
 short_session = [
     "aleph-runtime/short_session",
-    "primitives/short_session"
+    "primitives/short_session",
 ]
 try-runtime = [
     "aleph-runtime/try-runtime",

bin/node/Cargo.toml

@@ -2,10 +2,9 @@ use std::path::PathBuf;
 
 use finality_aleph::UnitCreationDelay;
 use log::warn;
+use primitives::{DEFAULT_MAX_NON_FINALIZED_BLOCKS, DEFAULT_UNIT_CREATION_DELAY};
 use sc_cli::clap::{self, ArgGroup, Parser};
 
-use crate::aleph_primitives::{DEFAULT_MAX_NON_FINALIZED_BLOCKS, DEFAULT_UNIT_CREATION_DELAY};
-
 #[derive(Debug, Parser, Clone)]
 #[clap(group(ArgGroup::new("backup")))]
 pub struct AlephCli {

bin/node/src/aleph_cli.rs

@@ -1,12 +1,18 @@
 use std::{collections::HashSet, str::FromStr, string::ToString};
 
 use aleph_runtime::{
-    AccountId, AlephConfig, AuraConfig, BalancesConfig, CommitteeManagementConfig, ElectionsConfig,
-    Feature, FeatureControlConfig, Perbill, RuntimeGenesisConfig, SessionConfig, StakingConfig,
-    SudoConfig, SystemConfig, VestingConfig, WASM_BINARY,
+    AlephConfig, AuraConfig, BalancesConfig, CommitteeManagementConfig, ElectionsConfig, Feature,
+    FeatureControlConfig, Perbill, RuntimeGenesisConfig, SessionConfig, StakingConfig, SudoConfig,
+    SystemConfig, VestingConfig, WASM_BINARY,
 };
 use libp2p::PeerId;
 use pallet_staking::{Forcing, StakerStatus};
+use primitives::{
+    staking::{MIN_NOMINATOR_BOND, MIN_VALIDATOR_BOND},
+    AccountId, AlephNodeSessionKeys as SessionKeys, AuraId, AuthorityId as AlephId,
+    SessionValidators, Version as FinalityVersion, ADDRESSES_ENCODING, LEGACY_FINALITY_VERSION,
+    TOKEN_DECIMALS,
+};
 use sc_cli::{
     clap::{self, Args},
     Error as CliError,
@@ -17,12 +23,6 @@ use serde_json::{Number, Value};
 use sp_application_crypto::Ss58Codec;
 use sp_core::{sr25519, Pair};
 
-use crate::aleph_primitives::{
-    staking::{MIN_NOMINATOR_BOND, MIN_VALIDATOR_BOND},
-    AlephNodeSessionKeys as SessionKeys, AuraId, AuthorityId as AlephId, SessionValidators,
-    Version as FinalityVersion, ADDRESSES_ENCODING, LEGACY_FINALITY_VERSION, TOKEN_DECIMALS,
-};
-
 pub const CHAINTYPE_DEV: &str = "dev";
 pub const CHAINTYPE_LOCAL: &str = "local";
 pub const CHAINTYPE_LIVE: &str = "live";

bin/node/src/chain_spec.rs

@@ -4,8 +4,8 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use aleph_runtime::AccountId;
 use libp2p::identity::{ed25519 as libp2p_ed25519, PublicKey};
+use primitives::{AccountId, AuraId, AuthorityId as AlephId};
 use sc_cli::{
     clap::{self, Args, Parser},
     Error, KeystoreParams,
@@ -15,12 +15,9 @@ use sc_service::config::{BasePath, KeystoreConfig};
 use sp_application_crypto::{key_types, Ss58Codec};
 use sp_keystore::Keystore;
 
-use crate::{
-    aleph_primitives::{AuraId, AuthorityId as AlephId},
-    chain_spec::{
-        self, account_id_from_string, AuthorityKeys, ChainParams, ChainSpec, SerializablePeerId,
-        DEFAULT_BACKUP_FOLDER,
-    },
+use crate::chain_spec::{
+    self, account_id_from_string, AuthorityKeys, ChainParams, ChainSpec, SerializablePeerId,
+    DEFAULT_BACKUP_FOLDER,
 };
 
 #[derive(Debug, Args)]
@@ -67,10 +64,10 @@ fn aura_key(keystore: &impl Keystore) -> AuraId {
 
 /// returns Aleph key, if absent a new key is generated
 fn aleph_key(keystore: &impl Keystore) -> AlephId {
-    Keystore::ed25519_public_keys(keystore, crate::aleph_primitives::KEY_TYPE)
+    Keystore::ed25519_public_keys(keystore, primitives::KEY_TYPE)
         .pop()
         .unwrap_or_else(|| {
-            Keystore::ed25519_generate_new(keystore, crate::aleph_primitives::KEY_TYPE, None)
+            Keystore::ed25519_generate_new(keystore, primitives::KEY_TYPE, None)
                 .expect("Could not create Aleph key")
         })
         .into()

bin/node/src/commands.rs

@@ -10,5 +10,4 @@ mod service;
 
 pub use cli::{Cli, Subcommand};
 pub use executor::ExecutorDispatch;
-use primitives as aleph_primitives;
 pub use service::{new_authority, new_partial};

bin/node/src/lib.rs

@@ -7,8 +7,6 @@ use pruning_config::PruningConfigValidator;
 use sc_cli::{clap::Parser, SubstrateCli};
 use sc_network::config::Role;
 use sc_service::{Configuration, PartialComponents};
-#[cfg(any(feature = "try-runtime", feature = "runtime-benchmarks"))]
-use {aleph_node::ExecutorDispatch, aleph_runtime::Block, sc_executor::NativeExecutionDispatch};
 
 fn enforce_heap_pages(config: &mut Configuration) {
     config.default_heap_pages = Some(HEAP_PAGES);
@@ -88,9 +86,11 @@ fn main() -> sc_cli::Result<()> {
         }
         #[cfg(feature = "try-runtime")]
         Some(Subcommand::TryRuntime(cmd)) => {
-            use primitives::MILLISECS_PER_BLOCK;
+            use aleph_node::ExecutorDispatch;
+            use primitives::{Block, MILLISECS_PER_BLOCK};
             use sc_executor::{sp_wasm_interface::ExtendedHostFunctions, NativeExecutionDispatch};
             use try_runtime_cli::block_building_info::timestamp_with_aura_info;
+
             let runner = cli.create_runner(cmd)?;
             runner.async_run(|config| {
                 let registry = config.prometheus_config.as_ref().map(|cfg| &cfg.registry);
@@ -99,6 +99,12 @@ fn main() -> sc_cli::Result<()> {
                         .map_err(|e| sc_cli::Error::Service(sc_service::Error::Prometheus(e)))?;
 
                 Ok((
+                    // TODO
+                    // warning: use of deprecated method `try_runtime_cli::TryRuntimeCmd::run`:
+                    // Substrate's `try-runtime` subcommand has been migrated to a standalone CLI
+                    // (https://github.com/paritytech/try-runtime-cli). It is no longer being
+                    // maintained here and will be removed entirely some time after January 2024.
+                    // Please remove this subcommand from your runtime and use the standalone CLI.
                     cmd.run::<Block, ExtendedHostFunctions<
                         sp_io::SubstrateHostFunctions,
                         <ExecutorDispatch as NativeExecutionDispatch>::ExtendHostFunctions,
@@ -115,6 +121,10 @@ fn main() -> sc_cli::Result<()> {
             .into()),
         #[cfg(feature = "runtime-benchmarks")]
         Some(Subcommand::Benchmark(cmd)) => {
+            use aleph_node::ExecutorDispatch;
+            use primitives::Block;
+            use sc_executor::NativeExecutionDispatch;
+
             let runner = cli.create_runner(cmd)?;
             runner.sync_run(|config| {
                 if let frame_benchmarking_cli::BenchmarkCmd::Pallet(cmd) = cmd {

bin/node/src/main.rs

@@ -7,10 +7,10 @@
 
 use std::sync::Arc;
 
-use aleph_runtime::{opaque::Block, AccountId, Balance, Nonce};
 use finality_aleph::{Justification, JustificationTranslator, ValidatorAddressCache};
 use futures::channel::mpsc;
 use jsonrpsee::RpcModule;
+use primitives::{AccountId, Balance, Block, Nonce};
 use sc_client_api::StorageProvider;
 pub use sc_rpc_api::DenyUnsafe;
 use sc_transaction_pool_api::TransactionPool;

bin/node/src/rpc.rs

@@ -5,14 +5,16 @@ use std::{
     sync::Arc,
 };
 
-use aleph_runtime::{self, opaque::Block, RuntimeApi};
 use finality_aleph::{
     run_validator_node, AlephBlockImport, AlephConfig, AllBlockMetrics, BlockImporter,
     ChannelProvider, Justification, JustificationTranslator, MillisecsPerBlock, Protocol,
     ProtocolNaming, RateLimiterConfig, RedirectingBlockImport, SessionPeriod, SubstrateChainStatus,
     SubstrateNetwork, SyncOracle, TracingBlockImport, ValidatorAddressCache,
 };
 use log::warn;
+use primitives::{
+    fake_runtime_api::fake_runtime::RuntimeApi, AlephSessionApi, Block, MAX_BLOCK_SIZE,
+};
 use sc_basic_authorship::ProposerFactory;
 use sc_client_api::{BlockBackend, HeaderBackend};
 use sc_consensus::ImportQueue;
@@ -28,7 +30,6 @@ use sp_consensus_aura::{sr25519::AuthorityPair as AuraPair, Slot};
 
 use crate::{
     aleph_cli::AlephCli,
-    aleph_primitives::{AlephSessionApi, MAX_BLOCK_SIZE},
     chain_spec::DEFAULT_BACKUP_FOLDER,
     executor::AlephExecutor,
     rpc::{create_full as create_full_rpc, FullDeps as RpcFullDeps},

bin/node/src/service.rs

@@ -44,10 +44,9 @@ use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use primitives::{
     staking::MAX_NOMINATORS_REWARDED_PER_VALIDATOR, wrap_methods, Address,
     AlephNodeSessionKeys as SessionKeys, ApiError as AlephApiError, AuraId, AuthorityId as AlephId,
-    Block as AlephBlock, BlockId as AlephBlockId, BlockNumber as AlephBlockNumber,
-    Header as AlephHeader, SessionAuthorityData, SessionCommittee, SessionIndex,
-    SessionInfoProvider, SessionValidatorError, Version as FinalityVersion, ADDRESSES_ENCODING,
-    DEFAULT_BAN_REASON_LENGTH, DEFAULT_MAX_WINNERS, DEFAULT_SESSIONS_PER_ERA,
+    BlockNumber as AlephBlockNumber, Header as AlephHeader, SessionAuthorityData, SessionCommittee,
+    SessionIndex, SessionInfoProvider, SessionValidatorError, Version as FinalityVersion,
+    ADDRESSES_ENCODING, DEFAULT_BAN_REASON_LENGTH, DEFAULT_MAX_WINNERS, DEFAULT_SESSIONS_PER_ERA,
     DEFAULT_SESSION_PERIOD, MAX_BLOCK_SIZE, MILLISECS_PER_BLOCK, TOKEN,
 };
 pub use primitives::{AccountId, AccountIndex, Balance, Hash, Nonce, Signature};
@@ -58,7 +57,7 @@ use sp_core::{crypto::KeyTypeId, ConstU128, OpaqueMetadata};
 #[cfg(any(feature = "std", test))]
 pub use sp_runtime::BuildStorage;
 use sp_runtime::{
-    create_runtime_str, generic, impl_opaque_keys,
+    create_runtime_str, generic,
     traits::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, Bounded, Convert, ConvertInto,
         IdentityLookup, One, OpaqueKeys,
@@ -73,30 +72,6 @@ use sp_std::prelude::*;
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 
-/// 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 {
-    pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
-
-    use super::*;
-
-    /// Opaque block header type.
-    pub type Header = AlephHeader;
-    /// Opaque block type.
-    pub type Block = AlephBlock;
-    /// Opaque block identifier type.
-    pub type BlockId = AlephBlockId;
-
-    impl_opaque_keys! {
-        pub struct SessionKeys {
-            pub aura: Aura,
-            pub aleph: Aleph,
-        }
-    }
-}
-
 #[sp_version::runtime_version]
 pub const VERSION: RuntimeVersion = RuntimeVersion {
     spec_name: create_runtime_str!("aleph-node"),
@@ -1072,13 +1047,13 @@ impl_runtime_apis! {
 
     impl sp_session::SessionKeys<Block> for Runtime {
         fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
-            opaque::SessionKeys::generate(seed)
+            SessionKeys::generate(seed)
         }
 
         fn decode_session_keys(
             encoded: Vec<u8>,
         ) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
-            opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
+            SessionKeys::decode_into_raw_public_keys(&encoded)
         }
     }