Update substrate

substrate/node/Cargo.toml

@@ -33,6 +33,7 @@ frame-benchmarking-cli = { git = "https://github.com/serai-dex/substrate" }
 
 serai-runtime = { path = "../runtime", features = ["std"] }
 
+sc-offchain = { git = "https://github.com/serai-dex/substrate" }
 sc-transaction-pool = { git = "https://github.com/serai-dex/substrate" }
 sc-transaction-pool-api = { git = "https://github.com/serai-dex/substrate" }
 sc-basic-authorship = { git = "https://github.com/serai-dex/substrate" }

substrate/node/src/chain_spec.rs

@@ -1,14 +1,16 @@
+use core::marker::PhantomData;
+
 use sp_core::Pair as PairTrait;
 
 use sc_service::ChainType;
 
 use serai_runtime::{
   primitives::*, tokens::primitives::ADDRESS as TOKENS_ADDRESS, WASM_BINARY, opaque::SessionKeys,
-  BABE_GENESIS_EPOCH_CONFIG, GenesisConfig, SystemConfig, BalancesConfig, AssetsConfig,
+  BABE_GENESIS_EPOCH_CONFIG, RuntimeGenesisConfig, SystemConfig, BalancesConfig, AssetsConfig,
   ValidatorSetsConfig, SessionConfig, BabeConfig, GrandpaConfig, AuthorityDiscoveryConfig,
 };
 
-pub type ChainSpec = sc_service::GenericChainSpec<GenesisConfig>;
+pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig>;
 
 fn account_from_name(name: &'static str) -> PublicKey {
   insecure_pair_from_name(name).public()
@@ -18,7 +20,7 @@ fn testnet_genesis(
   wasm_binary: &[u8],
   validators: &[&'static str],
   endowed_accounts: Vec<PublicKey>,
-) -> GenesisConfig {
+) -> RuntimeGenesisConfig {
   let session_key = |name| {
     let key = account_from_name(name);
     (
@@ -28,8 +30,8 @@ fn testnet_genesis(
     )
   };
 
-  GenesisConfig {
-    system: SystemConfig { code: wasm_binary.to_vec() },
+  RuntimeGenesisConfig {
+    system: SystemConfig { code: wasm_binary.to_vec(), _config: PhantomData },
 
     balances: BalancesConfig {
       balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 60)).collect(),
@@ -61,10 +63,14 @@ fn testnet_genesis(
       participants: validators.iter().map(|name| account_from_name(name)).collect(),
     },
     session: SessionConfig { keys: validators.iter().map(|name| session_key(*name)).collect() },
-    babe: BabeConfig { authorities: vec![], epoch_config: Some(BABE_GENESIS_EPOCH_CONFIG) },
-    grandpa: GrandpaConfig { authorities: vec![] },
+    babe: BabeConfig {
+      authorities: vec![],
+      epoch_config: Some(BABE_GENESIS_EPOCH_CONFIG),
+      _config: PhantomData,
+    },
+    grandpa: GrandpaConfig { authorities: vec![], _config: PhantomData },
 
-    authority_discovery: AuthorityDiscoveryConfig { keys: vec![] },
+    authority_discovery: AuthorityDiscoveryConfig { keys: vec![], _config: PhantomData },
   }
 }
 

substrate/node/src/command.rs

@@ -4,7 +4,7 @@ use serai_runtime::Block;
 
 use sc_service::{PruningMode, PartialComponents};
 
-use sc_cli::{ChainSpec, RuntimeVersion, SubstrateCli};
+use sc_cli::SubstrateCli;
 use frame_benchmarking_cli::{ExtrinsicFactory, BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE};
 
 use crate::{
@@ -46,10 +46,6 @@ impl SubstrateCli for Cli {
       _ => panic!("Unknown network ID"),
     }
   }
-
-  fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
-    &serai_runtime::VERSION
-  }
 }
 
 pub fn run() -> sc_cli::Result<()> {
@@ -99,29 +95,7 @@ pub fn run() -> sc_cli::Result<()> {
     }),
 
     Some(Subcommand::Benchmark(cmd)) => cli.create_runner(cmd)?.sync_run(|config| match cmd {
-      BenchmarkCmd::Pallet(cmd) => {
-        use sc_executor::{NativeVersion, NativeExecutionDispatch};
-
-        use serai_runtime as runtime;
-
-        struct ExecutorDispatch;
-        impl NativeExecutionDispatch for ExecutorDispatch {
-          #[cfg(feature = "runtime-benchmarks")]
-          type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;
-          #[cfg(not(feature = "runtime-benchmarks"))]
-          type ExtendHostFunctions = ();
-
-          fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
-            runtime::api::dispatch(method, data)
-          }
-
-          fn native_version() -> NativeVersion {
-            runtime::native_version()
-          }
-        }
-
-        cmd.run::<Block, ExecutorDispatch>(config)
-      }
+      BenchmarkCmd::Pallet(cmd) => cmd.run::<Block, ()>(config),
 
       BenchmarkCmd::Block(cmd) => cmd.run(service::new_partial(&config)?.client),
 

substrate/node/src/service.rs

@@ -12,7 +12,8 @@ use sc_network_common::sync::warp::WarpSyncParams;
 use sc_network::{Event, NetworkEventStream};
 use sc_service::{error::Error as ServiceError, Configuration, TaskManager, TFullClient};
 
-use sc_client_api::BlockBackend;
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sc_client_api::{BlockBackend, Backend};
 
 use sc_telemetry::{Telemetry, TelemetryWorker};
 
@@ -116,17 +117,21 @@ pub fn new_partial(config: &Configuration) -> Result<PartialComponents, ServiceE
   )?;
 
   let slot_duration = babe_link.config().slot_duration();
-  let (import_queue, babe_handle) = sc_consensus_babe::import_queue(
-    babe_link.clone(),
-    block_import.clone(),
-    Some(Box::new(justification_import)),
-    client.clone(),
-    select_chain.clone(),
-    move |_, _| async move { Ok(create_inherent_data_providers(slot_duration)) },
-    &task_manager.spawn_essential_handle(),
-    config.prometheus_registry(),
-    telemetry.as_ref().map(Telemetry::handle),
-  )?;
+  let (import_queue, babe_handle) =
+    sc_consensus_babe::import_queue(sc_consensus_babe::ImportQueueParams {
+      link: babe_link.clone(),
+      block_import: block_import.clone(),
+      justification_import: Some(Box::new(justification_import)),
+      client: client.clone(),
+      select_chain: select_chain.clone(),
+      create_inherent_data_providers: move |_, _| async move {
+        Ok(create_inherent_data_providers(slot_duration))
+      },
+      spawner: &task_manager.spawn_essential_handle(),
+      registry: config.prometheus_registry(),
+      telemetry: telemetry.as_ref().map(Telemetry::handle),
+      offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()),
+    })?;
   // This can't be dropped, or BABE breaks
   // We don't have anything to do with it though
   // This won't grow in size, so forgetting this isn't a disastrous memleak
@@ -184,11 +189,20 @@ pub async fn new_full(config: Configuration) -> Result<TaskManager, ServiceError
     })?;
 
   if config.offchain_worker.enabled {
-    sc_service::build_offchain_workers(
-      &config,
-      task_manager.spawn_handle(),
-      client.clone(),
-      network.clone(),
+    task_manager.spawn_handle().spawn(
+      "offchain-workers-runner",
+      "offchain-worker",
+      sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
+        runtime_api_provider: client.clone(),
+        is_validator: config.role.is_authority(),
+        keystore: Some(keystore_container.keystore()),
+        offchain_db: backend.offchain_storage(),
+        transaction_pool: Some(OffchainTransactionPoolFactory::new(transaction_pool.clone())),
+        network_provider: network.clone(),
+        enable_http_requests: true,
+        custom_extensions: |_| vec![],
+      })
+      .run(client.clone(), task_manager.spawn_handle()),
     );
   }
 
@@ -238,7 +252,7 @@ pub async fn new_full(config: Configuration) -> Result<TaskManager, ServiceError
       env: sc_basic_authorship::ProposerFactory::new(
         task_manager.spawn_handle(),
         client.clone(),
-        transaction_pool,
+        transaction_pool.clone(),
         prometheus_registry.as_ref(),
         telemetry.as_ref().map(Telemetry::handle),
       ),
@@ -312,6 +326,7 @@ pub async fn new_full(config: Configuration) -> Result<TaskManager, ServiceError
         voting_rule: grandpa::VotingRulesBuilder::default().build(),
         prometheus_registry,
         shared_voter_state,
+        offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool),
       })?,
     );
   }