From a3d96efe8c89a93efc2987c30eabad83a1521f02 Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Fri, 5 Apr 2024 14:02:11 +0300 Subject: [PATCH 01/15] Farming cluster --- Cargo.lock | 31 +- .../src/segment_reconstruction.rs | 18 +- crates/subspace-farmer/Cargo.toml | 2 +- .../src/bin/subspace-farmer/commands.rs | 1 + .../bin/subspace-farmer/commands/cluster.rs | 181 ++++ .../subspace-farmer/commands/cluster/cache.rs | 180 ++++ .../commands/cluster/controller.rs | 254 +++++ .../commands/cluster/controller/caches.rs | 201 ++++ .../commands/cluster/controller/farms.rs | 393 +++++++ .../commands/cluster/farmer.rs | 515 ++++++++++ .../commands/cluster/plotter.rs | 178 ++++ .../src/bin/subspace-farmer/commands/farm.rs | 5 +- .../src/bin/subspace-farmer/main.rs | 13 +- crates/subspace-farmer/src/cluster.rs | 56 + crates/subspace-farmer/src/cluster/cache.rs | 754 ++++++++++++++ .../subspace-farmer/src/cluster/controller.rs | 738 ++++++++++++++ crates/subspace-farmer/src/cluster/farmer.rs | 835 +++++++++++++++ crates/subspace-farmer/src/cluster/plotter.rs | 960 ++++++++++++++++++ 18 files changed, 5302 insertions(+), 13 deletions(-) create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/cache.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/caches.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/farms.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/farmer.rs create mode 100644 crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/plotter.rs create mode 100644 crates/subspace-farmer/src/cluster/cache.rs create mode 100644 crates/subspace-farmer/src/cluster/controller.rs create mode 100644 crates/subspace-farmer/src/cluster/farmer.rs create mode 100644 crates/subspace-farmer/src/cluster/plotter.rs diff --git a/Cargo.lock b/Cargo.lock index 511fab3a46..3ef8fa13ac 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -948,9 +948,9 @@ dependencies = [ [[package]] name = "async-nats" -version = "0.34.0" +version = "0.35.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eea7b126ebfa4db78e9e788b2a792b6329f35b4f2fdd56dbc646dedc2beec7a5" +checksum = "d5e47d2f7305524258908449aff6c86db36697a9b4219bfb1777e0ca1945358d" dependencies = [ "base64 0.22.0", "bytes", @@ -973,7 +973,7 @@ dependencies = [ "thiserror", "time", "tokio", - "tokio-rustls 0.25.0", + "tokio-rustls 0.26.0", "tracing", "tryhard", "url", @@ -9454,6 +9454,20 @@ dependencies = [ "zeroize", ] +[[package]] +name = "rustls" +version = "0.23.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "afabcee0551bd1aa3e18e5adbf2c0544722014b899adb31bd186ec638d3da97e" +dependencies = [ + "once_cell", + "ring 0.17.8", + "rustls-pki-types", + "rustls-webpki 0.102.3", + "subtle 2.5.0", + "zeroize", +] + [[package]] name = "rustls-native-certs" version = "0.6.3" @@ -13384,6 +13398,17 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-rustls" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" +dependencies = [ + "rustls 0.23.5", + "rustls-pki-types", + "tokio", +] + [[package]] name = "tokio-stream" version = "0.1.15" diff --git a/crates/subspace-farmer-components/src/segment_reconstruction.rs b/crates/subspace-farmer-components/src/segment_reconstruction.rs index 92b85de285..74396db9f7 100644 --- a/crates/subspace-farmer-components/src/segment_reconstruction.rs +++ b/crates/subspace-farmer-components/src/segment_reconstruction.rs @@ -7,11 +7,9 @@ use subspace_core_primitives::crypto::kzg::Kzg; use subspace_core_primitives::{ArchivedHistorySegment, Piece, PieceIndex, RecordedHistorySegment}; use thiserror::Error; use tokio::sync::Semaphore; +use tokio::task::JoinError; use tracing::{debug, error, info, trace, warn}; -// TODO: Probably should be made configurable -const PARALLELISM_LEVEL: usize = 20; - #[derive(Debug, Error)] pub(crate) enum SegmentReconstructionError { /// Not enough pieces to reconstruct a segment @@ -21,6 +19,10 @@ pub(crate) enum SegmentReconstructionError { /// Internal piece retrieval process failed #[error("Pieces retrieval failed")] PieceRetrievalFailed(#[from] ReconstructorError), + + /// Join error + #[error("Join error: {0}")] + JoinError(#[from] JoinError), } pub(crate) async fn recover_missing_piece( @@ -32,7 +34,7 @@ pub(crate) async fn recover_missing_piece( let segment_index = missing_piece_index.segment_index(); let position = missing_piece_index.position(); - let semaphore = &Semaphore::new(PARALLELISM_LEVEL); + let semaphore = &Semaphore::new(RecordedHistorySegment::NUM_RAW_RECORDS); let acquired_pieces_counter = &AtomicUsize::default(); let required_pieces_number = RecordedHistorySegment::NUM_RAW_RECORDS; @@ -100,9 +102,13 @@ pub(crate) async fn recover_missing_piece( return Err(SegmentReconstructionError::NotEnoughPiecesAcquired); } - let archiver = PiecesReconstructor::new(kzg).expect("Internal constructor call must succeed."); + let result = tokio::task::spawn_blocking(move || { + let reconstructor = + PiecesReconstructor::new(kzg).expect("Internal constructor call must succeed."); - let result = archiver.reconstruct_piece(&segment_pieces, position as usize)?; + reconstructor.reconstruct_piece(&segment_pieces, position as usize) + }) + .await??; info!(%missing_piece_index, "Recovering missing piece succeeded."); diff --git a/crates/subspace-farmer/Cargo.toml b/crates/subspace-farmer/Cargo.toml index b33c483d2d..82c6c0f3e5 100644 --- a/crates/subspace-farmer/Cargo.toml +++ b/crates/subspace-farmer/Cargo.toml @@ -14,7 +14,7 @@ include = [ [dependencies] anyhow = "1.0.82" async-lock = "3.3.0" -async-nats = "0.34.0" +async-nats = "0.35.0" async-trait = "0.1.80" backoff = { version = "0.4.0", features = ["futures", "tokio"] } base58 = "0.2.0" diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands.rs index 5f5ad44665..0d6936e9c8 100644 --- a/crates/subspace-farmer/src/bin/subspace-farmer/commands.rs +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands.rs @@ -1,4 +1,5 @@ pub(crate) mod benchmark; +pub(crate) mod cluster; pub(crate) mod farm; mod info; mod scrub; diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster.rs new file mode 100644 index 0000000000..3e44c37984 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster.rs @@ -0,0 +1,181 @@ +mod cache; +mod controller; +mod farmer; +mod plotter; + +use crate::commands::cluster::cache::{cache, CacheArgs}; +use crate::commands::cluster::controller::{controller, ControllerArgs}; +use crate::commands::cluster::farmer::{farmer, FarmerArgs}; +use crate::commands::cluster::plotter::{plotter, PlotterArgs}; +use crate::utils::shutdown_signal; +use anyhow::anyhow; +use async_nats::ServerAddr; +use backoff::ExponentialBackoff; +use clap::{Parser, Subcommand}; +use futures::stream::FuturesUnordered; +use futures::{select, FutureExt, StreamExt}; +use prometheus_client::registry::Registry; +use std::env::current_exe; +use std::mem; +use std::net::SocketAddr; +use std::num::NonZeroUsize; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::utils::AsyncJoinOnDrop; +use subspace_metrics::{start_prometheus_metrics_server, RegistryAdapter}; +use subspace_proof_of_space::Table; + +/// Arguments for cluster +#[derive(Debug, Parser)] +pub(crate) struct ClusterArgs { + /// Shared arguments for all subcommands + #[clap(flatten)] + shared_args: SharedArgs, + /// Cluster subcommands + #[clap(flatten)] + subcommands: ClusterSubcommands, +} + +/// Recursive cluster subcommands +#[derive(Debug, Parser)] +struct ClusterSubcommands { + /// Cluster subcommands + #[clap(subcommand)] + subcommand: ClusterSubcommand, +} + +/// Shared arguments +#[derive(Debug, Parser)] +struct SharedArgs { + /// NATS server address, typically in `nats://server1:port1` format, can be specified multiple + /// times. + /// + /// NOTE: NATS must be configured for message sizes of 2MiB or larger (1MiB is the default), + /// which can be done by starting NATS server with config file containing `max_payload = 2MB`. + #[arg(long, alias = "nats-server", required = true)] + nats_servers: Vec, + /// Size of connection pool of NATS clients. + /// + /// Pool size can be increased in case of large number of farms or high plotting capacity of + /// this instance. + #[arg(long, default_value = "8")] + nats_pool_size: NonZeroUsize, + /// Defines endpoints for the prometheus metrics server. It doesn't start without at least + /// one specified endpoint. Format: 127.0.0.1:8080 + #[arg(long, aliases = ["metrics-endpoint", "metrics-endpoints"])] + prometheus_listen_on: Vec, +} + +/// Cluster subcommands +#[derive(Debug, Subcommand)] +enum ClusterSubcommand { + /// Farming cluster controller + Controller(ControllerArgs), + /// Farming cluster farmer + Farmer(FarmerArgs), + /// Farming cluster plotter + Plotter(PlotterArgs), + /// Farming cluster cache + Cache(CacheArgs), +} + +impl ClusterSubcommand { + fn extract_additional_components(&mut self) -> Vec { + match self { + ClusterSubcommand::Controller(args) => mem::take(&mut args.additional_components), + ClusterSubcommand::Farmer(args) => mem::take(&mut args.additional_components), + ClusterSubcommand::Plotter(args) => mem::take(&mut args.additional_components), + ClusterSubcommand::Cache(args) => mem::take(&mut args.additional_components), + } + } +} + +pub(crate) async fn cluster(cluster_args: ClusterArgs) -> anyhow::Result<()> +where + PosTable: Table, +{ + let signal = shutdown_signal(); + + let ClusterArgs { + shared_args, + subcommands, + } = cluster_args; + let SharedArgs { + nats_servers, + nats_pool_size, + prometheus_listen_on, + } = shared_args; + let ClusterSubcommands { mut subcommand } = subcommands; + + let nats_client = NatsClient::new( + nats_servers, + ExponentialBackoff { + max_elapsed_time: None, + ..ExponentialBackoff::default() + }, + nats_pool_size, + ) + .await + .map_err(|error| anyhow!("Failed to connect to NATS server: {error}"))?; + let mut registry = Registry::default(); + + let mut tasks = FuturesUnordered::new(); + + loop { + let nats_client = nats_client.clone(); + let additional_components = subcommand.extract_additional_components(); + + tasks.push(match subcommand { + ClusterSubcommand::Controller(controller_args) => { + controller(nats_client, &mut registry, controller_args).await? + } + ClusterSubcommand::Farmer(farmer_args) => { + farmer::(nats_client, &mut registry, farmer_args).await? + } + ClusterSubcommand::Plotter(plotter_args) => { + plotter::(nats_client, &mut registry, plotter_args).await? + } + ClusterSubcommand::Cache(cache_args) => { + cache(nats_client, &mut registry, cache_args).await? + } + }); + + if additional_components.is_empty() { + break; + } + + let binary_name = current_exe() + .ok() + .and_then(|path| { + path.file_name() + .and_then(|file_name| file_name.to_str()) + .map(str::to_string) + }) + .unwrap_or_else(|| "subspace-farmer".to_string()); + ClusterSubcommands { subcommand } = + ClusterSubcommands::parse_from([binary_name].into_iter().chain(additional_components)); + } + + if !prometheus_listen_on.is_empty() { + let prometheus_task = start_prometheus_metrics_server( + prometheus_listen_on, + RegistryAdapter::PrometheusClient(registry), + )?; + + let join_handle = tokio::spawn(prometheus_task); + tasks.push(Box::pin(async move { + Ok(AsyncJoinOnDrop::new(join_handle, true).await??) + })); + } + + select! { + // Signal future + _ = signal.fuse() => { + Ok(()) + }, + + // Run future + result = tasks.next() => { + result.expect("List of tasks is not empty; qed") + }, + } +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/cache.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/cache.rs new file mode 100644 index 0000000000..130d1fe36d --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/cache.rs @@ -0,0 +1,180 @@ +use anyhow::anyhow; +use bytesize::ByteSize; +use clap::Parser; +use prometheus_client::registry::Registry; +use std::fs; +use std::future::Future; +use std::path::PathBuf; +use std::pin::Pin; +use std::str::FromStr; +use std::time::Duration; +use subspace_farmer::cluster::cache::cache_service; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::piece_cache::PieceCache; + +/// Interval between cache self-identification broadcast messages +pub(super) const CACHE_IDENTIFICATION_BROADCAST_INTERVAL: Duration = Duration::from_secs(5); + +#[derive(Debug, Clone)] +struct DiskCache { + /// Path to directory where cache is stored + directory: PathBuf, + /// How much space in bytes can cache use + allocated_space: u64, +} + +impl FromStr for DiskCache { + type Err = String; + + #[inline] + fn from_str(s: &str) -> anyhow::Result { + let parts = s.split(',').collect::>(); + if parts.len() != 2 { + return Err("Must contain 2 coma-separated components".to_string()); + } + + let mut plot_directory = None; + let mut allocated_space = None; + + for part in parts { + let part = part.splitn(2, '=').collect::>(); + if part.len() != 2 { + return Err("Each component must contain = separating key from value".to_string()); + } + + let key = *part.first().expect("Length checked above; qed"); + let value = *part.get(1).expect("Length checked above; qed"); + + match key { + "path" => { + plot_directory.replace(PathBuf::from(value)); + } + "size" => { + allocated_space.replace( + value + .parse::() + .map_err(|error| { + format!("Failed to parse `size` \"{value}\": {error}") + })? + .as_u64(), + ); + } + key => { + return Err(format!( + "Key \"{key}\" is not supported, only `path` or `size`" + )); + } + } + } + + Ok(DiskCache { + directory: plot_directory.ok_or( + "`path` key is required with path to directory where cache will be stored", + )?, + allocated_space: allocated_space + .ok_or("`size` key is required with allocated amount of disk space")?, + }) + } +} + +/// Arguments for cache +#[derive(Debug, Parser)] +pub(super) struct CacheArgs { + /// One or more caches located at specified path, each with its own allocated space. + /// + /// Format for each cache is coma-separated list of strings like this: + /// + /// path=/path/to/directory,size=5T + /// + /// `size` is max allocated size in human-readable format (e.g. 10GB, 2TiB) or just bytes that + /// cache will make sure to not exceed (and will pre-allocated all the space on startup to + /// ensure it will not run out of space in runtime). + disk_caches: Vec, + /// Run temporary cache with specified farm size in human-readable format (e.g. 10GB, 2TiB) or + /// just bytes (e.g. 4096), this will create a temporary directory that will be deleted at the + /// end of the process. + #[arg(long, conflicts_with = "disk_caches")] + tmp: Option, + /// Cache group to use, the same cache group must be also specified on corresponding controller + #[arg(long, default_value = "default")] + cache_group: String, + /// Additional cluster components + #[clap(raw = true)] + pub(super) additional_components: Vec, +} + +pub(super) async fn cache( + nats_client: NatsClient, + _registry: &mut Registry, + cache_args: CacheArgs, +) -> anyhow::Result>>>> { + let CacheArgs { + mut disk_caches, + tmp, + cache_group, + additional_components: _, + } = cache_args; + + let tmp_directory = if let Some(plot_size) = tmp { + let tmp_directory = tempfile::Builder::new() + .prefix("subspace-cache-") + .tempdir()?; + + disk_caches = vec![DiskCache { + directory: tmp_directory.as_ref().to_path_buf(), + allocated_space: plot_size.as_u64(), + }]; + + Some(tmp_directory) + } else { + if disk_caches.is_empty() { + return Err(anyhow!("There must be at least one disk cache provided")); + } + + for cache in &disk_caches { + if !cache.directory.exists() { + if let Err(error) = fs::create_dir(&cache.directory) { + return Err(anyhow!( + "Directory {} doesn't exist and can't be created: {}", + cache.directory.display(), + error + )); + } + } + } + None + }; + + // TODO: Metrics + + let caches = disk_caches + .iter() + .map(|disk_cache| { + PieceCache::open( + &disk_cache.directory, + u32::try_from(disk_cache.allocated_space / PieceCache::element_size() as u64) + .unwrap_or(u32::MAX), + ) + .map_err(|error| { + anyhow!( + "Failed to open piece cache at {}: {error}", + disk_cache.directory.display() + ) + }) + }) + .collect::, _>>()?; + + Ok(Box::pin(async move { + cache_service( + nats_client, + &caches, + &cache_group, + CACHE_IDENTIFICATION_BROADCAST_INTERVAL, + ) + .await?; + + drop(tmp_directory); + + Ok(()) + })) +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs new file mode 100644 index 0000000000..07de54bca8 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs @@ -0,0 +1,254 @@ +mod caches; +mod farms; + +use crate::commands::cluster::controller::caches::maintain_caches; +use crate::commands::cluster::controller::farms::{maintain_farms, FarmIndex}; +use crate::commands::shared::derive_libp2p_keypair; +use crate::commands::shared::network::{configure_network, NetworkArgs}; +use anyhow::anyhow; +use async_lock::RwLock as AsyncRwLock; +use backoff::ExponentialBackoff; +use clap::{Parser, ValueHint}; +use futures::{select, FutureExt}; +use prometheus_client::registry::Registry; +use std::future::Future; +use std::path::PathBuf; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::Duration; +use subspace_core_primitives::crypto::kzg::{embedded_kzg_settings, Kzg}; +use subspace_farmer::cluster::controller::controller_service; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::farmer_cache::FarmerCache; +use subspace_farmer::node_client::node_rpc_client::NodeRpcClient; +use subspace_farmer::node_client::NodeClient; +use subspace_farmer::utils::farmer_piece_getter::{DsnCacheRetryPolicy, FarmerPieceGetter}; +use subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator; +use subspace_farmer::utils::plotted_pieces::PlottedPieces; +use subspace_farmer::utils::run_future_in_dedicated_thread; +use subspace_farmer::Identity; +use subspace_networking::utils::piece_provider::PieceProvider; +use tracing::info; + +/// Get piece retry attempts number. +const PIECE_GETTER_MAX_RETRIES: u16 = 7; +/// Defines initial duration between get_piece calls. +const GET_PIECE_INITIAL_INTERVAL: Duration = Duration::from_secs(5); +/// Defines max duration between get_piece calls. +const GET_PIECE_MAX_INTERVAL: Duration = Duration::from_secs(40); + +// TODO: Metrics for controller and sub-components +/// Arguments for controller +#[derive(Debug, Parser)] +pub(super) struct ControllerArgs { + /// Base path where to store P2P network identity + #[arg(long, value_hint = ValueHint::DirPath)] + base_path: Option, + /// WebSocket RPC URL of the Subspace node to connect to + #[arg(long, value_hint = ValueHint::Url, default_value = "ws://127.0.0.1:9944")] + node_rpc_url: String, + /// Cache group managed by this controller, each controller must have its dedicated cache group + /// and there should be just a single controller per cache group or else they may conflict with + /// each other and cause unnecessary cache writes. + /// + /// It is strongly recommended to use alphanumeric values for cache group, the same cache group + /// must be also specified on corresponding caches. + #[arg(long, default_value = "default")] + cache_group: String, + /// Network parameters + #[clap(flatten)] + network_args: NetworkArgs, + /// Sets some flags that are convenient during development, currently `--allow-private-ips` + #[arg(long)] + dev: bool, + /// Run temporary controller identity + #[arg(long, conflicts_with = "base_path")] + tmp: bool, + /// Additional cluster components + #[clap(raw = true)] + pub(super) additional_components: Vec, +} + +pub(super) async fn controller( + nats_client: NatsClient, + registry: &mut Registry, + controller_args: ControllerArgs, +) -> anyhow::Result>>>> { + let ControllerArgs { + base_path, + node_rpc_url, + cache_group, + mut network_args, + dev, + tmp, + additional_components: _, + } = controller_args; + + // Override flags with `--dev` + network_args.allow_private_ips = network_args.allow_private_ips || dev; + + let (base_path, tmp_directory) = if tmp { + let tmp_directory = tempfile::Builder::new() + .prefix("subspace-cluster-controller-") + .tempdir()?; + + (tmp_directory.as_ref().to_path_buf(), Some(tmp_directory)) + } else { + let Some(base_path) = base_path else { + return Err(anyhow!("--base-path must be specified explicitly")); + }; + + (base_path, None) + }; + + let plotted_pieces = Arc::new(AsyncRwLock::new(PlottedPieces::::default())); + + info!(url = %node_rpc_url, "Connecting to node RPC"); + let node_client = NodeRpcClient::new(&node_rpc_url).await?; + + let farmer_app_info = node_client + .farmer_app_info() + .await + .map_err(|error| anyhow!("Failed to get farmer app info: {error}"))?; + + let identity = Identity::open_or_create(&base_path) + .map_err(|error| anyhow!("Failed to open or create identity: {error}"))?; + let keypair = derive_libp2p_keypair(identity.secret_key()); + let peer_id = keypair.public().to_peer_id(); + let instance = peer_id.to_string(); + + let (farmer_cache, farmer_cache_worker) = FarmerCache::new(node_client.clone(), peer_id); + + // TODO: Metrics + + let (node, mut node_runner) = { + if network_args.bootstrap_nodes.is_empty() { + network_args + .bootstrap_nodes + .clone_from(&farmer_app_info.dsn_bootstrap_nodes); + } + + configure_network( + hex::encode(farmer_app_info.genesis_hash), + &base_path, + keypair, + network_args, + Arc::downgrade(&plotted_pieces), + node_client.clone(), + farmer_cache.clone(), + Some(registry), + )? + }; + + let kzg = Kzg::new(embedded_kzg_settings()); + let validator = Some(SegmentCommitmentPieceValidator::new( + node.clone(), + node_client.clone(), + kzg.clone(), + )); + let piece_provider = PieceProvider::new(node.clone(), validator.clone()); + + let piece_getter = FarmerPieceGetter::new( + piece_provider, + farmer_cache.clone(), + node_client.clone(), + Arc::clone(&plotted_pieces), + DsnCacheRetryPolicy { + max_retries: PIECE_GETTER_MAX_RETRIES, + backoff: ExponentialBackoff { + initial_interval: GET_PIECE_INITIAL_INTERVAL, + max_interval: GET_PIECE_MAX_INTERVAL, + // Try until we get a valid piece + max_elapsed_time: None, + multiplier: 1.75, + ..ExponentialBackoff::default() + }, + }, + ); + + let farmer_cache_worker_fut = run_future_in_dedicated_thread( + { + let future = farmer_cache_worker.run(piece_getter.downgrade()); + + move || future + }, + "controller-cache-worker".to_string(), + )?; + + let controller_service_fut = run_future_in_dedicated_thread( + { + let nats_client = nats_client.clone(); + let instance = instance.clone(); + + move || async move { + controller_service(&nats_client, &node_client, &piece_getter, &instance).await + } + }, + "controller-service".to_string(), + )?; + + let farms_fut = run_future_in_dedicated_thread( + { + let nats_client = nats_client.clone(); + + move || async move { maintain_farms(&instance, &nats_client, &plotted_pieces).await } + }, + "controller-farms".to_string(), + )?; + + let caches_fut = run_future_in_dedicated_thread( + move || async move { maintain_caches(&cache_group, &nats_client, farmer_cache).await }, + "controller-caches".to_string(), + )?; + + let networking_fut = run_future_in_dedicated_thread( + move || async move { node_runner.run().await }, + "controller-networking".to_string(), + )?; + + Ok(Box::pin(async move { + // This defines order in which things are dropped + let networking_fut = networking_fut; + let farms_fut = farms_fut; + let caches_fut = caches_fut; + let farmer_cache_worker_fut = farmer_cache_worker_fut; + let controller_service_fut = controller_service_fut; + + let networking_fut = pin!(networking_fut); + let farms_fut = pin!(farms_fut); + let caches_fut = pin!(caches_fut); + let farmer_cache_worker_fut = pin!(farmer_cache_worker_fut); + let controller_service_fut = pin!(controller_service_fut); + + select! { + // Networking future + _ = networking_fut.fuse() => { + info!("Node runner exited.") + }, + + // Farms future + result = farms_fut.fuse() => { + result??; + }, + + // Caches future + result = caches_fut.fuse() => { + result??; + }, + + // Piece cache worker future + _ = farmer_cache_worker_fut.fuse() => { + info!("Farmer cache worker exited.") + }, + + // Controller service future + result = controller_service_fut.fuse() => { + result??; + }, + } + + drop(tmp_directory); + + Ok(()) + })) +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/caches.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/caches.rs new file mode 100644 index 0000000000..543eeeeda7 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/caches.rs @@ -0,0 +1,201 @@ +//! This module exposed implementation of caches maintenance. +//! +//! The goal is to observe caches in a particular cache group and keep controller's data structures +//! about which pieces are stored where up to date. Implementation automatically handles dynamic +//! cache addition and removal, tries to reduce number of reinitializations that result in potential +//! piece cache sync, etc. + +use crate::commands::cluster::cache::CACHE_IDENTIFICATION_BROADCAST_INTERVAL; +use anyhow::anyhow; +use futures::channel::oneshot; +use futures::future::FusedFuture; +use futures::{select, FutureExt, StreamExt}; +use parking_lot::Mutex; +use std::future::{ready, Future}; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::{Duration, Instant}; +use subspace_farmer::cluster::cache::{ + ClusterCacheId, ClusterCacheIdentifyBroadcast, ClusterPieceCache, +}; +use subspace_farmer::cluster::controller::ClusterControllerCacheIdentifyBroadcast; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::farm::PieceCache; +use subspace_farmer::farmer_cache::FarmerCache; +use tokio::time::MissedTickBehavior; +use tracing::{info, trace, warn}; + +const SCHEDULE_REINITIALIZATION_DELAY: Duration = Duration::from_secs(3); + +#[derive(Debug)] +struct KnownCache { + cache_id: ClusterCacheId, + last_identification: Instant, + piece_cache: Arc, +} + +#[derive(Debug, Default)] +struct KnownCaches { + known_caches: Vec, +} + +impl KnownCaches { + fn get_all(&self) -> Vec> { + self.known_caches + .iter() + .map(|known_cache| Arc::clone(&known_cache.piece_cache) as Arc<_>) + .collect() + } + + /// Return `true` if farmer cache reinitialization is required + fn update( + &mut self, + cache_id: ClusterCacheId, + max_num_elements: u32, + nats_client: &NatsClient, + ) -> bool { + if self.known_caches.iter_mut().any(|known_cache| { + if known_cache.cache_id == cache_id { + known_cache.last_identification = Instant::now(); + true + } else { + false + } + }) { + return false; + } + + let piece_cache = Arc::new(ClusterPieceCache::new( + cache_id, + max_num_elements, + nats_client.clone(), + )); + self.known_caches.push(KnownCache { + cache_id, + last_identification: Instant::now(), + piece_cache, + }); + true + } + + fn remove_expired(&mut self) -> impl Iterator + '_ { + self.known_caches.extract_if(|known_cache| { + known_cache.last_identification.elapsed() > CACHE_IDENTIFICATION_BROADCAST_INTERVAL * 2 + }) + } +} + +pub(super) async fn maintain_caches( + cache_group: &str, + nats_client: &NatsClient, + farmer_cache: FarmerCache, +) -> anyhow::Result<()> { + let mut known_caches = KnownCaches::default(); + + let mut scheduled_reinitialization_for = None; + // Farm that is being added/removed right now (if any) + let mut cache_reinitialization = + (Box::pin(ready(())) as Pin>>).fuse(); + + let cache_identify_subscription = pin!(nats_client + .subscribe_to_broadcasts::(None, None) + .await + .map_err(|error| anyhow!("Failed to subscribe to cache identify broadcast: {error}"))?); + + // Request cache to identify themselves + if let Err(error) = nats_client + .broadcast(&ClusterControllerCacheIdentifyBroadcast, cache_group) + .await + { + warn!(%error, "Failed to send cache identification broadcast"); + } + + let mut cache_identify_subscription = cache_identify_subscription.fuse(); + let mut cache_pruning_interval = tokio::time::interval_at( + (Instant::now() + CACHE_IDENTIFICATION_BROADCAST_INTERVAL * 2).into(), + CACHE_IDENTIFICATION_BROADCAST_INTERVAL * 2, + ); + cache_pruning_interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + + loop { + if cache_reinitialization.is_terminated() + && let Some(time) = scheduled_reinitialization_for + && time >= Instant::now() + { + scheduled_reinitialization_for.take(); + + let new_piece_caches = known_caches.get_all(); + let new_cache_reinitialization = async { + let (sync_finish_sender, sync_finish_receiver) = oneshot::channel::<()>(); + let sync_finish_sender = Mutex::new(Some(sync_finish_sender)); + + let _handler_id = farmer_cache.on_sync_progress(Arc::new(move |&progress| { + if progress == 100.0 { + if let Some(sync_finish_sender) = sync_finish_sender.lock().take() { + // Result doesn't matter + let _ = sync_finish_sender.send(()); + } + } + })); + + farmer_cache + .replace_backing_caches(new_piece_caches, Vec::new()) + .await; + + // Wait for piece cache sync to finish before potentially staring a new one, result + // doesn't matter + let _ = sync_finish_receiver.await; + }; + + cache_reinitialization = + (Box::pin(new_cache_reinitialization) as Pin>>).fuse(); + } + + select! { + maybe_identify_message = cache_identify_subscription.next() => { + let Some(identify_message) = maybe_identify_message else { + return Err(anyhow!("Cache identify stream ended")); + }; + + let ClusterCacheIdentifyBroadcast { + cache_id, + max_num_elements, + } = identify_message; + if known_caches.update(cache_id, max_num_elements, nats_client) { + info!( + %cache_id, + "New cache discovered, scheduling reinitialization" + ); + scheduled_reinitialization_for.replace( + Instant::now() + SCHEDULE_REINITIALIZATION_DELAY, + ); + } else { + trace!( + %cache_id, + "Received identification for already known cache" + ); + } + } + _ = cache_pruning_interval.tick().fuse() => { + let mut reinit = false; + for removed_cache in known_caches.remove_expired() { + reinit = true; + + warn!( + cache_id = %removed_cache.cache_id, + "Cache expired and removed, scheduling reinitialization" + ); + } + + if reinit { + scheduled_reinitialization_for.replace( + Instant::now() + SCHEDULE_REINITIALIZATION_DELAY, + ); + } + } + _ = cache_reinitialization => { + // Nothing left to do + } + } + } +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/farms.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/farms.rs new file mode 100644 index 0000000000..a85c43b384 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller/farms.rs @@ -0,0 +1,393 @@ +//! This module exposed implementation of farms maintenance. +//! +//! The goal is to observe farms in a cluster and keep controller's data structures +//! about which pieces are plotted in which sectors of which farm up to date. Implementation +//! automatically handles dynamic farm addition and removal, etc. + +use crate::commands::cluster::farmer::FARMER_IDENTIFICATION_BROADCAST_INTERVAL; +use anyhow::anyhow; +use async_lock::RwLock as AsyncRwLock; +use futures::channel::oneshot; +use futures::future::FusedFuture; +use futures::stream::FuturesUnordered; +use futures::{select, FutureExt, StreamExt}; +use parking_lot::Mutex; +use std::collections::hash_map::Entry; +use std::collections::{HashMap, VecDeque}; +use std::future::{pending, ready, Future}; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::Instant; +use subspace_core_primitives::{Blake3Hash, SectorIndex}; +use subspace_farmer::cluster::controller::ClusterControllerFarmerIdentifyBroadcast; +use subspace_farmer::cluster::farmer::{ClusterFarm, ClusterFarmerIdentifyFarmBroadcast}; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::farm::{Farm, FarmId, SectorPlottingDetails, SectorUpdate}; +use subspace_farmer::utils::plotted_pieces::PlottedPieces; +use tokio::time::MissedTickBehavior; +use tracing::{error, info, trace, warn}; + +type AddRemoveFuture<'a> = + Pin, Box)>> + 'a>>; + +pub(super) type FarmIndex = u16; + +#[derive(Debug)] +struct KnownFarm { + farm_id: FarmId, + fingerprint: Blake3Hash, + last_identification: Instant, + expired_sender: oneshot::Sender<()>, +} + +enum KnownFarmInsertResult { + Inserted { + farm_index: FarmIndex, + expired_receiver: oneshot::Receiver<()>, + }, + FingerprintUpdated { + farm_index: FarmIndex, + expired_receiver: oneshot::Receiver<()>, + }, + NotInserted, +} + +#[derive(Debug, Default)] +struct KnownFarms { + known_farms: HashMap, +} + +impl KnownFarms { + fn insert_or_update( + &mut self, + farm_id: FarmId, + fingerprint: Blake3Hash, + ) -> KnownFarmInsertResult { + if let Some(existing_result) = + self.known_farms + .iter_mut() + .find_map(|(&farm_index, known_farm)| { + if known_farm.farm_id == farm_id { + if known_farm.fingerprint == fingerprint { + known_farm.last_identification = Instant::now(); + Some(KnownFarmInsertResult::NotInserted) + } else { + let (expired_sender, expired_receiver) = oneshot::channel(); + + known_farm.fingerprint = fingerprint; + known_farm.expired_sender = expired_sender; + + Some(KnownFarmInsertResult::FingerprintUpdated { + farm_index, + expired_receiver, + }) + } + } else { + None + } + }) + { + return existing_result; + } + + for farm_index in FarmIndex::MIN..=FarmIndex::MAX { + if let Entry::Vacant(entry) = self.known_farms.entry(farm_index) { + let (expired_sender, expired_receiver) = oneshot::channel(); + + entry.insert(KnownFarm { + farm_id, + fingerprint, + last_identification: Instant::now(), + expired_sender, + }); + + return KnownFarmInsertResult::Inserted { + farm_index, + expired_receiver, + }; + } + } + + warn!(%farm_id, max_supported_farm_index = %FarmIndex::MAX, "Too many farms, ignoring"); + KnownFarmInsertResult::NotInserted + } + + fn remove_expired(&mut self) -> impl Iterator + '_ { + self.known_farms.extract_if(|_farm_index, known_farm| { + known_farm.last_identification.elapsed() > FARMER_IDENTIFICATION_BROADCAST_INTERVAL * 2 + }) + } + + fn remove(&mut self, farm_index: FarmIndex) { + self.known_farms.remove(&farm_index); + } +} + +pub(super) async fn maintain_farms( + instance: &str, + nats_client: &NatsClient, + plotted_pieces: &AsyncRwLock>, +) -> anyhow::Result<()> { + let mut known_farms = KnownFarms::default(); + + // Futures that need to be processed sequentially in order to add/remove farms, if farm was + // added, future will resolve with `Some`, `None` if removed + let mut farms_to_add_remove = VecDeque::::new(); + // Farm that is being added/removed right now (if any) + let mut farm_add_remove_in_progress = (Box::pin(ready(None)) as AddRemoveFuture).fuse(); + // Initialize with pending future so it never ends + let mut farms = FuturesUnordered::from_iter([ + Box::pin(pending()) as Pin)>>> + ]); + + let farmer_identify_subscription = pin!(nats_client + .subscribe_to_broadcasts::(None, None) + .await + .map_err(|error| anyhow!( + "Failed to subscribe to farmer identify farm broadcast: {error}" + ))?); + + // Request farmer to identify themselves + if let Err(error) = nats_client + .broadcast(&ClusterControllerFarmerIdentifyBroadcast, instance) + .await + { + warn!(%error, "Failed to send farmer identification broadcast"); + } + + let mut farmer_identify_subscription = farmer_identify_subscription.fuse(); + let mut farm_pruning_interval = tokio::time::interval_at( + (Instant::now() + FARMER_IDENTIFICATION_BROADCAST_INTERVAL * 2).into(), + FARMER_IDENTIFICATION_BROADCAST_INTERVAL * 2, + ); + farm_pruning_interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + + loop { + if farm_add_remove_in_progress.is_terminated() { + if let Some(fut) = farms_to_add_remove.pop_front() { + farm_add_remove_in_progress = fut.fuse(); + } + } + + select! { + (farm_index, result) = farms.select_next_some() => { + known_farms.remove(farm_index); + farms_to_add_remove.push_back(Box::pin(async move { + plotted_pieces.write().await.delete_farm(farm_index); + + None + })); + + match result { + Ok(()) => { + info!(%farm_index, "Farm exited successfully"); + } + Err(error) => { + error!(%farm_index, %error, "Farm exited with error"); + } + } + } + maybe_identify_message = farmer_identify_subscription.next() => { + let Some(identify_message) = maybe_identify_message else { + return Err(anyhow!("Farmer identify stream ended")); + }; + + process_farm_identify_message( + identify_message, + nats_client, + &mut known_farms, + &mut farms_to_add_remove, + plotted_pieces, + ); + } + _ = farm_pruning_interval.tick().fuse() => { + for (farm_index, removed_farm) in known_farms.remove_expired() { + if removed_farm.expired_sender.send(()).is_ok() { + warn!( + %farm_index, + farm_id = %removed_farm.farm_id, + "Farm expired and removed" + ); + } else { + warn!( + %farm_index, + farm_id = %removed_farm.farm_id, + "Farm exited before expiration notification" + ); + } + plotted_pieces.write().await.delete_farm(farm_index); + } + } + result = farm_add_remove_in_progress => { + if let Some((farm_index, expired_receiver, farm)) = result { + farms.push(Box::pin(async move { + select! { + result = farm.run().fuse() => { + (farm_index, result) + } + _ = expired_receiver.fuse() => { + // Nothing to do + (farm_index, Ok(())) + } + } + })); + } + } + } + } +} + +fn process_farm_identify_message<'a>( + identify_message: ClusterFarmerIdentifyFarmBroadcast, + nats_client: &'a NatsClient, + known_farms: &mut KnownFarms, + farms_to_add_remove: &mut VecDeque>, + plotted_pieces: &'a AsyncRwLock>, +) { + let ClusterFarmerIdentifyFarmBroadcast { + farm_id, + total_sectors_count, + fingerprint, + } = identify_message; + let (farm_index, expired_receiver, add, remove) = + match known_farms.insert_or_update(farm_id, fingerprint) { + KnownFarmInsertResult::Inserted { + farm_index, + expired_receiver, + } => { + info!( + %farm_index, + %farm_id, + "Discovered new farm, initializing" + ); + + (farm_index, expired_receiver, true, false) + } + KnownFarmInsertResult::FingerprintUpdated { + farm_index, + expired_receiver, + } => { + info!( + %farm_index, + %farm_id, + "Farm fingerprint updated, re-initializing" + ); + + (farm_index, expired_receiver, true, true) + } + KnownFarmInsertResult::NotInserted => { + trace!( + %farm_id, + "Received identification for already known farm" + ); + // Nothing to do here + return; + } + }; + + if remove { + farms_to_add_remove.push_back(Box::pin(async move { + plotted_pieces.write().await.delete_farm(farm_index); + + None + })); + } + + if add { + farms_to_add_remove.push_back(Box::pin(async move { + match initialize_farm( + farm_index, + farm_id, + total_sectors_count, + plotted_pieces, + nats_client, + ) + .await + { + Ok(farm) => { + if remove { + info!( + %farm_index, + %farm_id, + "Farm re-initialized successfully" + ); + } else { + info!( + %farm_index, + %farm_id, + "Farm initialized successfully" + ); + } + + Some((farm_index, expired_receiver, Box::new(farm) as Box<_>)) + } + Err(error) => { + warn!( + %error, + "Failed to initialize farm {farm_id}" + ); + None + } + } + })); + } +} + +async fn initialize_farm( + farm_index: FarmIndex, + farm_id: FarmId, + total_sectors_count: SectorIndex, + plotted_pieces: &AsyncRwLock>, + nats_client: &NatsClient, +) -> anyhow::Result { + let farm = ClusterFarm::new(farm_id, total_sectors_count, nats_client.clone()) + .await + .map_err(|error| anyhow!("Failed instantiate cluster farm {farm_id}: {error}"))?; + + let mut plotted_pieces = plotted_pieces.write().await; + plotted_pieces.add_farm(farm_index, farm.piece_reader()); + + // Buffer sectors that are plotted while already plotted sectors are being iterated over + let plotted_sectors_buffer = Arc::new(Mutex::new(Vec::new())); + let sector_update_handler = farm.on_sector_update(Arc::new({ + let plotted_sectors_buffer = Arc::clone(&plotted_sectors_buffer); + + move |(_sector_index, sector_update)| { + if let SectorUpdate::Plotting(SectorPlottingDetails::Finished { + plotted_sector, + old_plotted_sector, + .. + }) = sector_update + { + plotted_sectors_buffer + .lock() + .push((plotted_sector.clone(), old_plotted_sector.clone())); + } + } + })); + + // Add plotted sectors of the farm to global plotted pieces + let plotted_sectors = farm.plotted_sectors(); + let mut plotted_sectors = plotted_sectors + .get() + .await + .map_err(|error| anyhow!("Failed to get plotted sectors for farm {farm_id}: {error}"))?; + while let Some(plotted_sector_result) = plotted_sectors.next().await { + let plotted_sector = plotted_sector_result + .map_err(|error| anyhow!("Failed to get plotted sector for farm {farm_id}: {error}"))?; + + plotted_pieces.add_sector(farm_index, &plotted_sector); + } + + // Add sectors that were plotted while above iteration was happening to plotted sectors + // too + drop(sector_update_handler); + for (plotted_sector, old_plotted_sector) in plotted_sectors_buffer.lock().drain(..) { + if let Some(old_plotted_sector) = old_plotted_sector { + plotted_pieces.delete_sector(farm_index, &old_plotted_sector); + } + plotted_pieces.add_sector(farm_index, &plotted_sector); + } + + Ok(farm) +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/farmer.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/farmer.rs new file mode 100644 index 0000000000..2bc7a35944 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/farmer.rs @@ -0,0 +1,515 @@ +use crate::commands::shared::metrics::{FarmerMetrics, SectorState}; +use crate::commands::shared::DiskFarm; +use anyhow::anyhow; +use async_lock::Mutex as AsyncMutex; +use backoff::ExponentialBackoff; +use bytesize::ByteSize; +use clap::Parser; +use futures::stream::{FuturesOrdered, FuturesUnordered}; +use futures::{select, FutureExt, StreamExt, TryStreamExt}; +use prometheus_client::registry::Registry; +use std::fs; +use std::future::Future; +use std::num::NonZeroUsize; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::Duration; +use subspace_core_primitives::crypto::kzg::{embedded_kzg_settings, Kzg}; +use subspace_core_primitives::{PublicKey, Record}; +use subspace_erasure_coding::ErasureCoding; +use subspace_farmer::cluster::controller::ClusterNodeClient; +use subspace_farmer::cluster::farmer::farmer_service; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::cluster::plotter::ClusterPlotter; +use subspace_farmer::farm::{ + Farm, FarmingNotification, SectorExpirationDetails, SectorPlottingDetails, SectorUpdate, +}; +use subspace_farmer::node_client::NodeClient; +use subspace_farmer::single_disk_farm::{ + SingleDiskFarm, SingleDiskFarmError, SingleDiskFarmOptions, +}; +use subspace_farmer::utils::ss58::parse_ss58_reward_address; +use subspace_farmer::utils::{ + recommended_number_of_farming_threads, run_future_in_dedicated_thread, AsyncJoinOnDrop, +}; +use subspace_proof_of_space::Table; +use tokio::sync::{Barrier, Semaphore}; +use tracing::{error, info, info_span, warn, Instrument}; + +const FARM_ERROR_PRINT_INTERVAL: Duration = Duration::from_secs(30); +/// Interval between farmer self-identification broadcast messages +pub(super) const FARMER_IDENTIFICATION_BROADCAST_INTERVAL: Duration = Duration::from_secs(5); + +/// Arguments for farmer +#[derive(Debug, Parser)] +pub(super) struct FarmerArgs { + /// One or more farm located at specified path, each with its own allocated space. + /// + /// In case of multiple disks, it is recommended to specify them individually rather than using + /// RAID 0, that way farmer will be able to better take advantage of concurrency of individual + /// drives. + /// + /// Format for each farm is coma-separated list of strings like this: + /// + /// path=/path/to/directory,size=5T + /// + /// `size` is max allocated size in human-readable format (e.g. 10GB, 2TiB) or just bytes that + /// farmer will make sure to not exceed (and will pre-allocated all the space on startup to + /// ensure it will not run out of space in runtime). Optionally, `record-chunks-mode` can be + /// set to `ConcurrentChunks` or `WholeSector` in order to avoid internal benchmarking during + /// startup. + disk_farms: Vec, + /// Address for farming rewards + #[arg(long, value_parser = parse_ss58_reward_address)] + reward_address: PublicKey, + /// Run temporary farmer with specified farm size in human-readable format (e.g. 10GB, 2TiB) or + /// just bytes (e.g. 4096), this will create a temporary directory that will be deleted at the + /// end of the process. + #[arg(long, conflicts_with = "disk_farms")] + tmp: Option, + /// Maximum number of pieces in sector (can override protocol value to something lower). + /// + /// This will make plotting of individual sectors faster, decrease load on CPU proving, but also + /// proportionally increase amount of disk reads during audits since every sector needs to be + /// audited and there will be more of them. + /// + /// This is primarily for development and not recommended to use by regular users. + #[arg(long)] + max_pieces_in_sector: Option, + /// Do not print info about configured farms on startup + #[arg(long)] + no_info: bool, + /// Defines max number sectors farmer will encode concurrently, defaults to 8. Might be limited + /// by plotting capacity available in the cluster. + /// + /// Increase will result in higher memory usage. + #[arg(long, default_value = "8")] + sector_encoding_concurrency: NonZeroUsize, + /// Size of PER FARM thread pool used for farming (mostly for blocking I/O, but also for some + /// compute-intensive operations during proving), defaults to number of logical CPUs + /// available on UMA system and number of logical CPUs in first NUMA node on NUMA system, but + /// not more than 32 threads + #[arg(long)] + farming_thread_pool_size: Option, + /// Disable farm locking, for example if file system doesn't support it + #[arg(long)] + disable_farm_locking: bool, + /// Whether to create missing farms during start. + /// + /// If set to `false` farmer will exit with error if one of the farms doesn't already exist. + #[arg(long, default_value_t = true, action = clap::ArgAction::Set)] + create: bool, + /// Exit on farm error. + /// + /// By default, farmer will continue running if there are still other working farms. + #[arg(long)] + exit_on_farm_error: bool, + /// Additional cluster components + #[clap(raw = true)] + pub(super) additional_components: Vec, +} + +pub(super) async fn farmer( + nats_client: NatsClient, + registry: &mut Registry, + farmer_args: FarmerArgs, +) -> anyhow::Result>>>> +where + PosTable: Table, +{ + let FarmerArgs { + mut disk_farms, + reward_address, + tmp, + max_pieces_in_sector, + no_info, + sector_encoding_concurrency, + farming_thread_pool_size, + disable_farm_locking, + create, + exit_on_farm_error, + additional_components: _, + } = farmer_args; + + let tmp_directory = if let Some(plot_size) = tmp { + let tmp_directory = tempfile::Builder::new() + .prefix("subspace-farmer-") + .tempdir()?; + + disk_farms = vec![DiskFarm { + directory: tmp_directory.as_ref().to_path_buf(), + allocated_space: plot_size.as_u64(), + read_sector_record_chunks_mode: None, + }]; + + Some(tmp_directory) + } else { + if disk_farms.is_empty() { + return Err(anyhow!("There must be at least one disk farm provided")); + } + + for farm in &disk_farms { + if !farm.directory.exists() { + if let Err(error) = fs::create_dir(&farm.directory) { + return Err(anyhow!( + "Directory {} doesn't exist and can't be created: {}", + farm.directory.display(), + error + )); + } + } + } + None + }; + + let node_client = ClusterNodeClient::new(nats_client.clone()); + + let farmer_app_info = node_client + .farmer_app_info() + .await + .map_err(|error| anyhow!("Failed to get farmer app info: {error}"))?; + + let farmer_metrics = FarmerMetrics::new(registry); + + let kzg = Kzg::new(embedded_kzg_settings()); + let erasure_coding = ErasureCoding::new( + NonZeroUsize::new(Record::NUM_S_BUCKETS.next_power_of_two().ilog2() as usize) + .expect("Not zero; qed"), + ) + .map_err(|error| anyhow!("Failed to instantiate erasure coding: {error}"))?; + + let max_pieces_in_sector = match max_pieces_in_sector { + Some(max_pieces_in_sector) => { + if max_pieces_in_sector > farmer_app_info.protocol_info.max_pieces_in_sector { + warn!( + protocol_value = farmer_app_info.protocol_info.max_pieces_in_sector, + desired_value = max_pieces_in_sector, + "Can't set max pieces in sector higher than protocol value, using protocol \ + value" + ); + + farmer_app_info.protocol_info.max_pieces_in_sector + } else { + max_pieces_in_sector + } + } + None => farmer_app_info.protocol_info.max_pieces_in_sector, + }; + + let farming_thread_pool_size = farming_thread_pool_size + .map(|farming_thread_pool_size| farming_thread_pool_size.get()) + .unwrap_or_else(recommended_number_of_farming_threads); + + let global_mutex = Arc::default(); + let plotter = Arc::new(ClusterPlotter::new( + nats_client.clone(), + sector_encoding_concurrency, + ExponentialBackoff { + max_elapsed_time: None, + ..ExponentialBackoff::default() + }, + )); + + let farms = { + let node_client = node_client.clone(); + let info_mutex = &AsyncMutex::new(()); + let faster_read_sector_record_chunks_mode_barrier = + Arc::new(Barrier::new(disk_farms.len())); + let faster_read_sector_record_chunks_mode_concurrency = Arc::new(Semaphore::new(1)); + + let mut farms = Vec::with_capacity(disk_farms.len()); + let mut farms_stream = disk_farms + .into_iter() + .enumerate() + .map(|(farm_index, disk_farm)| { + let farmer_app_info = farmer_app_info.clone(); + let node_client = node_client.clone(); + let kzg = kzg.clone(); + let erasure_coding = erasure_coding.clone(); + let plotter = Arc::clone(&plotter); + let global_mutex = Arc::clone(&global_mutex); + let faster_read_sector_record_chunks_mode_barrier = + Arc::clone(&faster_read_sector_record_chunks_mode_barrier); + let faster_read_sector_record_chunks_mode_concurrency = + Arc::clone(&faster_read_sector_record_chunks_mode_concurrency); + + async move { + let farm_fut = SingleDiskFarm::new::<_, _, PosTable>( + SingleDiskFarmOptions { + directory: disk_farm.directory.clone(), + farmer_app_info, + allocated_space: disk_farm.allocated_space, + max_pieces_in_sector, + node_client, + reward_address, + kzg, + erasure_coding, + // Cache is provided by dedicated caches in farming cluster + cache_percentage: 0, + farming_thread_pool_size, + plotting_delay: None, + global_mutex, + disable_farm_locking, + read_sector_record_chunks_mode: disk_farm + .read_sector_record_chunks_mode, + faster_read_sector_record_chunks_mode_barrier, + faster_read_sector_record_chunks_mode_concurrency, + plotter, + create, + }, + farm_index, + ); + + let farm = match farm_fut.await { + Ok(farm) => farm, + Err(SingleDiskFarmError::InsufficientAllocatedSpace { + min_space, + allocated_space, + }) => { + return ( + farm_index, + Err(anyhow!( + "Allocated space {} ({}) is not enough, minimum is ~{} (~{}, \ + {} bytes to be exact)", + bytesize::to_string(allocated_space, true), + bytesize::to_string(allocated_space, false), + bytesize::to_string(min_space, true), + bytesize::to_string(min_space, false), + min_space + )), + ); + } + Err(error) => { + return (farm_index, Err(error.into())); + } + }; + + if !no_info { + let _info_guard = info_mutex.lock().await; + + let info = farm.info(); + info!("Farm {farm_index}:"); + info!(" ID: {}", info.id()); + info!(" Genesis hash: 0x{}", hex::encode(info.genesis_hash())); + info!(" Public key: 0x{}", hex::encode(info.public_key())); + info!( + " Allocated space: {} ({})", + bytesize::to_string(info.allocated_space(), true), + bytesize::to_string(info.allocated_space(), false) + ); + info!(" Directory: {}", disk_farm.directory.display()); + } + + (farm_index, Ok(Box::new(farm) as Box)) + } + .instrument(info_span!("", %farm_index)) + }) + .collect::>(); + + while let Some((farm_index, farm)) = farms_stream.next().await { + if let Err(error) = &farm { + let span = info_span!("", %farm_index); + let _span_guard = span.enter(); + + error!(%error, "Farm creation failed"); + } + farms.push((farm_index, farm?)); + } + + // Restore order after unordered initialization + farms.sort_unstable_by_key(|(farm_index, _farm)| *farm_index); + + farms + .into_iter() + .map(|(_farm_index, farm)| farm) + .collect::>() + }; + + let total_and_plotted_sectors = farms + .iter() + .enumerate() + .map(|(farm_index, farm)| async move { + let total_sector_count = farm.total_sectors_count(); + let mut plotted_sectors_count = 0; + let plotted_sectors = farm.plotted_sectors(); + let mut plotted_sectors = plotted_sectors.get().await.map_err(|error| { + anyhow!("Failed to get plotted sectors for farm {farm_index}: {error}") + })?; + while let Some(plotted_sector_result) = plotted_sectors.next().await { + plotted_sectors_count += 1; + plotted_sector_result.map_err(|error| { + anyhow!( + "Failed reading plotted sector on startup for farm {farm_index}: {error}" + ) + })?; + } + + anyhow::Ok((total_sector_count, plotted_sectors_count)) + }) + .collect::>() + .try_collect::>() + .await?; + + let farmer_service_fut = farmer_service( + nats_client, + farms.as_slice(), + FARMER_IDENTIFICATION_BROADCAST_INTERVAL, + ); + let farmer_service_fut = run_future_in_dedicated_thread( + move || farmer_service_fut, + "controller-service".to_string(), + )?; + + let mut farms_stream = (0u8..) + .zip(farms) + .zip(total_and_plotted_sectors) + .map(|((farm_index, farm), sector_counts)| { + let (total_sector_count, plotted_sectors_count) = sector_counts; + farmer_metrics.update_sectors_total( + farm.id(), + total_sector_count - plotted_sectors_count, + SectorState::NotPlotted, + ); + farmer_metrics.update_sectors_total( + farm.id(), + plotted_sectors_count, + SectorState::Plotted, + ); + farm.on_sector_update(Arc::new({ + let farm_id = *farm.id(); + let farmer_metrics = farmer_metrics.clone(); + + move |(_sector_index, sector_state)| match sector_state { + SectorUpdate::Plotting(SectorPlottingDetails::Starting { .. }) => { + farmer_metrics.sector_plotting.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Downloading) => { + farmer_metrics.sector_downloading.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Downloaded(time)) => { + farmer_metrics.observe_sector_downloading_time(&farm_id, time); + farmer_metrics.sector_downloaded.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Encoding) => { + farmer_metrics.sector_encoding.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Encoded(time)) => { + farmer_metrics.observe_sector_encoding_time(&farm_id, time); + farmer_metrics.sector_encoded.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Writing) => { + farmer_metrics.sector_writing.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Written(time)) => { + farmer_metrics.observe_sector_writing_time(&farm_id, time); + farmer_metrics.sector_written.inc(); + } + SectorUpdate::Plotting(SectorPlottingDetails::Finished { time, .. }) => { + farmer_metrics.observe_sector_plotting_time(&farm_id, time); + farmer_metrics.sector_plotted.inc(); + farmer_metrics.update_sector_state(&farm_id, SectorState::Plotted); + } + SectorUpdate::Plotting(SectorPlottingDetails::Error(_)) => { + farmer_metrics.sector_plotting_error.inc(); + } + SectorUpdate::Expiration(SectorExpirationDetails::AboutToExpire) => { + farmer_metrics.update_sector_state(&farm_id, SectorState::AboutToExpire); + } + SectorUpdate::Expiration(SectorExpirationDetails::Expired) => { + farmer_metrics.update_sector_state(&farm_id, SectorState::Expired); + } + SectorUpdate::Expiration(SectorExpirationDetails::Determined { .. }) => { + // Not interested in here + } + } + })) + .detach(); + + farm.on_farming_notification(Arc::new({ + let farm_id = *farm.id(); + let farmer_metrics = farmer_metrics.clone(); + + move |farming_notification| match farming_notification { + FarmingNotification::Auditing(auditing_details) => { + farmer_metrics.observe_auditing_time(&farm_id, &auditing_details.time); + } + FarmingNotification::Proving(proving_details) => { + farmer_metrics.observe_proving_time( + &farm_id, + &proving_details.time, + proving_details.result, + ); + } + FarmingNotification::NonFatalError(error) => { + farmer_metrics.note_farming_error(&farm_id, error); + } + } + })) + .detach(); + + farm.run().map(move |result| (farm_index, result)) + }) + .collect::>(); + + let mut farm_errors = Vec::new(); + + let farm_fut = run_future_in_dedicated_thread( + move || async move { + while let Some((farm_index, result)) = farms_stream.next().await { + match result { + Ok(()) => { + info!(%farm_index, "Farm exited successfully"); + } + Err(error) => { + error!(%farm_index, %error, "Farm exited with error"); + + if farms_stream.is_empty() || exit_on_farm_error { + return Err(error); + } else { + farm_errors.push(AsyncJoinOnDrop::new( + tokio::spawn(async move { + loop { + tokio::time::sleep(FARM_ERROR_PRINT_INTERVAL).await; + + error!( + %farm_index, + %error, + "Farm errored and stopped" + ); + } + }), + true, + )) + } + } + } + } + anyhow::Ok(()) + }, + "farmer-farm".to_string(), + )?; + + Ok(Box::pin(async move { + let farm_fut = farm_fut; + let farmer_service_fut = farmer_service_fut; + + let farm_fut = pin!(farm_fut); + let farmer_service_fut = pin!(farmer_service_fut); + + select! { + // Farm future + result = farm_fut.fuse() => { + result??; + }, + + // Piece cache worker future + result = farmer_service_fut.fuse() => { + result??; + }, + } + + drop(tmp_directory); + + Ok(()) + })) +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/plotter.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/plotter.rs new file mode 100644 index 0000000000..4ce94a2db1 --- /dev/null +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/plotter.rs @@ -0,0 +1,178 @@ +use crate::commands::shared::PlottingThreadPriority; +use anyhow::anyhow; +use clap::Parser; +use prometheus_client::registry::Registry; +use std::future::Future; +use std::num::NonZeroUsize; +use std::pin::Pin; +use std::sync::Arc; +use subspace_core_primitives::crypto::kzg::{embedded_kzg_settings, Kzg}; +use subspace_core_primitives::Record; +use subspace_erasure_coding::ErasureCoding; +use subspace_farmer::cluster::controller::ClusterPieceGetter; +use subspace_farmer::cluster::nats_client::NatsClient; +use subspace_farmer::cluster::plotter::plotter_service; +use subspace_farmer::plotter::cpu::CpuPlotter; +use subspace_farmer::utils::{ + create_plotting_thread_pool_manager, parse_cpu_cores_sets, thread_pool_core_indices, +}; +use subspace_proof_of_space::Table; +use tokio::sync::Semaphore; +use tracing::info; + +/// Arguments for plotter +#[derive(Debug, Parser)] +pub(super) struct PlotterArgs { + /// Piece getter concurrency. + /// + /// Increase can result in NATS communication issues if too many messages arrive via NATS, but + /// are not processed quickly enough for some reason and might require increasing cluster-level + /// `--nats-pool-size` parameter. + #[arg(long, default_value = "100")] + piece_getter_concurrency: NonZeroUsize, + /// Defines how many sectors farmer will download concurrently, allows to limit memory usage of + /// the plotting process, defaults to `--sector-encoding-concurrency` + 1 to download future + /// sector ahead of time. + /// + /// Increase will result in higher memory usage. + #[arg(long)] + sector_downloading_concurrency: Option, + /// Defines how many sectors farmer will encode concurrently, defaults to 1 on UMA system and + /// number of NUMA nodes on NUMA system or L3 cache groups on large CPUs. It is further + /// restricted by + /// `--sector-downloading-concurrency` and setting this option higher than + /// `--sector-downloading-concurrency` will have no effect. + /// + /// Increase will result in higher memory usage. + #[arg(long)] + sector_encoding_concurrency: Option, + /// Defines how many records farmer will encode in a single sector concurrently, defaults to one + /// record per 2 cores, but not more than 8 in total. Higher concurrency means higher memory + /// usage and typically more efficient CPU utilization. + #[arg(long)] + record_encoding_concurrency: Option, + /// Size of one thread pool used for plotting, defaults to number of logical CPUs available + /// on UMA system and number of logical CPUs available in NUMA node on NUMA system or L3 cache + /// groups on large CPUs. + /// + /// Number of thread pools is defined by `--sector-encoding-concurrency` option, different + /// thread pools might have different number of threads if NUMA nodes do not have the same size. + /// + /// Threads will be pinned to corresponding CPU cores at creation. + #[arg(long)] + plotting_thread_pool_size: Option, + /// Specify exact CPU cores to be used for plotting bypassing any custom logic farmer might use + /// otherwise. It replaces both `--sector-encoding-concurrency` and + /// `--plotting-thread-pool-size` options if specified. Requires `--replotting-cpu-cores` to be + /// specified with the same number of CPU cores groups (or not specified at all, in which case + /// it'll use the same thread pool as plotting). + /// + /// Cores are coma-separated, with whitespace separating different thread pools/encoding + /// instances. For example "0,1 2,3" will result in two sectors being encoded at the same time, + /// each with a pair of CPU cores. + #[arg(long, conflicts_with_all = & ["sector_encoding_concurrency", "plotting_thread_pool_size"])] + plotting_cpu_cores: Option, + /// Plotting thread priority, by default de-prioritizes plotting threads in order to make sure + /// farming is successful and computer can be used comfortably for other things. Can be set to + /// "min", "max" or "default". + #[arg(long, default_value_t = PlottingThreadPriority::Min)] + plotting_thread_priority: PlottingThreadPriority, + /// Additional cluster components + #[clap(raw = true)] + pub(super) additional_components: Vec, +} + +pub(super) async fn plotter( + nats_client: NatsClient, + _registry: &mut Registry, + plotter_args: PlotterArgs, +) -> anyhow::Result>>>> +where + PosTable: Table, +{ + let PlotterArgs { + piece_getter_concurrency, + sector_downloading_concurrency, + sector_encoding_concurrency, + record_encoding_concurrency, + plotting_thread_pool_size, + plotting_cpu_cores, + plotting_thread_priority, + additional_components: _, + } = plotter_args; + + let kzg = Kzg::new(embedded_kzg_settings()); + let erasure_coding = ErasureCoding::new( + NonZeroUsize::new(Record::NUM_S_BUCKETS.next_power_of_two().ilog2() as usize) + .expect("Not zero; qed"), + ) + .map_err(|error| anyhow!("Failed to instantiate erasure coding: {error}"))?; + let piece_getter = ClusterPieceGetter::new(nats_client.clone(), piece_getter_concurrency); + + let plotting_thread_pool_core_indices; + if let Some(plotting_cpu_cores) = plotting_cpu_cores { + plotting_thread_pool_core_indices = parse_cpu_cores_sets(&plotting_cpu_cores) + .map_err(|error| anyhow!("Failed to parse `--plotting-cpu-cores`: {error}"))?; + } else { + plotting_thread_pool_core_indices = + thread_pool_core_indices(plotting_thread_pool_size, sector_encoding_concurrency); + + if plotting_thread_pool_core_indices.len() > 1 { + info!( + l3_cache_groups = %plotting_thread_pool_core_indices.len(), + "Multiple L3 cache groups detected" + ); + } + } + + let downloading_semaphore = Arc::new(Semaphore::new( + sector_downloading_concurrency + .map(|sector_downloading_concurrency| sector_downloading_concurrency.get()) + .unwrap_or(plotting_thread_pool_core_indices.len() + 1), + )); + + let record_encoding_concurrency = record_encoding_concurrency.unwrap_or_else(|| { + let cpu_cores = plotting_thread_pool_core_indices + .first() + .expect("Guaranteed to have some CPU cores; qed"); + + NonZeroUsize::new((cpu_cores.cpu_cores().len() / 2).clamp(1, 8)).expect("Not zero; qed") + }); + + info!( + ?plotting_thread_pool_core_indices, + "Preparing plotting thread pools" + ); + + let replotting_thread_pool_core_indices = plotting_thread_pool_core_indices + .clone() + .into_iter() + .map(|mut cpu_core_set| { + // We'll not use replotting threads at all, so just limit them to 1 core so we don't + // have too many threads hanging unnecessarily + cpu_core_set.truncate(1); + cpu_core_set + }); + let plotting_thread_pool_manager = create_plotting_thread_pool_manager( + plotting_thread_pool_core_indices + .into_iter() + .zip(replotting_thread_pool_core_indices), + plotting_thread_priority.into(), + )?; + let global_mutex = Arc::default(); + let cpu_plotter = CpuPlotter::<_, PosTable>::new( + piece_getter, + downloading_semaphore, + plotting_thread_pool_manager, + record_encoding_concurrency, + Arc::clone(&global_mutex), + kzg.clone(), + erasure_coding.clone(), + ); + + // TODO: Metrics + + Ok(Box::pin(async move { + plotter_service(&nats_client, &cpu_plotter).await + })) +} diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/farm.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/farm.rs index e5409fa800..ce07e9d06b 100644 --- a/crates/subspace-farmer/src/bin/subspace-farmer/commands/farm.rs +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/farm.rs @@ -131,7 +131,7 @@ pub(crate) struct FarmingArgs { /// Increase will result in higher memory usage. #[arg(long)] sector_encoding_concurrency: Option, - /// Defines how many record farmer will encode in a single sector concurrently, defaults to one + /// Defines how many records farmer will encode in a single sector concurrently, defaults to one /// record per 2 cores, but not more than 8 in total. Higher concurrency means higher memory /// usage and typically more efficient CPU utilization. #[arg(long)] @@ -184,7 +184,8 @@ pub(crate) struct FarmingArgs { #[arg(long, conflicts_with_all = & ["sector_encoding_concurrency", "replotting_thread_pool_size"])] replotting_cpu_cores: Option, /// Plotting thread priority, by default de-prioritizes plotting threads in order to make sure - /// farming is successful and computer can be used comfortably for other things + /// farming is successful and computer can be used comfortably for other things. Can be set to + /// "min", "max" or "default". #[arg(long, default_value_t = PlottingThreadPriority::Min)] plotting_thread_priority: PlottingThreadPriority, /// Enable plot cache. diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/main.rs b/crates/subspace-farmer/src/bin/subspace-farmer/main.rs index 2f368efd1f..3522f376a0 100644 --- a/crates/subspace-farmer/src/bin/subspace-farmer/main.rs +++ b/crates/subspace-farmer/src/bin/subspace-farmer/main.rs @@ -1,4 +1,10 @@ -#![feature(const_option, type_changing_struct_update)] +#![feature( + const_option, + extract_if, + hash_extract_if, + let_chains, + type_changing_struct_update +)] mod commands; mod utils; @@ -24,6 +30,8 @@ type PosTable = ChiaTable; enum Command { /// Start a farmer, does plotting and farming Farm(commands::farm::FarmingArgs), + /// Farming cluster + Cluster(commands::cluster::ClusterArgs), /// Run various benchmarks #[clap(subcommand)] Benchmark(commands::benchmark::BenchmarkArgs), @@ -86,6 +94,9 @@ async fn main() -> anyhow::Result<()> { Command::Farm(farming_args) => { commands::farm::farm::(farming_args).await?; } + Command::Cluster(cluster_args) => { + commands::cluster::cluster::(cluster_args).await?; + } Command::Benchmark(benchmark_args) => { commands::benchmark::benchmark(benchmark_args)?; } diff --git a/crates/subspace-farmer/src/cluster.rs b/crates/subspace-farmer/src/cluster.rs index 313273ca26..2de6eead0e 100644 --- a/crates/subspace-farmer/src/cluster.rs +++ b/crates/subspace-farmer/src/cluster.rs @@ -1 +1,57 @@ +//! Cluster version of the farmer +//! +//! This module contains isolated set of modules that implement cluster-specific functionality for +//! the farmer, allowing to distribute cooperating components across machines, while still working +//! together. +//! +//! Specifically, 4 separate components are extracted: +//! * controller +//! * farmer +//! * plotter +//! * cache +//! +//! ### Controller +//! +//! Controller connects to the node via RPC and DSN. It handles notifications from node and +//! orchestrates other components. It will send slot notifications to farmers, store and retrieve +//! pieces from caches on requests from DSN, etc. +//! +//! While there could be multiple controllers shared between farmers, each controller must have its +//! dedicated pool of caches and each cache should belong to a single controller. This allows to +//! shut down some controllers for upgrades and other maintenance tasks without affecting farmer's +//! ability to farm and receive rewards. +//! +//! ### Farmer +//! +//! Farmer maintains farms with plotted pieces and corresponding metadata. Farmer does audits and +//! proving, retrieves pieces from plotted sectors on request, but doesn’t do any caching or P2P +//! networking with DSN. When sectors need to be plotted/replotted, request will be sent to Plotter +//! to do that instead of doing it locally, though plotter and farmer can be co-located. +//! +//! Farmers receive (de-duplicated) slot notifications from all controllers and will send solution +//! back to the controller from which they received slot notification. +//! +//! ### Plotter +//! +//! Plotter needs to be able to do heavy compute with proportional amount of RAM for plotting +//! purposes. +//! +//! There could be any number of plotters in a cluster, adding more will increase total cluster +//! ability to plot concurrent sectors. +//! +//! ### Cache +//! +//! Cache helps with plotting process and with serving data to DSN. At the same time, writes and +//! reads are while random, they are done in large size and low frequency comparing in contrast to +//! farmer. Fast retrieval is important for plotters to not stay idle, but generally cache can work +//! even on HDDs. +//! +//! There could be any number of caches in the cluster, but each cache instance belongs to one of +//! the controllers. So if multiple controllers are present in the cluster, you'll want at least one +//! cache connected to each as well for optimal performance. + +pub mod cache; +pub mod controller; +pub mod farmer; pub mod nats_client; +pub mod plotter; diff --git a/crates/subspace-farmer/src/cluster/cache.rs b/crates/subspace-farmer/src/cluster/cache.rs new file mode 100644 index 0000000000..e4f543752b --- /dev/null +++ b/crates/subspace-farmer/src/cluster/cache.rs @@ -0,0 +1,754 @@ +//! Farming cluster cache +//! +//! Cache is responsible for caching pieces within allocated space to accelerate plotting and serve +//! pieces in response to DSN requests. +//! +//! This module exposes some data structures for NATS communication, custom piece cache +//! implementation designed to work with cluster cache and a service function to drive the backend +//! part of the cache. + +use crate::cluster::controller::ClusterControllerCacheIdentifyBroadcast; +use crate::cluster::nats_client::{ + GenericBroadcast, GenericRequest, GenericStreamRequest, NatsClient, StreamRequest, +}; +use crate::farm::{FarmError, PieceCache, PieceCacheOffset}; +use anyhow::anyhow; +use async_nats::Message; +use async_trait::async_trait; +use derive_more::Display; +use futures::stream::FuturesUnordered; +use futures::{select, stream, FutureExt, Stream, StreamExt}; +use parity_scale_codec::{Decode, Encode, EncodeLike, Input, Output}; +use std::future::{pending, Future}; +use std::pin::{pin, Pin}; +use std::time::Duration; +use subspace_core_primitives::{Piece, PieceIndex}; +use tokio::time::MissedTickBehavior; +use tracing::{debug, error, trace, warn}; +use ulid::Ulid; + +/// An ephemeral identifier for a cache +#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Display)] +pub enum ClusterCacheId { + Ulid(Ulid), +} + +impl Encode for ClusterCacheId { + #[inline] + fn size_hint(&self) -> usize { + 1_usize + + match self { + ClusterCacheId::Ulid(ulid) => 0_usize.saturating_add(Encode::size_hint(&ulid.0)), + } + } + + #[inline] + fn encode_to(&self, output: &mut O) { + match self { + ClusterCacheId::Ulid(ulid) => { + output.push_byte(0); + Encode::encode_to(&ulid.0, output); + } + } + } +} + +impl EncodeLike for ClusterCacheId {} + +impl Decode for ClusterCacheId { + #[inline] + fn decode(input: &mut I) -> Result { + match input + .read_byte() + .map_err(|e| e.chain("Could not decode `CacheId`, failed to read variant byte"))? + { + 0 => u128::decode(input) + .map(|ulid| ClusterCacheId::Ulid(Ulid(ulid))) + .map_err(|e| e.chain("Could not decode `CacheId::Ulid.0`")), + _ => Err("Could not decode `CacheId`, variant doesn't exist".into()), + } + } +} + +#[allow(clippy::new_without_default)] +impl ClusterCacheId { + /// Creates new ID + #[inline] + pub fn new() -> Self { + Self::Ulid(Ulid::new()) + } +} + +/// Broadcast with identification details by caches +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterCacheIdentifyBroadcast { + /// Cache ID + pub cache_id: ClusterCacheId, + /// Max number of elements in this cache + pub max_num_elements: u32, +} + +impl GenericBroadcast for ClusterCacheIdentifyBroadcast { + const SUBJECT: &'static str = "subspace.cache.*.identify"; +} + +/// Write piece into cache +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterCacheWritePieceRequest { + offset: PieceCacheOffset, + piece_index: PieceIndex, + piece: Piece, +} + +impl GenericRequest for ClusterCacheWritePieceRequest { + const SUBJECT: &'static str = "subspace.cache.*.write-piece"; + type Response = Result<(), String>; +} + +/// Read piece index from cache +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterCacheReadPieceIndexRequest { + offset: PieceCacheOffset, +} + +impl GenericRequest for ClusterCacheReadPieceIndexRequest { + const SUBJECT: &'static str = "subspace.cache.*.read-piece-index"; + type Response = Result, String>; +} + +/// Read piece from cache +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterCacheReadPieceRequest { + offset: PieceCacheOffset, +} + +impl GenericRequest for ClusterCacheReadPieceRequest { + const SUBJECT: &'static str = "subspace.cache.*.read-piece"; + type Response = Result, String>; +} + +/// Request plotted from farmer, request +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterCacheContentsRequest; + +impl GenericStreamRequest for ClusterCacheContentsRequest { + const SUBJECT: &'static str = "subspace.cache.*.contents"; + type Response = Result<(PieceCacheOffset, Option), String>; +} + +/// Cluster cache implementation +#[derive(Debug)] +pub struct ClusterPieceCache { + cache_id_string: String, + max_num_elements: u32, + nats_client: NatsClient, +} + +#[async_trait] +impl PieceCache for ClusterPieceCache { + #[inline] + fn max_num_elements(&self) -> u32 { + self.max_num_elements + } + + async fn contents( + &self, + ) -> Result< + Box< + dyn Stream), FarmError>> + + Unpin + + Send + + '_, + >, + FarmError, + > { + Ok(Box::new( + self.nats_client + .stream_request(ClusterCacheContentsRequest, Some(&self.cache_id_string)) + .await? + .map(|response| response.map_err(FarmError::from)), + )) + } + + async fn write_piece( + &self, + offset: PieceCacheOffset, + piece_index: PieceIndex, + piece: &Piece, + ) -> Result<(), FarmError> { + Ok(self + .nats_client + .request( + &ClusterCacheWritePieceRequest { + offset, + piece_index, + piece: piece.clone(), + }, + Some(&self.cache_id_string), + ) + .await??) + } + + async fn read_piece_index( + &self, + offset: PieceCacheOffset, + ) -> Result, FarmError> { + Ok(self + .nats_client + .request( + &ClusterCacheReadPieceIndexRequest { offset }, + Some(&self.cache_id_string), + ) + .await??) + } + + async fn read_piece(&self, offset: PieceCacheOffset) -> Result, FarmError> { + Ok(self + .nats_client + .request( + &ClusterCacheReadPieceRequest { offset }, + Some(&self.cache_id_string), + ) + .await??) + } +} + +impl ClusterPieceCache { + /// Create new instance using information from previously received + /// [`ClusterCacheIdentifyBroadcast`] + #[inline] + pub fn new( + cache_id: ClusterCacheId, + max_num_elements: u32, + nats_client: NatsClient, + ) -> ClusterPieceCache { + Self { + cache_id_string: cache_id.to_string(), + max_num_elements, + nats_client, + } + } +} + +#[derive(Debug)] +struct CacheDetails<'a, C> { + cache_id: ClusterCacheId, + cache_id_string: String, + cache: &'a C, +} + +/// Create cache service for specified caches that will be processing incoming requests and send +/// periodic identify notifications +pub async fn cache_service( + nats_client: NatsClient, + caches: &[C], + cache_group: &str, + identification_broadcast_interval: Duration, +) -> anyhow::Result<()> +where + C: PieceCache, +{ + let caches_details = caches + .iter() + .map(|cache| { + let cache_id = ClusterCacheId::new(); + + CacheDetails { + cache_id, + cache_id_string: cache_id.to_string(), + cache, + } + }) + .collect::>(); + + select! { + result = identify_responder(&nats_client, &caches_details, cache_group, identification_broadcast_interval).fuse() => { + result + }, + result = write_piece_responder(&nats_client, &caches_details).fuse() => { + result + }, + result = read_piece_index_responder(&nats_client, &caches_details).fuse() => { + result + }, + result = read_piece_responder(&nats_client, &caches_details).fuse() => { + result + }, + result = contents_responder(&nats_client, &caches_details).fuse() => { + result + }, + } +} + +/// Listen for cache identification broadcast from controller and publish identification +/// broadcast in response, also send periodic notifications reminding that cache exists. +/// +/// Implementation is using concurrency with multiple tokio tasks, but can be started multiple times +/// per controller instance in order to parallelize more work across threads if needed. +async fn identify_responder( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], + cache_group: &str, + identification_broadcast_interval: Duration, +) -> anyhow::Result<()> +where + C: PieceCache, +{ + let mut subscription = nats_client + .subscribe_to_broadcasts::( + Some(cache_group), + Some(cache_group.to_string()), + ) + .await + .map_err(|error| { + anyhow!("Failed to subscribe to cache identify broadcast requests: {error}") + })? + .fuse(); + // Also send periodic updates in addition to the subscription response + let mut interval = tokio::time::interval(identification_broadcast_interval); + interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + debug!("Identify broadcast stream ended"); + break; + }; + + trace!(?message, "Cache received identify broadcast message"); + + send_identify_broadcast(nats_client, caches_details).await; + interval.reset(); + } + _ = interval.tick().fuse() => { + trace!("Cache self-identification"); + + send_identify_broadcast(nats_client, caches_details).await; + } + } + } + + Ok(()) +} + +async fn send_identify_broadcast( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], +) where + C: PieceCache, +{ + caches_details + .iter() + .map(|cache| async move { + if let Err(error) = nats_client + .broadcast( + &ClusterCacheIdentifyBroadcast { + cache_id: cache.cache_id, + max_num_elements: cache.cache.max_num_elements(), + }, + &cache.cache_id_string, + ) + .await + { + warn!( + cache_id = %cache.cache_id, + %error, + "Failed to send cache identify notification" + ); + } + }) + .collect::>() + .collect::>() + .await; +} + +async fn write_piece_responder( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], +) -> anyhow::Result<()> +where + C: PieceCache, +{ + caches_details + .iter() + .map(|cache_details| async move { + // Initialize with pending future so it never ends + let mut processing = + FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + let mut subscription = nats_client + .queue_subscribe( + ClusterCacheWritePieceRequest::SUBJECT + .replace('*', &cache_details.cache_id_string), + cache_details.cache_id_string.clone(), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to write piece requests for cache {}: {}", + cache_details.cache_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_write_piece_request( + nats_client, + cache_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No caches"))? +} + +async fn process_write_piece_request( + nats_client: &NatsClient, + cache_details: &CacheDetails<'_, C>, + message: Message, +) where + C: PieceCache, +{ + let Some(reply_subject) = message.reply else { + return; + }; + + let ClusterCacheWritePieceRequest { + offset, + piece_index, + piece, + } = match ClusterCacheWritePieceRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode write piece request" + ); + return; + } + }; + + let response: ::Response = cache_details + .cache + .write_piece(offset, piece_index, &piece) + .await + .map_err(|error| error.to_string()); + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send write piece response"); + } +} + +async fn read_piece_index_responder( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], +) -> anyhow::Result<()> +where + C: PieceCache, +{ + caches_details + .iter() + .map(|cache_details| async move { + // Initialize with pending future so it never ends + let mut processing = + FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + let mut subscription = nats_client + .queue_subscribe( + ClusterCacheReadPieceIndexRequest::SUBJECT + .replace('*', &cache_details.cache_id_string), + cache_details.cache_id_string.clone(), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to read piece index requests for cache {}: {}", + cache_details.cache_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_read_piece_index_request( + nats_client, + cache_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No caches"))? +} + +async fn process_read_piece_index_request( + nats_client: &NatsClient, + cache_details: &CacheDetails<'_, C>, + message: Message, +) where + C: PieceCache, +{ + let Some(reply_subject) = message.reply else { + return; + }; + + let ClusterCacheReadPieceIndexRequest { offset } = + match ClusterCacheReadPieceIndexRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode read piece index request" + ); + return; + } + }; + + let response: ::Response = cache_details + .cache + .read_piece_index(offset) + .await + .map_err(|error| error.to_string()); + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send read piece index response"); + } +} + +async fn read_piece_responder( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], +) -> anyhow::Result<()> +where + C: PieceCache, +{ + caches_details + .iter() + .map(|cache_details| async move { + // Initialize with pending future so it never ends + let mut processing = + FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + let mut subscription = nats_client + .queue_subscribe( + ClusterCacheReadPieceRequest::SUBJECT + .replace('*', &cache_details.cache_id_string), + cache_details.cache_id_string.clone(), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to read piece requests for cache {}: {}", + cache_details.cache_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_read_piece_request( + nats_client, + cache_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No caches"))? +} + +async fn process_read_piece_request( + nats_client: &NatsClient, + cache_details: &CacheDetails<'_, C>, + message: Message, +) where + C: PieceCache, +{ + let Some(reply_subject) = message.reply else { + return; + }; + + let ClusterCacheReadPieceRequest { offset } = + match ClusterCacheReadPieceRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode read piece request" + ); + return; + } + }; + + let response: ::Response = cache_details + .cache + .read_piece(offset) + .await + .map_err(|error| error.to_string()); + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send read piece response"); + } +} + +async fn contents_responder( + nats_client: &NatsClient, + caches_details: &[CacheDetails<'_, C>], +) -> anyhow::Result<()> +where + C: PieceCache, +{ + caches_details + .iter() + .map(|cache_details| async move { + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered::from_iter([ + Box::pin(pending()) as Pin + Send>> + ]); + let mut subscription = nats_client + .subscribe_to_stream_requests( + Some(&cache_details.cache_id_string), + Some(cache_details.cache_id_string.clone()), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to contents requests for cache {}: {}", + cache_details.cache_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_contents_request( + nats_client, + cache_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No caches"))? +} + +async fn process_contents_request( + nats_client: &NatsClient, + cache_details: &CacheDetails<'_, C>, + request: StreamRequest, +) where + C: PieceCache, +{ + trace!(?request, "Contents request"); + + match cache_details.cache.contents().await { + Ok(contents) => { + nats_client + .stream_response::( + request.response_subject, + contents.map(|maybe_cache_element| { + maybe_cache_element.map_err(|error| error.to_string()) + }), + ) + .await; + } + Err(error) => { + error!( + %error, + cache_id = %cache_details.cache_id, + "Failed to get contents" + ); + + nats_client + .stream_response::( + request.response_subject, + pin!(stream::once(async move { + Err(format!("Failed to get contents: {error}")) + })), + ) + .await; + } + } +} diff --git a/crates/subspace-farmer/src/cluster/controller.rs b/crates/subspace-farmer/src/cluster/controller.rs new file mode 100644 index 0000000000..1cf4ce9d56 --- /dev/null +++ b/crates/subspace-farmer/src/cluster/controller.rs @@ -0,0 +1,738 @@ +//! Farming cluster controller +//! +//! Controller is responsible for managing farming cluster. +//! +//! This module exposes some data structures for NATS communication, custom piece getter and node +//! client implementations designed to work with cluster controller and a service function to drive +//! the backend part of the controller. + +use crate::cluster::nats_client::{ + GenericBroadcast, GenericNotification, GenericRequest, NatsClient, +}; +use crate::node_client::{Error as NodeClientError, NodeClient}; +use anyhow::anyhow; +use async_lock::Semaphore; +use async_nats::{HeaderValue, Message}; +use async_trait::async_trait; +use futures::stream::FuturesUnordered; +use futures::{select, FutureExt, Stream, StreamExt}; +use parity_scale_codec::{Decode, Encode}; +use parking_lot::Mutex; +use std::error::Error; +use std::future::{pending, Future}; +use std::num::NonZeroUsize; +use std::pin::Pin; +use std::sync::Arc; +use std::time::{Duration, Instant}; +use subspace_core_primitives::{Piece, PieceIndex, SegmentHeader, SegmentIndex}; +use subspace_farmer_components::PieceGetter; +use subspace_rpc_primitives::{ + FarmerAppInfo, RewardSignatureResponse, RewardSigningInfo, SlotInfo, SolutionResponse, +}; +use tracing::{debug, trace, warn}; + +const FARMER_APP_INFO_DEDUPLICATION_WINDOW: Duration = Duration::from_secs(1); + +/// Broadcast sent by controllers requesting farmers to identify themselves +#[derive(Debug, Copy, Clone, Encode, Decode)] +pub struct ClusterControllerFarmerIdentifyBroadcast; + +impl GenericBroadcast for ClusterControllerFarmerIdentifyBroadcast { + const SUBJECT: &'static str = "subspace.controller.farmer-identify"; +} + +/// Broadcast sent by controllers requesting caches in cache group to identify themselves +#[derive(Debug, Copy, Clone, Encode, Decode)] +pub struct ClusterControllerCacheIdentifyBroadcast; + +impl GenericBroadcast for ClusterControllerCacheIdentifyBroadcast { + /// `*` here stands for cache group + const SUBJECT: &'static str = "subspace.controller.*.cache-identify"; +} + +/// Broadcast with slot info sent by controllers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerSlotInfoBroadcast { + pub slot_info: SlotInfo, + pub instance: String, +} + +impl GenericBroadcast for ClusterControllerSlotInfoBroadcast { + const SUBJECT: &'static str = "subspace.controller.slot-info"; + + fn deterministic_message_id(&self) -> Option { + // TODO: Depending on answer in `https://github.com/nats-io/nats.docs/issues/663` this might + // be simplified to just a slot number + Some(HeaderValue::from( + format!("slot-info-{}", self.slot_info.slot_number).as_str(), + )) + } +} + +/// Broadcast with reward signing info by controllers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerRewardSigningBroadcast { + pub reward_signing_info: RewardSigningInfo, +} + +impl GenericBroadcast for ClusterControllerRewardSigningBroadcast { + const SUBJECT: &'static str = "subspace.controller.reward-signing-info"; +} + +/// Broadcast with archived segment headers by controllers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerArchivedSegmentHeaderBroadcast { + pub archived_segment_header: SegmentHeader, +} + +impl GenericBroadcast for ClusterControllerArchivedSegmentHeaderBroadcast { + const SUBJECT: &'static str = "subspace.controller.archived-segment-header"; + + fn deterministic_message_id(&self) -> Option { + // TODO: Depending on answer in `https://github.com/nats-io/nats.docs/issues/663` this might + // be simplified to just a segment index + Some(HeaderValue::from( + format!( + "archived-segment-{}", + self.archived_segment_header.segment_index() + ) + .as_str(), + )) + } +} + +/// Notification messages with solution by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerSolutionNotification { + pub solution_response: SolutionResponse, +} + +impl GenericNotification for ClusterControllerSolutionNotification { + const SUBJECT: &'static str = "subspace.controller.*.solution"; +} + +/// Notification messages with reward signature by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerRewardSignatureNotification { + pub reward_signature: RewardSignatureResponse, +} + +impl GenericNotification for ClusterControllerRewardSignatureNotification { + const SUBJECT: &'static str = "subspace.controller.*.reward-signature"; +} + +/// Request farmer app info from controller +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerFarmerAppInfoRequest; + +impl GenericRequest for ClusterControllerFarmerAppInfoRequest { + const SUBJECT: &'static str = "subspace.controller.farmer-app-info"; + type Response = FarmerAppInfo; +} + +/// Request segment headers with specified segment indices +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerSegmentHeadersRequest { + pub segment_indices: Vec, +} + +impl GenericRequest for ClusterControllerSegmentHeadersRequest { + const SUBJECT: &'static str = "subspace.controller.segment-headers"; + type Response = Vec>; +} + +/// Request piece with specified index +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterControllerPieceRequest { + pub piece_index: PieceIndex, +} + +impl GenericRequest for ClusterControllerPieceRequest { + const SUBJECT: &'static str = "subspace.controller.piece"; + type Response = Option; +} + +/// Cluster piece getter +#[derive(Debug, Clone)] +pub struct ClusterPieceGetter { + nats_client: NatsClient, + request_semaphore: Arc, +} + +#[async_trait] +impl PieceGetter for ClusterPieceGetter { + async fn get_piece( + &self, + piece_index: PieceIndex, + ) -> Result, Box> { + let _guard = self.request_semaphore.acquire().await; + Ok(self + .nats_client + .request(&ClusterControllerPieceRequest { piece_index }, None) + .await?) + } +} + +impl ClusterPieceGetter { + /// Create new instance + #[inline] + pub fn new(nats_client: NatsClient, request_concurrency: NonZeroUsize) -> Self { + let request_semaphore = Arc::new(Semaphore::new(request_concurrency.get())); + Self { + nats_client, + request_semaphore, + } + } +} + +/// [`NodeClient`] used in cluster environment that connects to node through a controller instead +/// of to the node directly +#[derive(Debug, Clone)] +pub struct ClusterNodeClient { + nats_client: NatsClient, + // Store last slot info instance that can be used to send solution response to (some instances + // may be not synced and not able to receive solution responses) + last_slot_info_instance: Arc>, +} + +impl ClusterNodeClient { + /// Create a new instance + #[inline] + pub fn new(nats_client: NatsClient) -> Self { + Self { + nats_client, + last_slot_info_instance: Arc::default(), + } + } +} + +#[async_trait] +impl NodeClient for ClusterNodeClient { + async fn farmer_app_info(&self) -> Result { + Ok(self + .nats_client + .request(&ClusterControllerFarmerAppInfoRequest, None) + .await?) + } + + async fn subscribe_slot_info( + &self, + ) -> Result + Send + 'static>>, NodeClientError> { + let last_slot_info_instance = Arc::clone(&self.last_slot_info_instance); + let subscription = self + .nats_client + .subscribe_to_broadcasts::(None, None) + .await? + .map(move |broadcast| { + *last_slot_info_instance.lock() = broadcast.instance; + + broadcast.slot_info + }); + + Ok(Box::pin(subscription)) + } + + async fn submit_solution_response( + &self, + solution_response: SolutionResponse, + ) -> Result<(), NodeClientError> { + let last_slot_info_instance = self.last_slot_info_instance.lock().clone(); + Ok(self + .nats_client + .notification( + &ClusterControllerSolutionNotification { solution_response }, + Some(&last_slot_info_instance), + ) + .await?) + } + + async fn subscribe_reward_signing( + &self, + ) -> Result + Send + 'static>>, NodeClientError> + { + let subscription = self + .nats_client + .subscribe_to_broadcasts::(None, None) + .await? + .map(|broadcast| broadcast.reward_signing_info); + + Ok(Box::pin(subscription)) + } + + /// Submit a block signature + async fn submit_reward_signature( + &self, + reward_signature: RewardSignatureResponse, + ) -> Result<(), NodeClientError> { + let last_slot_info_instance = self.last_slot_info_instance.lock().clone(); + Ok(self + .nats_client + .notification( + &ClusterControllerRewardSignatureNotification { reward_signature }, + Some(&last_slot_info_instance), + ) + .await?) + } + + async fn subscribe_archived_segment_headers( + &self, + ) -> Result + Send + 'static>>, NodeClientError> { + let subscription = self + .nats_client + .subscribe_to_broadcasts::(None, None) + .await? + .map(|broadcast| broadcast.archived_segment_header); + + Ok(Box::pin(subscription)) + } + + async fn segment_headers( + &self, + segment_indices: Vec, + ) -> Result>, NodeClientError> { + Ok(self + .nats_client + .request( + &ClusterControllerSegmentHeadersRequest { segment_indices }, + None, + ) + .await?) + } + + async fn piece(&self, piece_index: PieceIndex) -> Result, NodeClientError> { + Ok(self + .nats_client + .request(&ClusterControllerPieceRequest { piece_index }, None) + .await?) + } + + async fn acknowledge_archived_segment_header( + &self, + _segment_index: SegmentIndex, + ) -> Result<(), NodeClientError> { + // Acknowledgement is unnecessary/unsupported + Ok(()) + } +} + +/// Create controller service that handles things like broadcasting information (for example slot +/// notifications) as well as responding to incoming requests (like piece requests). +/// +/// Implementation is using concurrency with multiple tokio tasks, but can be started multiple times +/// per controller instance in order to parallelize more work across threads if needed. +pub async fn controller_service( + nats_client: &NatsClient, + node_client: &NC, + piece_getter: &PG, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, + PG: PieceGetter + Sync, +{ + select! { + result = slot_info_broadcaster(nats_client, node_client, instance).fuse() => { + result + }, + result = reward_signing_broadcaster(nats_client, node_client, instance).fuse() => { + result + }, + result = archived_segment_headers_broadcaster(nats_client, node_client, instance).fuse() => { + result + }, + result = solution_response_forwarder(nats_client, node_client, instance).fuse() => { + result + }, + result = reward_signature_forwarder(nats_client, node_client, instance).fuse() => { + result + }, + result = farmer_app_info_responder(nats_client, node_client).fuse() => { + result + }, + result = segment_headers_responder(nats_client, node_client).fuse() => { + result + }, + result = piece_responder(nats_client, piece_getter).fuse() => { + result + }, + } +} + +async fn slot_info_broadcaster( + nats_client: &NatsClient, + node_client: &NC, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut slot_info_notifications = node_client + .subscribe_slot_info() + .await + .map_err(|error| anyhow!("Failed to subscribe to slot info notifications: {error}"))?; + + while let Some(slot_info) = slot_info_notifications.next().await { + debug!(?slot_info, "New slot"); + + let slot = slot_info.slot_number; + + if let Err(error) = nats_client + .broadcast( + &ClusterControllerSlotInfoBroadcast { + slot_info, + instance: instance.to_string(), + }, + instance, + ) + .await + { + warn!(%slot, %error, "Failed to broadcast slot info"); + } + } + + Ok(()) +} + +async fn reward_signing_broadcaster( + nats_client: &NatsClient, + node_client: &NC, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut reward_signing_notifications = node_client + .subscribe_reward_signing() + .await + .map_err(|error| anyhow!("Failed to subscribe to reward signing notifications: {error}"))?; + + while let Some(reward_signing_info) = reward_signing_notifications.next().await { + trace!(?reward_signing_info, "New reward signing notification"); + + if let Err(error) = nats_client + .broadcast( + &ClusterControllerRewardSigningBroadcast { + reward_signing_info, + }, + instance, + ) + .await + { + warn!(%error, "Failed to broadcast reward signing info"); + } + } + + Ok(()) +} + +async fn archived_segment_headers_broadcaster( + nats_client: &NatsClient, + node_client: &NC, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut archived_segments_notifications = node_client + .subscribe_archived_segment_headers() + .await + .map_err(|error| { + anyhow!("Failed to subscribe to archived segment header notifications: {error}") + })?; + + while let Some(archived_segment_header) = archived_segments_notifications.next().await { + trace!( + ?archived_segment_header, + "New archived archived segment header notification" + ); + + node_client + .acknowledge_archived_segment_header(archived_segment_header.segment_index()) + .await + .map_err(|error| anyhow!("Failed to acknowledge archived segment header: {error}"))?; + + if let Err(error) = nats_client + .broadcast( + &ClusterControllerArchivedSegmentHeaderBroadcast { + archived_segment_header, + }, + instance, + ) + .await + { + warn!(%error, "Failed to broadcast archived segment header info"); + } + } + + Ok(()) +} + +async fn solution_response_forwarder( + nats_client: &NatsClient, + node_client: &NC, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut subscription = nats_client + .subscribe_to_notifications::( + Some(instance), + Some(instance.to_string()), + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to solution notifications: {error}"))?; + + while let Some(notification) = subscription.next().await { + debug!(?notification, "Solution notification"); + + if let Err(error) = node_client + .submit_solution_response(notification.solution_response) + .await + { + warn!(%error, "Failed to send solution response"); + } + } + + Ok(()) +} + +async fn reward_signature_forwarder( + nats_client: &NatsClient, + node_client: &NC, + instance: &str, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut subscription = nats_client + .subscribe_to_notifications::( + Some(instance), + Some(instance.to_string()), + ) + .await + .map_err(|error| { + anyhow!("Failed to subscribe to reward signature notifications: {error}") + })?; + + while let Some(notification) = subscription.next().await { + debug!(?notification, "Reward signature notification"); + + if let Err(error) = node_client + .submit_reward_signature(notification.reward_signature) + .await + { + warn!(%error, "Failed to send reward signature"); + } + } + + Ok(()) +} + +async fn farmer_app_info_responder( + nats_client: &NatsClient, + node_client: &NC, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut subscription = nats_client + .queue_subscribe( + ClusterControllerFarmerAppInfoRequest::SUBJECT, + "subspace.controller".to_string(), + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to farmer app info requests: {error}"))?; + + let mut last_farmer_app_info: ::Response = node_client + .farmer_app_info() + .await + .map_err(|error| anyhow!("Failed to get farmer app info: {error}"))?; + let mut last_farmer_app_info_request = Instant::now(); + + while let Some(message) = subscription.next().await { + trace!("Farmer app info request"); + + let Some(reply_subject) = message.reply else { + continue; + }; + + if last_farmer_app_info_request.elapsed() > FARMER_APP_INFO_DEDUPLICATION_WINDOW { + match node_client.farmer_app_info().await { + Ok(new_last_farmer_app_info) => { + last_farmer_app_info = new_last_farmer_app_info; + last_farmer_app_info_request = Instant::now(); + } + Err(error) => { + warn!(%error, "Failed to get farmer app info"); + } + } + } + + if let Err(error) = nats_client + .publish(reply_subject, last_farmer_app_info.encode().into()) + .await + { + warn!(%error, "Failed to send farmer app info response"); + } + } + + Ok(()) +} + +async fn segment_headers_responder( + nats_client: &NatsClient, + node_client: &NC, +) -> anyhow::Result<()> +where + NC: NodeClient, +{ + let mut subscription = nats_client + .queue_subscribe( + ClusterControllerSegmentHeadersRequest::SUBJECT, + "subspace.controller".to_string(), + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to segment headers requests: {error}"))?; + + let mut last_request_response = None::<( + ClusterControllerSegmentHeadersRequest, + ::Response, + )>; + + while let Some(message) = subscription.next().await { + let Some(reply_subject) = message.reply else { + continue; + }; + + let request = + match ClusterControllerSegmentHeadersRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode segment headers request" + ); + continue; + } + }; + trace!(?request, "Segment headers request"); + + let response = if let Some((last_request, response)) = &last_request_response + && last_request.segment_indices == request.segment_indices + { + response + } else { + match node_client + .segment_headers(request.segment_indices.clone()) + .await + { + Ok(segment_headers) => &last_request_response.insert((request, segment_headers)).1, + Err(error) => { + warn!( + %error, + segment_indices = ?request.segment_indices, + "Failed to get segment headers" + ); + continue; + } + } + }; + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send farmer app info response"); + } + } + + Ok(()) +} + +async fn piece_responder(nats_client: &NatsClient, piece_getter: &PG) -> anyhow::Result<()> +where + PG: PieceGetter + Sync, +{ + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + + let mut subscription = nats_client + .queue_subscribe( + ClusterControllerPieceRequest::SUBJECT, + "subspace.controller".to_string(), + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to piece requests: {error}"))? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_piece_request( + nats_client, + piece_getter, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) +} + +async fn process_piece_request(nats_client: &NatsClient, piece_getter: &PG, message: Message) +where + PG: PieceGetter, +{ + let Some(reply_subject) = message.reply else { + return; + }; + + let request = match ClusterControllerPieceRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode piece request" + ); + return; + } + }; + trace!(?request, "Piece request"); + + // TODO: It would be great to send cached pieces from cache instance directly to requested + // rather than proxying through controller, but it is awkward with current architecture + + let maybe_piece: ::Response = + match piece_getter.get_piece(request.piece_index).await { + Ok(maybe_piece) => maybe_piece, + Err(error) => { + warn!( + %error, + piece_index = %request.piece_index, + "Failed to get piece" + ); + return; + } + }; + + if let Err(error) = nats_client + .publish(reply_subject, maybe_piece.encode().into()) + .await + { + warn!(%error, "Failed to send farmer app info response"); + } +} diff --git a/crates/subspace-farmer/src/cluster/farmer.rs b/crates/subspace-farmer/src/cluster/farmer.rs new file mode 100644 index 0000000000..1ed0c35ccd --- /dev/null +++ b/crates/subspace-farmer/src/cluster/farmer.rs @@ -0,0 +1,835 @@ +//! Farming cluster farmer +//! +//! Farmer is responsible for maintaining farms, doing audits and generating proofs when solution is +//! found in one of the plots. +//! +//! This module exposes some data structures for NATS communication, custom farm implementation +//! designed to work with cluster farmer and a service function to drive the backend part +//! of the farmer. + +use crate::cluster::controller::ClusterControllerFarmerIdentifyBroadcast; +use crate::cluster::nats_client::{ + GenericBroadcast, GenericRequest, GenericStreamRequest, NatsClient, StreamRequest, +}; +use crate::farm::{ + Farm, FarmError, FarmId, FarmingNotification, HandlerFn, HandlerId, MaybePieceStoredResult, + PieceCache, PieceCacheOffset, PieceReader, PlotCache, PlottedSectors, SectorUpdate, +}; +use crate::utils::AsyncJoinOnDrop; +use anyhow::anyhow; +use async_nats::Message; +use async_trait::async_trait; +use event_listener_primitives::Bag; +use futures::channel::mpsc; +use futures::stream::FuturesUnordered; +use futures::{select, stream, FutureExt, Stream, StreamExt}; +use parity_scale_codec::{Decode, Encode}; +use std::future::{pending, Future}; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::{Duration, Instant}; +use subspace_core_primitives::crypto::blake3_hash_list; +use subspace_core_primitives::{Blake3Hash, Piece, PieceIndex, PieceOffset, SectorIndex}; +use subspace_farmer_components::plotting::PlottedSector; +use subspace_networking::libp2p::kad::RecordKey; +use subspace_rpc_primitives::SolutionResponse; +use tokio::time::MissedTickBehavior; +use tracing::{debug, error, trace, warn}; + +const BROADCAST_NOTIFICATIONS_BUFFER: usize = 1000; +const MIN_FARMER_IDENTIFICATION_INTERVAL: Duration = Duration::from_secs(1); + +type Handler = Bag, A>; + +/// Broadcast with identification details by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterFarmerIdentifyFarmBroadcast { + /// Farm ID + pub farm_id: FarmId, + /// Total number of sectors in the farm + pub total_sectors_count: SectorIndex, + /// Farm fingerprint changes when something about farm changes (like allocated space) + pub fingerprint: Blake3Hash, +} + +impl GenericBroadcast for ClusterFarmerIdentifyFarmBroadcast { + const SUBJECT: &'static str = "subspace.farmer.*.identify"; +} + +/// Broadcast with sector updates by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterFarmerSectorUpdateBroadcast { + /// Farm ID + pub farm_id: FarmId, + /// Sector index + pub sector_index: SectorIndex, + /// Sector update + pub sector_update: SectorUpdate, +} + +impl GenericBroadcast for ClusterFarmerSectorUpdateBroadcast { + const SUBJECT: &'static str = "subspace.farmer.*.sector-update"; +} + +/// Broadcast with farming notifications by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterFarmerFarmingNotificationBroadcast { + /// Farm ID + pub farm_id: FarmId, + /// Farming notification + pub farming_notification: FarmingNotification, +} + +impl GenericBroadcast for ClusterFarmerFarmingNotificationBroadcast { + const SUBJECT: &'static str = "subspace.farmer.*.farming-notification"; +} + +/// Broadcast with solutions by farmers +#[derive(Debug, Clone, Encode, Decode)] +pub struct ClusterFarmerSolutionBroadcast { + /// Farm ID + pub farm_id: FarmId, + /// Solution response + pub solution_response: SolutionResponse, +} + +impl GenericBroadcast for ClusterFarmerSolutionBroadcast { + const SUBJECT: &'static str = "subspace.farmer.*.solution-response"; +} + +/// Read piece from farm +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterFarmerReadPieceRequest { + sector_index: SectorIndex, + piece_offset: PieceOffset, +} + +impl GenericRequest for ClusterFarmerReadPieceRequest { + const SUBJECT: &'static str = "subspace.farmer.*.farm.read-piece"; + type Response = Result, String>; +} + +/// Request plotted sectors from farmer +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterFarmerPlottedSectorsRequest; + +impl GenericStreamRequest for ClusterFarmerPlottedSectorsRequest { + const SUBJECT: &'static str = "subspace.farmer.*.farm.plotted-sectors"; + type Response = Result; +} + +#[derive(Debug)] +struct ClusterPlottedSectors { + farm_id_string: String, + nats_client: NatsClient, +} + +#[async_trait] +impl PlottedSectors for ClusterPlottedSectors { + async fn get( + &self, + ) -> Result< + Box> + Unpin + Send + '_>, + FarmError, + > { + Ok(Box::new( + self.nats_client + .stream_request( + ClusterFarmerPlottedSectorsRequest, + Some(&self.farm_id_string), + ) + .await? + .map(|response| response.map_err(FarmError::from)), + )) + } +} + +#[derive(Debug)] +struct DummyPieceCache; + +#[async_trait] +impl PieceCache for DummyPieceCache { + #[inline] + fn max_num_elements(&self) -> u32 { + 0 + } + + #[inline] + async fn contents( + &self, + ) -> Result< + Box< + dyn Stream), FarmError>> + + Unpin + + Send + + '_, + >, + FarmError, + > { + Ok(Box::new(stream::empty())) + } + + #[inline] + async fn write_piece( + &self, + _offset: PieceCacheOffset, + _piece_index: PieceIndex, + _piece: &Piece, + ) -> Result<(), FarmError> { + Err("Can't write pieces into empty cache".into()) + } + + #[inline] + async fn read_piece_index( + &self, + _offset: PieceCacheOffset, + ) -> Result, FarmError> { + Ok(None) + } + + #[inline] + async fn read_piece(&self, _offset: PieceCacheOffset) -> Result, FarmError> { + Ok(None) + } +} + +#[derive(Debug)] +struct DummyPlotCache; + +#[async_trait] +impl PlotCache for DummyPlotCache { + async fn is_piece_maybe_stored( + &self, + _key: &RecordKey, + ) -> Result { + Ok(MaybePieceStoredResult::No) + } + + async fn try_store_piece( + &self, + _piece_index: PieceIndex, + _piece: &Piece, + ) -> Result { + Ok(false) + } + + async fn read_piece(&self, _key: &RecordKey) -> Result, FarmError> { + Ok(None) + } +} + +#[derive(Debug)] +struct ClusterPieceReader { + farm_id_string: String, + nats_client: NatsClient, +} + +#[async_trait] +impl PieceReader for ClusterPieceReader { + async fn read_piece( + &self, + sector_index: SectorIndex, + piece_offset: PieceOffset, + ) -> Result, FarmError> { + Ok(self + .nats_client + .request( + &ClusterFarmerReadPieceRequest { + sector_index, + piece_offset, + }, + Some(&self.farm_id_string), + ) + .await??) + } +} + +#[derive(Default, Debug)] +struct Handlers { + sector_update: Handler<(SectorIndex, SectorUpdate)>, + farming_notification: Handler, + solution: Handler, +} + +/// Cluster farm implementation +#[derive(Debug)] +pub struct ClusterFarm { + farm_id: FarmId, + farm_id_string: String, + total_sectors_count: SectorIndex, + nats_client: NatsClient, + handlers: Arc, + background_tasks: AsyncJoinOnDrop<()>, +} + +#[async_trait(?Send)] +impl Farm for ClusterFarm { + fn id(&self) -> &FarmId { + &self.farm_id + } + + fn total_sectors_count(&self) -> SectorIndex { + self.total_sectors_count + } + + fn plotted_sectors(&self) -> Arc { + Arc::new(ClusterPlottedSectors { + farm_id_string: self.farm_id_string.clone(), + nats_client: self.nats_client.clone(), + }) + } + + fn piece_cache(&self) -> Arc { + Arc::new(DummyPieceCache) + } + + fn plot_cache(&self) -> Arc { + Arc::new(DummyPlotCache) + } + + fn piece_reader(&self) -> Arc { + Arc::new(ClusterPieceReader { + farm_id_string: self.farm_id_string.clone(), + nats_client: self.nats_client.clone(), + }) + } + + fn on_sector_update( + &self, + callback: HandlerFn<(SectorIndex, SectorUpdate)>, + ) -> Box { + Box::new(self.handlers.sector_update.add(callback)) + } + + fn on_farming_notification( + &self, + callback: HandlerFn, + ) -> Box { + Box::new(self.handlers.farming_notification.add(callback)) + } + + fn on_solution(&self, callback: HandlerFn) -> Box { + Box::new(self.handlers.solution.add(callback)) + } + + fn run(self: Box) -> Pin> + Send>> { + Box::pin(async move { Ok(self.background_tasks.await?) }) + } +} + +impl ClusterFarm { + /// Create new instance using information from previously received + /// [`ClusterFarmerIdentifyFarmBroadcast`] + pub async fn new( + farm_id: FarmId, + total_sectors_count: SectorIndex, + nats_client: NatsClient, + ) -> anyhow::Result { + let farm_id_string = farm_id.to_string(); + + let sector_updates_subscription = nats_client + .subscribe_to_broadcasts::( + Some(&farm_id_string), + None, + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to sector updates broadcast: {error}"))?; + let farming_notifications_subscription = nats_client + .subscribe_to_broadcasts::( + Some(&farm_id_string), + None, + ) + .await + .map_err(|error| { + anyhow!("Failed to subscribe to farming notifications broadcast: {error}") + })?; + let solution_subscription = nats_client + .subscribe_to_broadcasts::(Some(&farm_id_string), None) + .await + .map_err(|error| { + anyhow!("Failed to subscribe to solution responses broadcast: {error}") + })?; + + let handlers = Arc::::default(); + // Run background tasks and fire corresponding notifications + let background_tasks = { + let handlers = Arc::clone(&handlers); + + async move { + let mut sector_updates_subscription = pin!(sector_updates_subscription); + let mut farming_notifications_subscription = + pin!(farming_notifications_subscription); + let mut solution_subscription = pin!(solution_subscription); + + let sector_updates_fut = async { + while let Some(ClusterFarmerSectorUpdateBroadcast { + sector_index, + sector_update, + .. + }) = sector_updates_subscription.next().await + { + handlers + .sector_update + .call_simple(&(sector_index, sector_update)); + } + }; + let farming_notifications_fut = async { + while let Some(ClusterFarmerFarmingNotificationBroadcast { + farming_notification, + .. + }) = farming_notifications_subscription.next().await + { + handlers + .farming_notification + .call_simple(&farming_notification); + } + }; + let solutions_fut = async { + while let Some(ClusterFarmerSolutionBroadcast { + solution_response, .. + }) = solution_subscription.next().await + { + handlers.solution.call_simple(&solution_response); + } + }; + + select! { + _ = sector_updates_fut.fuse() => {} + _ = farming_notifications_fut.fuse() => {} + _ = solutions_fut.fuse() => {} + } + } + }; + + Ok(Self { + farm_id, + farm_id_string, + total_sectors_count, + nats_client, + handlers, + background_tasks: AsyncJoinOnDrop::new(tokio::spawn(background_tasks), true), + }) + } +} + +#[derive(Debug)] +struct FarmDetails { + farm_id: FarmId, + farm_id_string: String, + total_sectors_count: SectorIndex, + piece_reader: Arc, + plotted_sectors: Arc, + _background_tasks: AsyncJoinOnDrop<()>, +} + +/// Create farmer service for specified farms that will be processing incoming requests and send +/// periodic identify notifications. +/// +/// Implementation is using concurrency with multiple tokio tasks, but can be started multiple times +/// per controller instance in order to parallelize more work across threads if needed. +pub fn farmer_service( + nats_client: NatsClient, + farms: &[F], + identification_broadcast_interval: Duration, +) -> impl Future> + Send + 'static +where + F: Farm, +{ + // For each farm start forwarding notifications as broadcast messages and create farm details + // that can be used to respond to incoming requests + let farms_details = farms + .iter() + .map(|farm| { + let farm_id = *farm.id(); + let nats_client = nats_client.clone(); + + let (sector_updates_sender, mut sector_updates_receiver) = + mpsc::channel(BROADCAST_NOTIFICATIONS_BUFFER); + let (farming_notifications_sender, mut farming_notifications_receiver) = + mpsc::channel(BROADCAST_NOTIFICATIONS_BUFFER); + let (solutions_sender, mut solutions_receiver) = + mpsc::channel(BROADCAST_NOTIFICATIONS_BUFFER); + + let sector_updates_handler_id = + farm.on_sector_update(Arc::new(move |(sector_index, sector_update)| { + if let Err(error) = + sector_updates_sender + .clone() + .try_send(ClusterFarmerSectorUpdateBroadcast { + farm_id, + sector_index: *sector_index, + sector_update: sector_update.clone(), + }) + { + warn!(%farm_id, %error, "Failed to send sector update notification"); + } + })); + + let farming_notifications_handler_id = + farm.on_farming_notification(Arc::new(move |farming_notification| { + if let Err(error) = farming_notifications_sender.clone().try_send( + ClusterFarmerFarmingNotificationBroadcast { + farm_id, + farming_notification: farming_notification.clone(), + }, + ) { + warn!(%farm_id, %error, "Failed to send farming notification"); + } + })); + + let solutions_handler_id = farm.on_solution(Arc::new(move |solution_response| { + if let Err(error) = + solutions_sender + .clone() + .try_send(ClusterFarmerSolutionBroadcast { + farm_id, + solution_response: solution_response.clone(), + }) + { + warn!(%farm_id, %error, "Failed to send solution notification"); + } + })); + + let background_tasks = AsyncJoinOnDrop::new( + tokio::spawn(async move { + let farm_id_string = farm_id.to_string(); + + let sector_updates_fut = async { + while let Some(broadcast) = sector_updates_receiver.next().await { + if let Err(error) = + nats_client.broadcast(&broadcast, &farm_id_string).await + { + warn!(%farm_id, %error, "Failed to broadcast sector update"); + } + } + }; + let farming_notifications_fut = async { + while let Some(broadcast) = farming_notifications_receiver.next().await { + if let Err(error) = + nats_client.broadcast(&broadcast, &farm_id_string).await + { + warn!(%farm_id, %error, "Failed to broadcast farming notification"); + } + } + }; + let solutions_fut = async { + while let Some(broadcast) = solutions_receiver.next().await { + if let Err(error) = + nats_client.broadcast(&broadcast, &farm_id_string).await + { + warn!(%farm_id, %error, "Failed to broadcast solution"); + } + } + }; + + select! { + _ = sector_updates_fut.fuse() => {} + _ = farming_notifications_fut.fuse() => {} + _ = solutions_fut.fuse() => {} + } + + drop(sector_updates_handler_id); + drop(farming_notifications_handler_id); + drop(solutions_handler_id); + }), + true, + ); + + FarmDetails { + farm_id, + farm_id_string: farm_id.to_string(), + total_sectors_count: farm.total_sectors_count(), + piece_reader: farm.piece_reader(), + plotted_sectors: farm.plotted_sectors(), + _background_tasks: background_tasks, + } + }) + .collect::>(); + + async move { + select! { + result = identify_responder(&nats_client, &farms_details, identification_broadcast_interval).fuse() => { + result + }, + result = plotted_sectors_responder(&nats_client, &farms_details).fuse() => { + result + }, + result = read_piece_responder(&nats_client, &farms_details).fuse() => { + result + }, + } + } +} + +// Listen for farmer identification broadcast from controller and publish identification +// broadcast in response, also send periodic notifications reminding that farm exists +async fn identify_responder( + nats_client: &NatsClient, + farms_details: &[FarmDetails], + identification_broadcast_interval: Duration, +) -> anyhow::Result<()> { + let mut subscription = nats_client + .subscribe_to_broadcasts::( + None, + // Use the first farm as a queue group. Doesn't matter what we use, just needs to be + // deterministic. + farms_details + .first() + .map(|farm_details| farm_details.farm_id_string.clone()), + ) + .await + .map_err(|error| { + anyhow!("Failed to subscribe to farmer identify broadcast requests: {error}") + })? + .fuse(); + // Also send periodic updates in addition to the subscription response + let mut interval = tokio::time::interval(identification_broadcast_interval); + interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + + let mut last_identification = Instant::now(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + debug!("Identify broadcast stream ended"); + break; + }; + + trace!(?message, "Farmer received identify broadcast message"); + + if last_identification.elapsed() < MIN_FARMER_IDENTIFICATION_INTERVAL { + // Skip too frequent identification requests + continue; + } + + last_identification = Instant::now(); + send_identify_broadcast(nats_client, farms_details).await; + interval.reset(); + } + _ = interval.tick().fuse() => { + last_identification = Instant::now(); + trace!("Farmer self-identification"); + + send_identify_broadcast(nats_client, farms_details).await; + } + } + } + + Ok(()) +} + +async fn send_identify_broadcast(nats_client: &NatsClient, farms_details: &[FarmDetails]) { + farms_details + .iter() + .map(|farm_details| async move { + if let Err(error) = nats_client + .broadcast( + &ClusterFarmerIdentifyFarmBroadcast { + farm_id: farm_details.farm_id, + total_sectors_count: farm_details.total_sectors_count, + fingerprint: blake3_hash_list(&[ + &farm_details.farm_id.encode(), + &farm_details.total_sectors_count.to_le_bytes(), + ]), + }, + &farm_details.farm_id_string, + ) + .await + { + warn!( + farm_id = %farm_details.farm_id, + %error, + "Failed to send farmer identify notification" + ); + } + }) + .collect::>() + .collect::>() + .await; +} + +async fn plotted_sectors_responder( + nats_client: &NatsClient, + farms_details: &[FarmDetails], +) -> anyhow::Result<()> { + farms_details + .iter() + .map(|farm_details| async move { + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered::from_iter([ + Box::pin(pending()) as Pin + Send>> + ]); + let mut subscription = nats_client + .subscribe_to_stream_requests( + Some(&farm_details.farm_id_string), + Some(farm_details.farm_id_string.clone()), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to plotted sectors requests for farm {}: {}", + farm_details.farm_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_plotted_sectors_request( + nats_client, + farm_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No farms"))? +} + +async fn process_plotted_sectors_request( + nats_client: &NatsClient, + farm_details: &FarmDetails, + request: StreamRequest, +) { + trace!(?request, "Plotted sectors request"); + + match farm_details.plotted_sectors.get().await { + Ok(plotted_sectors) => { + nats_client + .stream_response::( + request.response_subject, + plotted_sectors.map(|maybe_plotted_sector| { + maybe_plotted_sector.map_err(|error| error.to_string()) + }), + ) + .await; + } + Err(error) => { + error!( + %error, + farm_id = %farm_details.farm_id, + "Failed to get plotted sectors" + ); + + nats_client + .stream_response::( + request.response_subject, + pin!(stream::once(async move { + Err(format!("Failed to get plotted sectors: {error}")) + })), + ) + .await; + } + } +} + +async fn read_piece_responder( + nats_client: &NatsClient, + farms_details: &[FarmDetails], +) -> anyhow::Result<()> { + farms_details + .iter() + .map(|farm_details| async move { + // Initialize with pending future so it never ends + let mut processing = + FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + let mut subscription = nats_client + .queue_subscribe( + ClusterFarmerReadPieceRequest::SUBJECT + .replace('*', &farm_details.farm_id_string), + farm_details.farm_id_string.clone(), + ) + .await + .map_err(|error| { + anyhow!( + "Failed to subscribe to read piece requests for farm {}: {}", + farm_details.farm_id, + error + ) + })? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_read_piece_request( + nats_client, + farm_details, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) + }) + .collect::>() + .next() + .await + .ok_or_else(|| anyhow!("No farms"))? +} + +async fn process_read_piece_request( + nats_client: &NatsClient, + farm_details: &FarmDetails, + message: Message, +) { + let Some(reply_subject) = message.reply else { + return; + }; + + let ClusterFarmerReadPieceRequest { + sector_index, + piece_offset, + } = match ClusterFarmerReadPieceRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode read piece request" + ); + return; + } + }; + + let response: ::Response = farm_details + .piece_reader + .read_piece(sector_index, piece_offset) + .await + .map_err(|error| error.to_string()); + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send read piece response"); + } +} diff --git a/crates/subspace-farmer/src/cluster/plotter.rs b/crates/subspace-farmer/src/cluster/plotter.rs new file mode 100644 index 0000000000..4230de2d1c --- /dev/null +++ b/crates/subspace-farmer/src/cluster/plotter.rs @@ -0,0 +1,960 @@ +//! Farming cluster plotter +//! +//! Plotter is responsible for plotting sectors in response to farmer requests. +//! +//! This module exposes some data structures for NATS communication, custom plotter +//! implementation designed to work with cluster plotter and a service function to drive the backend +//! part of the plotter. + +use crate::cluster::nats_client::{ + GenericRequest, GenericStreamRequest, NatsClient, StreamRequest, +}; +use crate::plotter::{Plotter, SectorPlottingProgress}; +use crate::utils::AsyncJoinOnDrop; +use anyhow::anyhow; +use async_trait::async_trait; +use backoff::backoff::Backoff; +use backoff::ExponentialBackoff; +use derive_more::Display; +use event_listener_primitives::{Bag, HandlerId}; +use futures::channel::mpsc; +use futures::stream::FuturesUnordered; +use futures::{select, stream, FutureExt, Sink, SinkExt, StreamExt}; +use parity_scale_codec::{Decode, Encode}; +use std::error::Error; +use std::future::{pending, Future}; +use std::num::NonZeroUsize; +use std::pin::{pin, Pin}; +use std::sync::Arc; +use std::time::{Duration, Instant}; +use subspace_core_primitives::{PublicKey, SectorIndex}; +use subspace_farmer_components::plotting::PlottedSector; +use subspace_farmer_components::FarmerProtocolInfo; +use tokio::sync::{OwnedSemaphorePermit, Semaphore}; +use tokio::time::MissedTickBehavior; +use tracing::{debug, info, info_span, trace, warn, Instrument}; +use ulid::Ulid; + +const FREE_CAPACITY_CHECK_INTERVAL: Duration = Duration::from_secs(1); +const PING_INTERVAL: Duration = Duration::from_secs(5); + +pub type HandlerFn3 = Arc; +type Handler3 = Bag, A, B, C>; + +/// An ephemeral identifier for a plotter +#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Display)] +pub enum ClusterPlotterId { + Ulid(Ulid), +} + +#[allow(clippy::new_without_default)] +impl ClusterPlotterId { + /// Creates new ID + pub fn new() -> Self { + Self::Ulid(Ulid::new()) + } +} + +/// Request for free plotter instance +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterPlotterFreeInstanceRequest; + +impl GenericRequest for ClusterPlotterFreeInstanceRequest { + const SUBJECT: &'static str = "subspace.plotter.free-instance"; + /// Might be `None` if instance had to respond, but turned out it was fully occupied already + type Response = Option; +} + +#[derive(Debug, Encode, Decode)] +enum ClusterSectorPlottingProgress { + /// Plotter is already fully occupied with other work + Occupied, + /// Periodic ping indicating plotter is still busy + Ping, + /// Downloading sector pieces + Downloading, + /// Downloaded sector pieces + Downloaded(Duration), + /// Encoding sector pieces + Encoding, + /// Encoded sector pieces + Encoded(Duration), + /// Finished plotting, followed by a series of sector chunks + Finished { + /// Information about plotted sector + plotted_sector: PlottedSector, + /// How much time it took to plot a sector + time: Duration, + }, + /// Sector chunk after finished plotting + SectorChunk(Result, String>), + /// Plotting failed + Error { + /// Error message + error: String, + }, +} + +/// Request to plot sector from plotter +#[derive(Debug, Clone, Encode, Decode)] +struct ClusterPlotterPlotSectorRequest { + public_key: PublicKey, + sector_index: SectorIndex, + farmer_protocol_info: FarmerProtocolInfo, + pieces_in_sector: u16, +} + +impl GenericStreamRequest for ClusterPlotterPlotSectorRequest { + const SUBJECT: &'static str = "subspace.plotter.*.plot-sector"; + type Response = ClusterSectorPlottingProgress; +} + +#[derive(Default, Debug)] +struct Handlers { + plotting_progress: Handler3, +} + +/// Cluster plotter +pub struct ClusterPlotter { + sector_encoding_semaphore: Arc, + retry_backoff_policy: ExponentialBackoff, + nats_client: NatsClient, + handlers: Arc, + tasks_sender: mpsc::Sender>, + _background_tasks: AsyncJoinOnDrop<()>, +} + +impl Drop for ClusterPlotter { + #[inline] + fn drop(&mut self) { + self.tasks_sender.close_channel(); + } +} + +#[async_trait] +impl Plotter for ClusterPlotter { + async fn has_free_capacity(&self) -> Result { + Ok(self.sector_encoding_semaphore.available_permits() > 0 + && self + .nats_client + .request(&ClusterPlotterFreeInstanceRequest, None) + .await + .map_err(|error| error.to_string())? + .is_some()) + } + + async fn plot_sector( + &self, + public_key: PublicKey, + sector_index: SectorIndex, + farmer_protocol_info: FarmerProtocolInfo, + pieces_in_sector: u16, + _replotting: bool, + mut progress_sender: PS, + ) where + PS: Sink + Unpin + Send + 'static, + PS::Error: Error, + { + let start = Instant::now(); + + // Done outside the future below as a backpressure, ensuring that it is not possible to + // schedule unbounded number of plotting tasks + let sector_encoding_permit = match Arc::clone(&self.sector_encoding_semaphore) + .acquire_owned() + .await + { + Ok(sector_encoding_permit) => sector_encoding_permit, + Err(error) => { + warn!(%error, "Failed to acquire sector encoding permit"); + + let progress_updater = ProgressUpdater { + public_key, + sector_index, + handlers: Arc::clone(&self.handlers), + }; + + progress_updater + .update_progress_and_events( + &mut progress_sender, + SectorPlottingProgress::Error { + error: format!("Failed to acquire sector encoding permit: {error}"), + }, + ) + .await; + + return; + } + }; + + self.plot_sector_internal( + start, + sector_encoding_permit, + public_key, + sector_index, + farmer_protocol_info, + pieces_in_sector, + progress_sender, + ) + .await + } + + async fn try_plot_sector( + &self, + public_key: PublicKey, + sector_index: SectorIndex, + farmer_protocol_info: FarmerProtocolInfo, + pieces_in_sector: u16, + _replotting: bool, + progress_sender: PS, + ) -> bool + where + PS: Sink + Unpin + Send + 'static, + PS::Error: Error, + { + let start = Instant::now(); + + let Ok(sector_encoding_permit) = + Arc::clone(&self.sector_encoding_semaphore).try_acquire_owned() + else { + return false; + }; + + self.plot_sector_internal( + start, + sector_encoding_permit, + public_key, + sector_index, + farmer_protocol_info, + pieces_in_sector, + progress_sender, + ) + .await; + + true + } +} + +impl ClusterPlotter { + /// Create new instance + pub fn new( + nats_client: NatsClient, + sector_encoding_concurrency: NonZeroUsize, + retry_backoff_policy: ExponentialBackoff, + ) -> Self { + let sector_encoding_semaphore = Arc::new(Semaphore::new(sector_encoding_concurrency.get())); + + let (tasks_sender, mut tasks_receiver) = mpsc::channel(1); + + // Basically runs plotting tasks in the background and allows to abort on drop + let background_tasks = AsyncJoinOnDrop::new( + tokio::spawn(async move { + let background_tasks = FuturesUnordered::new(); + let mut background_tasks = pin!(background_tasks); + // Just so that `FuturesUnordered` will never end + background_tasks.push(AsyncJoinOnDrop::new(tokio::spawn(pending::<()>()), true)); + + loop { + select! { + maybe_background_task = tasks_receiver.next().fuse() => { + let Some(background_task) = maybe_background_task else { + break; + }; + + background_tasks.push(background_task); + }, + _ = background_tasks.select_next_some() => { + // Nothing to do + } + } + } + }), + true, + ); + + Self { + sector_encoding_semaphore, + retry_backoff_policy, + nats_client, + handlers: Arc::default(), + tasks_sender, + _background_tasks: background_tasks, + } + } + + /// Subscribe to plotting progress notifications + pub fn on_plotting_progress( + &self, + callback: HandlerFn3, + ) -> HandlerId { + self.handlers.plotting_progress.add(callback) + } + + #[allow(clippy::too_many_arguments)] + async fn plot_sector_internal( + &self, + start: Instant, + sector_encoding_permit: OwnedSemaphorePermit, + public_key: PublicKey, + sector_index: SectorIndex, + farmer_protocol_info: FarmerProtocolInfo, + pieces_in_sector: u16, + mut progress_sender: PS, + ) where + PS: Sink + Unpin + Send + 'static, + PS::Error: Error, + { + let span = info_span!("", %public_key, %sector_index); + let _span_guard = span.enter(); + + trace!("Starting plotting, getting plotting permit"); + + let progress_updater = ProgressUpdater { + public_key, + sector_index, + handlers: Arc::clone(&self.handlers), + }; + + let mut retry_backoff_policy = self.retry_backoff_policy.clone(); + retry_backoff_policy.reset(); + + // Try to get plotter instance here first as a backpressure measure + let free_plotter_instance_fut = get_free_plotter_instance( + &self.nats_client, + &progress_updater, + &mut progress_sender, + &mut retry_backoff_policy, + ); + let mut maybe_free_instance = free_plotter_instance_fut.await; + if maybe_free_instance.is_none() { + return; + } + + trace!("Got plotting permit #1"); + + let nats_client = self.nats_client.clone(); + + let plotting_fut = async move { + 'outer: loop { + // Take free instance that was found earlier if available or try to find a new one + let free_instance = match maybe_free_instance.take() { + Some(free_instance) => free_instance, + None => { + let free_plotter_instance_fut = get_free_plotter_instance( + &nats_client, + &progress_updater, + &mut progress_sender, + &mut retry_backoff_policy, + ); + let Some(free_instance) = free_plotter_instance_fut.await else { + break; + }; + trace!("Got plotting permit #2"); + free_instance + } + }; + + let response_stream_result = nats_client + .stream_request( + ClusterPlotterPlotSectorRequest { + public_key, + sector_index, + farmer_protocol_info, + pieces_in_sector, + }, + Some(&free_instance), + ) + .await; + trace!("Subscribed to plotting notifications"); + + let mut response_stream = match response_stream_result { + Ok(response_stream) => response_stream, + Err(error) => { + progress_updater + .update_progress_and_events( + &mut progress_sender, + SectorPlottingProgress::Error { + error: format!("Failed make stream request: {error}"), + }, + ) + .await; + + break; + } + }; + + let (mut sector_sender, sector_receiver) = mpsc::channel(1); + let mut maybe_sector_receiver = Some(sector_receiver); + loop { + match tokio::time::timeout(PING_INTERVAL * 2, response_stream.next()).await { + Ok(Some(response)) => { + match process_response_notification( + &start, + &free_instance, + &progress_updater, + &mut progress_sender, + &mut retry_backoff_policy, + response, + &mut sector_sender, + &mut maybe_sector_receiver, + ) + .await + { + ResponseProcessingResult::Retry => { + debug!("Retrying"); + continue 'outer; + } + ResponseProcessingResult::Abort => { + debug!("Aborting"); + break 'outer; + } + ResponseProcessingResult::Continue => { + // Nothing to do + } + } + } + Ok(None) => { + trace!("Plotting done"); + break; + } + Err(_error) => { + progress_updater + .update_progress_and_events( + &mut progress_sender, + SectorPlottingProgress::Error { + error: "Timed out without ping from plotter".to_string(), + }, + ) + .await; + break; + } + } + } + + break; + } + + drop(sector_encoding_permit); + }; + + let plotting_task = + AsyncJoinOnDrop::new(tokio::spawn(plotting_fut.instrument(span.clone())), true); + if let Err(error) = self.tasks_sender.clone().send(plotting_task).await { + warn!(%error, "Failed to send plotting task"); + + let progress = SectorPlottingProgress::Error { + error: format!("Failed to send plotting task: {error}"), + }; + + self.handlers + .plotting_progress + .call_simple(&public_key, §or_index, &progress); + } + } +} + +// Try to get free plotter instance and return `None` if it is not possible +async fn get_free_plotter_instance( + nats_client: &NatsClient, + progress_updater: &ProgressUpdater, + progress_sender: &mut PS, + retry_backoff_policy: &mut ExponentialBackoff, +) -> Option +where + PS: Sink + Unpin + Send + 'static, + PS::Error: Error, +{ + loop { + match nats_client + .request(&ClusterPlotterFreeInstanceRequest, None) + .await + { + Ok(Some(free_instance)) => { + return Some(free_instance); + } + Ok(None) => { + if let Some(delay) = retry_backoff_policy.next_backoff() { + debug!("Instance was occupied, retrying #1"); + + tokio::time::sleep(delay).await; + continue; + } else { + progress_updater + .update_progress_and_events( + progress_sender, + SectorPlottingProgress::Error { + error: "Instance was occupied, exiting #1".to_string(), + }, + ) + .await; + return None; + } + } + // TODO: Handle different kinds of errors differently, not all of them are + // fatal + Err(error) => { + progress_updater + .update_progress_and_events( + progress_sender, + SectorPlottingProgress::Error { + error: format!("Failed to get free plotter instance: {error}"), + }, + ) + .await; + return None; + } + }; + } +} + +enum ResponseProcessingResult { + Retry, + Abort, + Continue, +} + +#[allow(clippy::too_many_arguments)] +async fn process_response_notification( + start: &Instant, + free_instance: &str, + progress_updater: &ProgressUpdater, + progress_sender: &mut PS, + retry_backoff_policy: &mut ExponentialBackoff, + response: ClusterSectorPlottingProgress, + sector_sender: &mut mpsc::Sender, String>>, + maybe_sector_receiver: &mut Option, String>>>, +) -> ResponseProcessingResult +where + PS: Sink + Unpin + Send + 'static, + PS::Error: Error, +{ + match response { + ClusterSectorPlottingProgress::Occupied => { + debug!(%free_instance, "Instance was occupied, retrying #2"); + + if let Some(delay) = retry_backoff_policy.next_backoff() { + debug!("Instance was occupied, retrying #2"); + + tokio::time::sleep(delay).await; + return ResponseProcessingResult::Retry; + } else { + debug!("Instance was occupied, exiting #2"); + return ResponseProcessingResult::Abort; + } + } + ClusterSectorPlottingProgress::Ping => { + // Expected + } + ClusterSectorPlottingProgress::Downloading => { + if !progress_updater + .update_progress_and_events(progress_sender, SectorPlottingProgress::Downloading) + .await + { + return ResponseProcessingResult::Abort; + } + } + ClusterSectorPlottingProgress::Downloaded(time) => { + if !progress_updater + .update_progress_and_events( + progress_sender, + SectorPlottingProgress::Downloaded(time), + ) + .await + { + return ResponseProcessingResult::Abort; + } + } + ClusterSectorPlottingProgress::Encoding => { + if !progress_updater + .update_progress_and_events(progress_sender, SectorPlottingProgress::Encoding) + .await + { + return ResponseProcessingResult::Abort; + } + } + ClusterSectorPlottingProgress::Encoded(time) => { + if !progress_updater + .update_progress_and_events(progress_sender, SectorPlottingProgress::Encoded(time)) + .await + { + return ResponseProcessingResult::Abort; + } + } + ClusterSectorPlottingProgress::Finished { + plotted_sector, + time: _, + } => { + let Some(sector_receiver) = maybe_sector_receiver.take() else { + debug!("Unexpected duplicated sector plotting progress Finished"); + + progress_updater + .update_progress_and_events( + progress_sender, + SectorPlottingProgress::Error { + error: "Unexpected duplicated sector plotting progress Finished" + .to_string(), + }, + ) + .await; + return ResponseProcessingResult::Abort; + }; + + let progress = SectorPlottingProgress::Finished { + plotted_sector, + // Use local time instead of reported by remote plotter + time: start.elapsed(), + sector: Box::pin(sector_receiver), + }; + if !progress_updater + .update_progress_and_events(progress_sender, progress) + .await + { + return ResponseProcessingResult::Abort; + } + + return ResponseProcessingResult::Continue; + } + // This variant must be sent after Finished and it handled above + ClusterSectorPlottingProgress::SectorChunk(maybe_sector_chunk) => { + if let Err(error) = sector_sender.send(maybe_sector_chunk).await { + warn!(%error, "Failed to send sector chunk"); + return ResponseProcessingResult::Abort; + } + return ResponseProcessingResult::Continue; + } + ClusterSectorPlottingProgress::Error { error } => { + if !progress_updater + .update_progress_and_events( + progress_sender, + SectorPlottingProgress::Error { error }, + ) + .await + { + return ResponseProcessingResult::Abort; + } + } + } + + ResponseProcessingResult::Continue +} + +struct ProgressUpdater { + public_key: PublicKey, + sector_index: SectorIndex, + handlers: Arc, +} + +impl ProgressUpdater { + /// Returns `true` on success and `false` if progress receiver channel is gone + async fn update_progress_and_events( + &self, + progress_sender: &mut PS, + progress: SectorPlottingProgress, + ) -> bool + where + PS: Sink + Unpin, + PS::Error: Error, + { + self.handlers.plotting_progress.call_simple( + &self.public_key, + &self.sector_index, + &progress, + ); + + if let Err(error) = progress_sender.send(progress).await { + warn!(%error, "Failed to send error progress update"); + + false + } else { + true + } + } +} + +/// Create plotter service that will be processing incoming requests. +/// +/// Implementation is using concurrency with multiple tokio tasks, but can be started multiple times +/// per controller instance in order to parallelize more work across threads if needed. +pub async fn plotter_service

(nats_client: &NatsClient, cpu_plotter: &P) -> anyhow::Result<()> +where + P: Plotter + Sync, +{ + let plotter_id = ClusterPlotterId::new(); + + select! { + result = free_instance_responder(&plotter_id, nats_client, cpu_plotter).fuse() => { + result + } + result = plot_sector_responder(&plotter_id, nats_client, cpu_plotter).fuse() => { + result + } + } +} + +async fn free_instance_responder

( + plotter_id: &ClusterPlotterId, + nats_client: &NatsClient, + cpu_plotter: &P, +) -> anyhow::Result<()> +where + P: Plotter + Sync, +{ + loop { + while !cpu_plotter.has_free_capacity().await.unwrap_or_default() { + tokio::time::sleep(FREE_CAPACITY_CHECK_INTERVAL).await; + } + + let mut subscription = nats_client + .queue_subscribe( + ClusterPlotterFreeInstanceRequest::SUBJECT, + "subspace.plotter".to_string(), + ) + .await + .map_err(|error| anyhow!("Failed to subscribe to free instance requests: {error}"))?; + + while let Some(message) = subscription.next().await { + let Some(reply_subject) = message.reply else { + continue; + }; + + let has_free_capacity = cpu_plotter.has_free_capacity().await.unwrap_or_default(); + let response: ::Response = + has_free_capacity.then(|| plotter_id.to_string()); + + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send free instance response"); + } + + if !has_free_capacity { + subscription.unsubscribe().await.map_err(|error| { + anyhow!("Failed to unsubscribe from free instance requests: {error}") + })?; + } + } + } +} + +async fn plot_sector_responder

( + plotter_id: &ClusterPlotterId, + nats_client: &NatsClient, + cpu_plotter: &P, +) -> anyhow::Result<()> +where + P: Plotter + Sync, +{ + let plotter_id_string = plotter_id.to_string(); + + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered::from_iter([ + Box::pin(pending()) as Pin + Send>> + ]); + let mut subscription = nats_client + .subscribe_to_stream_requests(Some(&plotter_id_string), Some(plotter_id_string.clone())) + .await + .map_err(|error| anyhow!("Failed to subscribe to plot sector requests: {}", error))? + .fuse(); + + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; + + // Create background task for concurrent processing + processing.push(Box::pin(process_plot_sector_request( + nats_client, + cpu_plotter, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + + Ok(()) +} + +async fn process_plot_sector_request

( + nats_client: &NatsClient, + cpu_plotter: &P, + request: StreamRequest, +) where + P: Plotter, +{ + let StreamRequest { + request: + ClusterPlotterPlotSectorRequest { + public_key, + sector_index, + farmer_protocol_info, + pieces_in_sector, + }, + response_subject, + } = request; + + // Wrapper future just for instrumentation below + let inner_fut = async { + info!("Plot sector request"); + + let (progress_sender, mut progress_receiver) = mpsc::channel(1); + + if !cpu_plotter + .try_plot_sector( + public_key, + sector_index, + farmer_protocol_info, + pieces_in_sector, + false, + progress_sender, + ) + .await + { + debug!("Plotter is currently occupied and can't plot more sectors"); + + nats_client + .stream_response::( + response_subject, + pin!(stream::once(async move { + ClusterSectorPlottingProgress::Occupied + })), + ) + .await; + return; + } + + let (mut response_proxy_sender, response_proxy_receiver) = mpsc::channel(0); + + let response_streaming_fut = nats_client + .stream_response::( + response_subject, + response_proxy_receiver, + ) + .fuse(); + let mut response_streaming_fut = pin!(response_streaming_fut); + let progress_proxy_fut = { + let mut response_proxy_sender = response_proxy_sender.clone(); + let approximate_max_message_size = nats_client.approximate_max_message_size(); + + async move { + while let Some(progress) = progress_receiver.next().await { + send_publish_progress( + &mut response_proxy_sender, + progress, + approximate_max_message_size, + ) + .await; + } + } + }; + + let mut ping_interval = tokio::time::interval(PING_INTERVAL); + ping_interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + let ping_fut = async { + loop { + ping_interval.tick().await; + if let Err(error) = response_proxy_sender + .send(ClusterSectorPlottingProgress::Ping) + .await + { + warn!(%error, "Failed to send plotting ping"); + return; + } + } + }; + + select! { + _ = response_streaming_fut => { + warn!("Response sending ended early"); + + return; + } + _ = progress_proxy_fut.fuse() => { + // Done + } + _ = ping_fut.fuse() => { + unreachable!("Ping loop never ends"); + } + } + + // Drain remaining progress messages + response_streaming_fut.await; + + info!("Finished plotting sector successfully"); + }; + + inner_fut + .instrument(info_span!("", %public_key, %sector_index)) + .await +} + +async fn send_publish_progress( + response_sender: &mut mpsc::Sender, + progress: SectorPlottingProgress, + approximate_max_message_size: usize, +) { + // Finished response is large and needs special care + let cluster_progress = match progress { + SectorPlottingProgress::Downloading => ClusterSectorPlottingProgress::Downloading, + SectorPlottingProgress::Downloaded(time) => ClusterSectorPlottingProgress::Downloaded(time), + SectorPlottingProgress::Encoding => ClusterSectorPlottingProgress::Encoding, + SectorPlottingProgress::Encoded(time) => ClusterSectorPlottingProgress::Encoded(time), + SectorPlottingProgress::Finished { + plotted_sector, + time, + mut sector, + } => { + if let Err(error) = response_sender + .send(ClusterSectorPlottingProgress::Finished { + plotted_sector, + time, + }) + .await + { + warn!(%error, "Failed to send plotting progress"); + return; + } + + while let Some(maybe_sector_chunk) = sector.next().await { + match maybe_sector_chunk { + Ok(sector_chunk) => { + // Slice large chunks into smaller ones before publishing + for sector_chunk in sector_chunk.chunks(approximate_max_message_size) { + if let Err(error) = response_sender + .send(ClusterSectorPlottingProgress::SectorChunk(Ok( + sector_chunk.to_vec() + ))) + .await + { + warn!(%error, "Failed to send plotting progress"); + return; + } + } + } + Err(error) => { + if let Err(error) = response_sender + .send(ClusterSectorPlottingProgress::SectorChunk(Err(error))) + .await + { + warn!(%error, "Failed to send plotting progress"); + return; + } + } + } + } + + response_sender.close_channel(); + + return; + } + SectorPlottingProgress::Error { error } => ClusterSectorPlottingProgress::Error { error }, + }; + + if let Err(error) = response_sender.send(cluster_progress).await { + warn!(%error, "Failed to send plotting progress"); + } +} From 9caa831e1d5f289c9451ad55b51a5efa03e1dd4c Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Mon, 13 May 2024 15:51:10 +0300 Subject: [PATCH 02/15] Additional logs --- crates/subspace-farmer/src/cluster/cache.rs | 27 ++++++++++----- .../subspace-farmer/src/cluster/controller.rs | 9 +++-- crates/subspace-farmer/src/cluster/farmer.rs | 9 +++-- .../src/cluster/nats_client.rs | 33 ++++++++++++++----- crates/subspace-farmer/src/cluster/plotter.rs | 10 ++++-- 5 files changed, 61 insertions(+), 27 deletions(-) diff --git a/crates/subspace-farmer/src/cluster/cache.rs b/crates/subspace-farmer/src/cluster/cache.rs index e4f543752b..441247827a 100644 --- a/crates/subspace-farmer/src/cluster/cache.rs +++ b/crates/subspace-farmer/src/cluster/cache.rs @@ -378,7 +378,7 @@ where FuturesUnordered:: + Send>>>::from_iter([ Box::pin(pending()) as Pin>, ]); - let mut subscription = nats_client + let subscription = nats_client .queue_subscribe( ClusterCacheWritePieceRequest::SUBJECT .replace('*', &cache_details.cache_id_string), @@ -391,8 +391,9 @@ where cache_details.cache_id, error ) - })? - .fuse(); + })?; + debug!(?subscription, "Write piece requests subscription"); + let mut subscription = subscription.fuse(); loop { select! { @@ -449,6 +450,8 @@ async fn process_write_piece_request( } }; + trace!(%offset, %piece_index, %reply_subject, "Write piece request"); + let response: ::Response = cache_details .cache .write_piece(offset, piece_index, &piece) @@ -478,7 +481,7 @@ where FuturesUnordered:: + Send>>>::from_iter([ Box::pin(pending()) as Pin>, ]); - let mut subscription = nats_client + let subscription = nats_client .queue_subscribe( ClusterCacheReadPieceIndexRequest::SUBJECT .replace('*', &cache_details.cache_id_string), @@ -491,8 +494,9 @@ where cache_details.cache_id, error ) - })? - .fuse(); + })?; + debug!(?subscription, "Read piece index requests subscription"); + let mut subscription = subscription.fuse(); loop { select! { @@ -546,6 +550,8 @@ async fn process_read_piece_index_request( } }; + trace!(%offset, %reply_subject, "Read piece index request"); + let response: ::Response = cache_details .cache .read_piece_index(offset) @@ -575,7 +581,7 @@ where FuturesUnordered:: + Send>>>::from_iter([ Box::pin(pending()) as Pin>, ]); - let mut subscription = nats_client + let subscription = nats_client .queue_subscribe( ClusterCacheReadPieceRequest::SUBJECT .replace('*', &cache_details.cache_id_string), @@ -588,8 +594,9 @@ where cache_details.cache_id, error ) - })? - .fuse(); + })?; + debug!(?subscription, "Read piece requests subscription"); + let mut subscription = subscription.fuse(); loop { select! { @@ -643,6 +650,8 @@ async fn process_read_piece_request( } }; + trace!(%offset, %reply_subject, "Read piece request"); + let response: ::Response = cache_details .cache .read_piece(offset) diff --git a/crates/subspace-farmer/src/cluster/controller.rs b/crates/subspace-farmer/src/cluster/controller.rs index 1cf4ce9d56..439045f62e 100644 --- a/crates/subspace-farmer/src/cluster/controller.rs +++ b/crates/subspace-farmer/src/cluster/controller.rs @@ -543,6 +543,7 @@ where ) .await .map_err(|error| anyhow!("Failed to subscribe to farmer app info requests: {error}"))?; + debug!(?subscription, "Farmer app info requests subscription"); let mut last_farmer_app_info: ::Response = node_client .farmer_app_info() @@ -594,6 +595,7 @@ where ) .await .map_err(|error| anyhow!("Failed to subscribe to segment headers requests: {error}"))?; + debug!(?subscription, "Segment headers requests subscription"); let mut last_request_response = None::<( ClusterControllerSegmentHeadersRequest, @@ -660,14 +662,15 @@ where Box::pin(pending()) as Pin>, ]); - let mut subscription = nats_client + let subscription = nats_client .queue_subscribe( ClusterControllerPieceRequest::SUBJECT, "subspace.controller".to_string(), ) .await - .map_err(|error| anyhow!("Failed to subscribe to piece requests: {error}"))? - .fuse(); + .map_err(|error| anyhow!("Failed to subscribe to piece requests: {error}"))?; + debug!(?subscription, "Piece requests subscription"); + let mut subscription = subscription.fuse(); loop { select! { diff --git a/crates/subspace-farmer/src/cluster/farmer.rs b/crates/subspace-farmer/src/cluster/farmer.rs index 1ed0c35ccd..6bf51ab333 100644 --- a/crates/subspace-farmer/src/cluster/farmer.rs +++ b/crates/subspace-farmer/src/cluster/farmer.rs @@ -752,7 +752,7 @@ async fn read_piece_responder( FuturesUnordered:: + Send>>>::from_iter([ Box::pin(pending()) as Pin>, ]); - let mut subscription = nats_client + let subscription = nats_client .queue_subscribe( ClusterFarmerReadPieceRequest::SUBJECT .replace('*', &farm_details.farm_id_string), @@ -765,8 +765,9 @@ async fn read_piece_responder( farm_details.farm_id, error ) - })? - .fuse(); + })?; + debug!(?subscription, "Read piece requests subscription"); + let mut subscription = subscription.fuse(); loop { select! { @@ -820,6 +821,8 @@ async fn process_read_piece_request( } }; + trace!(%sector_index, %piece_offset, %reply_subject, "Read piece request"); + let response: ::Response = farm_details .piece_reader .read_piece(sector_index, piece_offset) diff --git a/crates/subspace-farmer/src/cluster/nats_client.rs b/crates/subspace-farmer/src/cluster/nats_client.rs index 06522279e2..2d04b166bf 100644 --- a/crates/subspace-farmer/src/cluster/nats_client.rs +++ b/crates/subspace-farmer/src/cluster/nats_client.rs @@ -532,6 +532,7 @@ impl NatsClient { .client() .subscribe(stream_request.response_subject.clone()) .await?; + debug!(request_type = %type_name::(), ?subscriber, "Stream request subscription"); self.client() .publish( @@ -604,6 +605,12 @@ impl NatsClient { return; } }; + debug!( + request_type = %type_name::(), + response_type = %type_name::(), + ?ack_subscription, + "Ack subscription subscription" + ); let mut index = 0; loop { @@ -830,16 +837,24 @@ impl NatsClient { where Message: Decode, { + let subscriber = if let Some(queue_group) = queue_group { + self.client() + .queue_subscribe(subject_with_instance(subject, instance), queue_group) + .await? + } else { + self.client() + .subscribe(subject_with_instance(subject, instance)) + .await? + }; + debug!( + %subject, + message_type = %type_name::(), + ?subscriber, + "Simple subscription" + ); + Ok(SubscriberWrapper { - subscriber: if let Some(queue_group) = queue_group { - self.client() - .queue_subscribe(subject_with_instance(subject, instance), queue_group) - .await? - } else { - self.client() - .subscribe(subject_with_instance(subject, instance)) - .await? - }, + subscriber, _phantom: PhantomData, }) } diff --git a/crates/subspace-farmer/src/cluster/plotter.rs b/crates/subspace-farmer/src/cluster/plotter.rs index 4230de2d1c..7e999f252b 100644 --- a/crates/subspace-farmer/src/cluster/plotter.rs +++ b/crates/subspace-farmer/src/cluster/plotter.rs @@ -710,12 +710,15 @@ where ) .await .map_err(|error| anyhow!("Failed to subscribe to free instance requests: {error}"))?; + debug!(?subscription, "Free instance subscription"); while let Some(message) = subscription.next().await { let Some(reply_subject) = message.reply else { continue; }; + debug!(%reply_subject, "Free instance request"); + let has_free_capacity = cpu_plotter.has_free_capacity().await.unwrap_or_default(); let response: ::Response = has_free_capacity.then(|| plotter_id.to_string()); @@ -750,11 +753,12 @@ where let mut processing = FuturesUnordered::from_iter([ Box::pin(pending()) as Pin + Send>> ]); - let mut subscription = nats_client + let subscription = nats_client .subscribe_to_stream_requests(Some(&plotter_id_string), Some(plotter_id_string.clone())) .await - .map_err(|error| anyhow!("Failed to subscribe to plot sector requests: {}", error))? - .fuse(); + .map_err(|error| anyhow!("Failed to subscribe to plot sector requests: {}", error))?; + debug!(?subscription, "Plot sector subscription"); + let mut subscription = subscription.fuse(); loop { select! { From 7257373ffaa482ca7b424642dccfa7e25997d8fd Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Tue, 14 May 2024 01:31:29 +0300 Subject: [PATCH 03/15] Forward reward signature to all controllers --- crates/subspace-farmer/src/cluster/controller.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/crates/subspace-farmer/src/cluster/controller.rs b/crates/subspace-farmer/src/cluster/controller.rs index 439045f62e..d99b9142d5 100644 --- a/crates/subspace-farmer/src/cluster/controller.rs +++ b/crates/subspace-farmer/src/cluster/controller.rs @@ -118,7 +118,7 @@ pub struct ClusterControllerRewardSignatureNotification { } impl GenericNotification for ClusterControllerRewardSignatureNotification { - const SUBJECT: &'static str = "subspace.controller.*.reward-signature"; + const SUBJECT: &'static str = "subspace.controller.reward-signature"; } /// Request farmer app info from controller @@ -264,12 +264,11 @@ impl NodeClient for ClusterNodeClient { &self, reward_signature: RewardSignatureResponse, ) -> Result<(), NodeClientError> { - let last_slot_info_instance = self.last_slot_info_instance.lock().clone(); Ok(self .nats_client .notification( &ClusterControllerRewardSignatureNotification { reward_signature }, - Some(&last_slot_info_instance), + None, ) .await?) } @@ -507,7 +506,7 @@ where { let mut subscription = nats_client .subscribe_to_notifications::( - Some(instance), + None, Some(instance.to_string()), ) .await From 6575cb238294077ce41cfc7316a5eacd052fe52a Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Tue, 14 May 2024 02:56:10 +0300 Subject: [PATCH 04/15] Refactor cluster app info and segment headers responses with concurrency and full segment headers cache on controller --- .../commands/cluster/controller.rs | 9 +- .../subspace-farmer/src/cluster/controller.rs | 261 ++++++++++++------ 2 files changed, 189 insertions(+), 81 deletions(-) diff --git a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs index 07de54bca8..001d0c18d8 100644 --- a/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs +++ b/crates/subspace-farmer/src/bin/subspace-farmer/commands/cluster/controller.rs @@ -181,7 +181,14 @@ pub(super) async fn controller( let instance = instance.clone(); move || async move { - controller_service(&nats_client, &node_client, &piece_getter, &instance).await + controller_service( + &nats_client, + &node_client, + &piece_getter, + &instance, + &AsyncRwLock::default(), + ) + .await } }, "controller-service".to_string(), diff --git a/crates/subspace-farmer/src/cluster/controller.rs b/crates/subspace-farmer/src/cluster/controller.rs index d99b9142d5..1e347c6249 100644 --- a/crates/subspace-farmer/src/cluster/controller.rs +++ b/crates/subspace-farmer/src/cluster/controller.rs @@ -11,7 +11,7 @@ use crate::cluster::nats_client::{ }; use crate::node_client::{Error as NodeClientError, NodeClient}; use anyhow::anyhow; -use async_lock::Semaphore; +use async_lock::{Mutex as AsyncMutex, RwLock as AsyncRwLock, Semaphore}; use async_nats::{HeaderValue, Message}; use async_trait::async_trait; use futures::stream::FuturesUnordered; @@ -28,8 +28,9 @@ use subspace_core_primitives::{Piece, PieceIndex, SegmentHeader, SegmentIndex}; use subspace_farmer_components::PieceGetter; use subspace_rpc_primitives::{ FarmerAppInfo, RewardSignatureResponse, RewardSigningInfo, SlotInfo, SolutionResponse, + MAX_SEGMENT_HEADERS_PER_REQUEST, }; -use tracing::{debug, trace, warn}; +use tracing::{debug, info, trace, warn}; const FARMER_APP_INFO_DEDUPLICATION_WINDOW: Duration = Duration::from_secs(1); @@ -324,6 +325,7 @@ pub async fn controller_service( node_client: &NC, piece_getter: &PG, instance: &str, + segment_headers: &AsyncRwLock>, ) -> anyhow::Result<()> where NC: NodeClient, @@ -336,7 +338,7 @@ where result = reward_signing_broadcaster(nats_client, node_client, instance).fuse() => { result }, - result = archived_segment_headers_broadcaster(nats_client, node_client, instance).fuse() => { + result = archived_segment_headers_broadcaster(nats_client, node_client, instance, segment_headers).fuse() => { result }, result = solution_response_forwarder(nats_client, node_client, instance).fuse() => { @@ -348,7 +350,7 @@ where result = farmer_app_info_responder(nats_client, node_client).fuse() => { result }, - result = segment_headers_responder(nats_client, node_client).fuse() => { + result = segment_headers_responder(nats_client, segment_headers).fuse() => { result }, result = piece_responder(nats_client, piece_getter).fuse() => { @@ -428,6 +430,7 @@ async fn archived_segment_headers_broadcaster( nats_client: &NatsClient, node_client: &NC, instance: &str, + segment_headers: &AsyncRwLock>, ) -> anyhow::Result<()> where NC: NodeClient, @@ -439,6 +442,39 @@ where anyhow!("Failed to subscribe to archived segment header notifications: {error}") })?; + info!("Downloading all segment headers from node..."); + { + let mut segment_headers = segment_headers.write().await; + let mut segment_index_offset = SegmentIndex::from(segment_headers.len() as u64); + let segment_index_step = SegmentIndex::from(MAX_SEGMENT_HEADERS_PER_REQUEST as u64); + + 'outer: loop { + let from = segment_index_offset; + let to = segment_index_offset + segment_index_step; + trace!(%from, %to, "Requesting segment headers"); + + for maybe_segment_header in node_client + .segment_headers((from..to).collect()) + .await + .map_err(|error| { + anyhow!("Failed to download segment headers {from}..{to} from node: {error}") + })? + { + let Some(segment_header) = maybe_segment_header else { + // Reached non-existent segment header + break 'outer; + }; + + if segment_headers.len() == u64::from(segment_header.segment_index()) as usize { + segment_headers.push(segment_header); + } + } + + segment_index_offset += segment_index_step; + } + } + info!("Downloaded all segment headers from node successfully"); + while let Some(archived_segment_header) = archived_segments_notifications.next().await { trace!( ?archived_segment_header, @@ -461,6 +497,11 @@ where { warn!(%error, "Failed to broadcast archived segment header info"); } + + let mut segment_headers = segment_headers.write().await; + if segment_headers.len() == u64::from(archived_segment_header.segment_index()) as usize { + segment_headers.push(archived_segment_header); + } } Ok(()) @@ -535,7 +576,19 @@ async fn farmer_app_info_responder( where NC: NodeClient, { - let mut subscription = nats_client + let farmer_app_info: ::Response = + node_client + .farmer_app_info() + .await + .map_err(|error| anyhow!("Failed to get farmer app info: {error}"))?; + let last_farmer_app_info = AsyncMutex::new((farmer_app_info, Instant::now())); + + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + + let subscription = nats_client .queue_subscribe( ClusterControllerFarmerAppInfoRequest::SUBJECT, "subspace.controller".to_string(), @@ -543,25 +596,59 @@ where .await .map_err(|error| anyhow!("Failed to subscribe to farmer app info requests: {error}"))?; debug!(?subscription, "Farmer app info requests subscription"); + let mut subscription = subscription.fuse(); - let mut last_farmer_app_info: ::Response = node_client - .farmer_app_info() - .await - .map_err(|error| anyhow!("Failed to get farmer app info: {error}"))?; - let mut last_farmer_app_info_request = Instant::now(); + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; - while let Some(message) = subscription.next().await { - trace!("Farmer app info request"); + // Create background task for concurrent processing + processing.push(Box::pin(process_farmer_app_info_request( + nats_client, + node_client, + message, + &last_farmer_app_info, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } - let Some(reply_subject) = message.reply else { - continue; - }; + Ok(()) +} + +async fn process_farmer_app_info_request( + nats_client: &NatsClient, + node_client: &NC, + message: Message, + last_farmer_app_info: &AsyncMutex<(FarmerAppInfo, Instant)>, +) where + NC: NodeClient, +{ + let Some(reply_subject) = message.reply else { + return; + }; + + trace!("Farmer app info request"); + + let farmer_app_info = { + let (last_farmer_app_info, last_farmer_app_info_request) = + &mut *last_farmer_app_info.lock().await; if last_farmer_app_info_request.elapsed() > FARMER_APP_INFO_DEDUPLICATION_WINDOW { - match node_client.farmer_app_info().await { + let farmer_app_info: Result< + ::Response, + _, + > = node_client.farmer_app_info().await; + match farmer_app_info { Ok(new_last_farmer_app_info) => { - last_farmer_app_info = new_last_farmer_app_info; - last_farmer_app_info_request = Instant::now(); + *last_farmer_app_info = new_last_farmer_app_info; + *last_farmer_app_info_request = Instant::now(); } Err(error) => { warn!(%error, "Failed to get farmer app info"); @@ -569,25 +656,27 @@ where } } - if let Err(error) = nats_client - .publish(reply_subject, last_farmer_app_info.encode().into()) - .await - { - warn!(%error, "Failed to send farmer app info response"); - } - } + last_farmer_app_info.clone() + }; - Ok(()) + if let Err(error) = nats_client + .publish(reply_subject, farmer_app_info.encode().into()) + .await + { + warn!(%error, "Failed to send farmer app info response"); + } } -async fn segment_headers_responder( +async fn segment_headers_responder( nats_client: &NatsClient, - node_client: &NC, -) -> anyhow::Result<()> -where - NC: NodeClient, -{ - let mut subscription = nats_client + segment_headers: &AsyncRwLock>, +) -> anyhow::Result<()> { + // Initialize with pending future so it never ends + let mut processing = FuturesUnordered:: + Send>>>::from_iter([ + Box::pin(pending()) as Pin>, + ]); + + let subscription = nats_client .queue_subscribe( ClusterControllerSegmentHeadersRequest::SUBJECT, "subspace.controller".to_string(), @@ -595,61 +684,73 @@ where .await .map_err(|error| anyhow!("Failed to subscribe to segment headers requests: {error}"))?; debug!(?subscription, "Segment headers requests subscription"); + let mut subscription = subscription.fuse(); - let mut last_request_response = None::<( - ClusterControllerSegmentHeadersRequest, - ::Response, - )>; + loop { + select! { + maybe_message = subscription.next() => { + let Some(message) = maybe_message else { + break; + }; - while let Some(message) = subscription.next().await { - let Some(reply_subject) = message.reply else { - continue; - }; + // Create background task for concurrent processing + processing.push(Box::pin(process_segment_headers_request( + nats_client, + segment_headers, + message, + ))); + } + _ = processing.next() => { + // Nothing to do here + } + } + } + Ok(()) +} - let request = - match ClusterControllerSegmentHeadersRequest::decode(&mut message.payload.as_ref()) { - Ok(request) => request, - Err(error) => { - warn!( - %error, - message = %hex::encode(message.payload), - "Failed to decode segment headers request" - ); - continue; - } - }; - trace!(?request, "Segment headers request"); +async fn process_segment_headers_request( + nats_client: &NatsClient, + segment_headers: &AsyncRwLock>, + message: Message, +) { + let Some(reply_subject) = message.reply else { + return; + }; - let response = if let Some((last_request, response)) = &last_request_response - && last_request.segment_indices == request.segment_indices - { - response - } else { - match node_client - .segment_headers(request.segment_indices.clone()) - .await - { - Ok(segment_headers) => &last_request_response.insert((request, segment_headers)).1, - Err(error) => { - warn!( - %error, - segment_indices = ?request.segment_indices, - "Failed to get segment headers" - ); - continue; - } + let request = + match ClusterControllerSegmentHeadersRequest::decode(&mut message.payload.as_ref()) { + Ok(request) => request, + Err(error) => { + warn!( + %error, + message = %hex::encode(message.payload), + "Failed to decode segment headers request" + ); + return; } }; + trace!(?request, "Segment headers request"); + + let response: ::Response = { + let segment_headers = segment_headers.read().await; + + request + .segment_indices + .into_iter() + .map(|segment_index| { + segment_headers + .get(u64::from(segment_index) as usize) + .copied() + }) + .collect() + }; - if let Err(error) = nats_client - .publish(reply_subject, response.encode().into()) - .await - { - warn!(%error, "Failed to send farmer app info response"); - } + if let Err(error) = nats_client + .publish(reply_subject, response.encode().into()) + .await + { + warn!(%error, "Failed to send segment headers response"); } - - Ok(()) } async fn piece_responder(nats_client: &NatsClient, piece_getter: &PG) -> anyhow::Result<()> From 5e063083dc4e91888f4f2212d80f804fa353c85f Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Wed, 15 May 2024 13:00:15 +0300 Subject: [PATCH 05/15] Support lack of parent block weight --- crates/sc-consensus-subspace/src/block_import.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/crates/sc-consensus-subspace/src/block_import.rs b/crates/sc-consensus-subspace/src/block_import.rs index 9080d0759f..4b102c1f10 100644 --- a/crates/sc-consensus-subspace/src/block_import.rs +++ b/crates/sc-consensus-subspace/src/block_import.rs @@ -149,9 +149,6 @@ pub enum Error { /// Piece verification failed #[error("Piece verification failed for slot {0}")] InvalidPiece(Slot), - /// Parent block has no associated weight - #[error("Parent block of {0} has no associated weight")] - ParentBlockNoAssociatedWeight(Header::Hash), /// Block has invalid associated solution range #[error("Invalid solution range for block {0}")] InvalidSolutionRange(Header::Hash), @@ -659,7 +656,7 @@ where 0 } else { aux_schema::load_block_weight(self.client.as_ref(), block.header.parent_hash())? - .ok_or_else(|| Error::ParentBlockNoAssociatedWeight(block_hash))? + .unwrap_or_default() }; let added_weight = calculate_block_weight(subspace_digest_items.solution_range); From efe40599e06d6f37b89488fd387c9a798ef92d7f Mon Sep 17 00:00:00 2001 From: vedhavyas Date: Thu, 16 May 2024 18:30:37 +0530 Subject: [PATCH 06/15] ensure operator provides the proof of ownership of the signing key during registration to avoid front running --- crates/pallet-domains/src/benchmarking.rs | 31 ++- crates/pallet-domains/src/lib.rs | 18 +- crates/pallet-domains/src/staking.rs | 198 +++++++++--------- crates/pallet-domains/src/staking_epoch.rs | 21 +- crates/sp-domains/src/lib.rs | 8 + .../src/malicious_bundle_producer.rs | 23 +- 6 files changed, 182 insertions(+), 117 deletions(-) diff --git a/crates/pallet-domains/src/benchmarking.rs b/crates/pallet-domains/src/benchmarking.rs index 4eeca59d90..afbba0f5e8 100644 --- a/crates/pallet-domains/src/benchmarking.rs +++ b/crates/pallet-domains/src/benchmarking.rs @@ -25,10 +25,11 @@ use frame_support::traits::fungible::Mutate; use frame_support::traits::Hooks; use frame_support::weights::Weight; use frame_system::{Pallet as System, RawOrigin}; -use sp_core::crypto::UncheckedFrom; +use sp_core::crypto::{Ss58Codec, UncheckedFrom}; +use sp_core::ByteArray; use sp_domains::{ dummy_opaque_bundle, ConfirmedDomainBlock, DomainId, ExecutionReceipt, OperatorAllowList, - OperatorId, OperatorPublicKey, RuntimeType, + OperatorId, OperatorPublicKey, OperatorSignature, RuntimeType, }; use sp_domains_fraud_proof::fraud_proof::FraudProof; use sp_runtime::traits::{CheckedAdd, One, Zero}; @@ -569,8 +570,25 @@ mod benchmarks { let domain_id = register_domain::(); let operator_id = NextOperatorId::::get(); + let (key, signature) = { + let key = OperatorPublicKey::from_ss58check( + "5Gv1Uopoqo1k7125oDtFSCmxH4DzuCiBU7HBKu2bF1GZFsEb", + ) + .unwrap(); + + // signature data included operator_account since result from `account` with same + // input is always deterministic + let sig = OperatorSignature::from_slice(&[ + 88, 91, 154, 118, 137, 117, 109, 164, 232, 186, 101, 199, 94, 12, 91, 47, 228, 198, + 61, 146, 200, 227, 152, 191, 205, 114, 81, 127, 192, 158, 48, 96, 211, 199, 237, + 121, 170, 38, 118, 109, 3, 44, 198, 54, 155, 133, 240, 77, 200, 117, 107, 34, 248, + 238, 144, 101, 200, 146, 20, 94, 180, 98, 40, 134, + ]) + .unwrap(); + (key, sig) + }; let operator_config = OperatorConfig { - signing_key: OperatorPublicKey::unchecked_from([1u8; 32]), + signing_key: key, minimum_nominator_stake: T::MinNominatorStake::get(), nomination_tax: Default::default(), }; @@ -581,6 +599,7 @@ mod benchmarks { domain_id, T::MinOperatorStake::get(), operator_config.clone(), + signature, ); assert_eq!(NextOperatorId::::get(), operator_id + 1); @@ -949,13 +968,13 @@ mod benchmarks { nomination_tax: Default::default(), }; - assert_ok!(Domains::::register_operator( - RawOrigin::Signed(operator_account.clone()).into(), + assert_ok!(crate::do_register_operator::( + operator_account.clone(), domain_id, T::MinOperatorStake::get(), operator_config.clone(), + None, )); - assert_eq!( OperatorIdOwner::::get(operator_id), Some(operator_account.clone()) diff --git a/crates/pallet-domains/src/lib.rs b/crates/pallet-domains/src/lib.rs index 8f00b6fccd..f376306f35 100644 --- a/crates/pallet-domains/src/lib.rs +++ b/crates/pallet-domains/src/lib.rs @@ -37,6 +37,8 @@ extern crate alloc; use crate::block_tree::verify_execution_receipt; use crate::bundle_storage_fund::storage_fund_account; use crate::domain_registry::Error as DomainRegistryError; +#[cfg(feature = "runtime-benchmarks")] +pub use crate::staking::do_register_operator; use crate::staking::OperatorStatus; use crate::staking_epoch::EpochTransitionResult; use crate::weights::WeightInfo; @@ -208,7 +210,7 @@ mod pallet { use sp_domains::{ BundleDigest, ConfirmedDomainBlock, DomainBundleSubmitted, DomainId, DomainsTransfersTracker, EpochIndex, GenesisDomain, OperatorAllowList, OperatorId, - OperatorPublicKey, RuntimeId, RuntimeType, + OperatorPublicKey, OperatorSignature, RuntimeId, RuntimeType, }; use sp_domains_fraud_proof::fraud_proof::FraudProof; use sp_domains_fraud_proof::InvalidTransactionCode; @@ -1221,12 +1223,18 @@ mod pallet { domain_id: DomainId, amount: BalanceOf, config: OperatorConfig>, + signing_key_proof_of_ownership: OperatorSignature, ) -> DispatchResult { let owner = ensure_signed(origin)?; - let (operator_id, current_epoch_index) = - do_register_operator::(owner, domain_id, amount, config) - .map_err(Error::::from)?; + let (operator_id, current_epoch_index) = do_register_operator::( + owner, + domain_id, + amount, + config, + Some(signing_key_proof_of_ownership), + ) + .map_err(Error::::from)?; Self::deposit_event(Event::OperatorRegistered { operator_id, @@ -1486,6 +1494,8 @@ mod pallet { domain_id, operator_stake, operator_config, + // safe to not check the signing key ownership during genesis + None, ) .expect("Genesis operator registration must succeed"); diff --git a/crates/pallet-domains/src/staking.rs b/crates/pallet-domains/src/staking.rs index 3ade8c431e..d33ad94a34 100644 --- a/crates/pallet-domains/src/staking.rs +++ b/crates/pallet-domains/src/staking.rs @@ -20,9 +20,12 @@ use frame_support::traits::tokens::{Fortitude, Precision, Preservation}; use frame_support::{ensure, PalletError}; use scale_info::TypeInfo; use sp_core::{sr25519, Get}; -use sp_domains::{DomainId, EpochIndex, OperatorId, OperatorPublicKey}; +use sp_domains::{ + DomainId, EpochIndex, OperatorId, OperatorPublicKey, OperatorSignature, + OperatorSigningKeyProofOfOwnershipData, +}; use sp_runtime::traits::{CheckedAdd, CheckedSub, Zero}; -use sp_runtime::{Perbill, Percent, Perquintill, Saturating}; +use sp_runtime::{Perbill, Percent, Perquintill, RuntimeAppPublic, Saturating}; use sp_std::collections::btree_map::BTreeMap; use sp_std::collections::btree_set::BTreeSet; use sp_std::collections::vec_deque::VecDeque; @@ -293,6 +296,8 @@ pub enum Error { OperatorNotDeregistered, BundleStorageFund(bundle_storage_fund::Error), UnconfirmedER, + /// Invalid signature from Signing key owner. + InvalidSigningKeySignature, } // Increase `PendingStakingOperationCount` by one and check if the `MaxPendingStakingOperation` @@ -310,11 +315,12 @@ fn note_pending_staking_operation(domain_id: DomainId) -> Result<(), Ok(()) } -pub(crate) fn do_register_operator( +pub fn do_register_operator( operator_owner: T::AccountId, domain_id: DomainId, amount: BalanceOf, config: OperatorConfig>, + maybe_signing_key_proof_of_ownership: Option, ) -> Result<(OperatorId, EpochIndex), Error> { note_pending_staking_operation::(domain_id)?; @@ -329,6 +335,19 @@ pub(crate) fn do_register_operator( Error::DuplicateOperatorSigningKey ); + if let Some(signing_key_proof_of_ownership) = maybe_signing_key_proof_of_ownership { + let signing_key_signature_data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_owner.clone(), + }; + ensure!( + config.signing_key.verify( + &signing_key_signature_data.encode(), + &signing_key_proof_of_ownership, + ), + Error::InvalidSigningKeySignature + ); + } + ensure!( config.minimum_nominator_stake >= T::MinNominatorStake::get(), Error::MinimumNominatorStake @@ -1260,19 +1279,21 @@ pub(crate) mod tests { use crate::staking::{ do_convert_previous_epoch_withdrawal, do_nominate_operator, do_reward_operators, do_slash_operators, do_unlock_funds, do_withdraw_stake, Error as StakingError, Operator, - OperatorConfig, OperatorStatus, StakingSummary, + OperatorConfig, OperatorSigningKeyProofOfOwnershipData, OperatorStatus, StakingSummary, }; use crate::staking_epoch::do_finalize_domain_current_epoch; use crate::tests::{new_test_ext, ExistentialDeposit, RuntimeOrigin, Test}; use crate::{bundle_storage_fund, BalanceOf, Error, NominatorId, SlashedReason}; + use codec::Encode; use frame_support::traits::fungible::Mutate; use frame_support::traits::Currency; use frame_support::weights::Weight; use frame_support::{assert_err, assert_ok}; + use sp_core::crypto::UncheckedFrom; use sp_core::{sr25519, Pair, U256}; use sp_domains::{ ConfirmedDomainBlock, DomainId, OperatorAllowList, OperatorId, OperatorPair, - OperatorPublicKey, + OperatorPublicKey, OperatorSignature, }; use sp_runtime::traits::Zero; use sp_runtime::{PerThing, Perbill}; @@ -1285,6 +1306,7 @@ pub(crate) mod tests { const STORAGE_FEE_RESERVE: Perbill = Perbill::from_percent(20); + #[allow(clippy::too_many_arguments)] pub(crate) fn register_operator( domain_id: DomainId, operator_account: ::AccountId, @@ -1292,6 +1314,7 @@ pub(crate) mod tests { operator_stake: BalanceOf, minimum_nominator_stake: BalanceOf, signing_key: OperatorPublicKey, + signature: OperatorSignature, mut nominators: BTreeMap, (BalanceOf, BalanceOf)>, ) -> (OperatorId, OperatorConfig>) { nominators.insert(operator_account, (operator_free_balance, operator_stake)); @@ -1348,6 +1371,7 @@ pub(crate) mod tests { domain_id, operator_stake, operator_config.clone(), + signature, ); assert_ok!(res); @@ -1391,6 +1415,7 @@ pub(crate) mod tests { domain_id, Default::default(), operator_config, + OperatorSignature::unchecked_from([1u8; 64]), ); assert_err!( res, @@ -1413,11 +1438,17 @@ pub(crate) mod tests { nomination_tax: Default::default(), }; + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); + let res = Domains::register_operator( RuntimeOrigin::signed(operator_account), domain_id, Default::default(), operator_config, + signature, ); assert_err!( res, @@ -1438,6 +1469,10 @@ pub(crate) mod tests { let mut ext = new_test_ext(); ext.execute_with(|| { + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let (operator_id, mut operator_config) = register_operator( domain_id, operator_account, @@ -1445,6 +1480,7 @@ pub(crate) mod tests { operator_total_stake, SSC, pair.public(), + signature.clone(), BTreeMap::new(), ); @@ -1487,6 +1523,7 @@ pub(crate) mod tests { domain_id, operator_stake, operator_config.clone(), + signature.clone(), ); assert_err!( res, @@ -1496,11 +1533,16 @@ pub(crate) mod tests { // cannot use the locked funds to register a new operator let new_pair = OperatorPair::from_seed(&U256::from(1u32).into()); operator_config.signing_key = new_pair.public(); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = new_pair.sign(&data.encode()); let res = Domains::register_operator( RuntimeOrigin::signed(operator_account), domain_id, operator_stake, operator_config, + signature, ); assert_err!( res, @@ -1521,6 +1563,10 @@ pub(crate) mod tests { let operator_stake = 800 * SSC; let operator_storage_fee_deposit = 200 * SSC; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let nominator_account = 2; let nominator_free_balance = 150 * SSC; @@ -1537,6 +1583,7 @@ pub(crate) mod tests { operator_total_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(vec![( nominator_account, (nominator_free_balance, nominator_total_stake), @@ -1634,7 +1681,10 @@ pub(crate) mod tests { let operator_free_balance = 1500 * SSC; let operator_stake = 1000 * SSC; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let nominator_account = 7; let nominator_free_balance = 150 * SSC; let nominator_stake = 100 * SSC; @@ -1648,6 +1698,7 @@ pub(crate) mod tests { operator_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(vec![ (1, (nominator_free_balance, nominator_stake)), (2, (nominator_free_balance, nominator_stake)), @@ -1676,100 +1727,6 @@ pub(crate) mod tests { }); } - // TODO: `switch_domain` is not supported currently due to incompatible with lazily slashing - // enable this test when `switch_domain` is ready - // #[test] - // fn switch_domain_operator() { - // let old_domain_id = DomainId::new(0); - // let new_domain_id = DomainId::new(1); - // let operator_account = 1; - // let operator_free_balance = 250 * SSC; - // let operator_stake = 200 * SSC; - // let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - - // let mut ext = new_test_ext(); - // ext.execute_with(|| { - // let (operator_id, _) = register_operator( - // old_domain_id, - // operator_account, - // operator_free_balance, - // operator_stake, - // SSC, - // pair.public(), - // BTreeMap::new(), - // ); - - // let domain_config = DomainConfig { - // domain_name: String::from_utf8(vec![0; 1024]).unwrap(), - // runtime_id: 0, - // max_block_size: u32::MAX, - // max_block_weight: Weight::MAX, - // bundle_slot_probability: (0, 0), - // target_bundles_per_block: 0, - // operator_allow_list: OperatorAllowList::Anyone, - // initial_balances: Default::default(), - // }; - - // let domain_obj = DomainObject { - // owner_account_id: 0, - // created_at: 0, - // genesis_receipt_hash: Default::default(), - // domain_config, - // domain_runtime_info: Default::default(), - // }; - - // DomainRegistry::::insert(new_domain_id, domain_obj); - - // DomainStakingSummary::::insert( - // new_domain_id, - // StakingSummary { - // current_epoch_index: 0, - // current_total_stake: 0, - // current_operators: BTreeMap::new(), - // next_operators: BTreeSet::new(), - // current_epoch_rewards: BTreeMap::new(), - // }, - // ); - - // let res = Domains::switch_domain( - // RuntimeOrigin::signed(operator_account), - // operator_id, - // new_domain_id, - // ); - // assert_ok!(res); - - // let old_domain_stake_summary = - // DomainStakingSummary::::get(old_domain_id).unwrap(); - // assert!(!old_domain_stake_summary - // .next_operators - // .contains(&operator_id)); - - // let new_domain_stake_summary = - // DomainStakingSummary::::get(new_domain_id).unwrap(); - // assert!(!new_domain_stake_summary - // .next_operators - // .contains(&operator_id)); - - // let operator = Operators::::get(operator_id).unwrap(); - // assert_eq!(operator.current_domain_id, old_domain_id); - // assert_eq!(operator.next_domain_id, new_domain_id); - // assert_eq!( - // PendingOperatorSwitches::::get(old_domain_id).unwrap(), - // BTreeSet::from_iter(vec![operator_id]) - // ); - - // let res = Domains::switch_domain( - // RuntimeOrigin::signed(operator_account), - // operator_id, - // new_domain_id, - // ); - // assert_err!( - // res, - // Error::::Staking(crate::staking::Error::PendingOperatorSwitch) - // ) - // }); - // } - #[test] fn operator_deregistration() { let domain_id = DomainId::new(0); @@ -1777,7 +1734,10 @@ pub(crate) mod tests { let operator_stake = 200 * SSC; let operator_free_balance = 250 * SSC; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let mut ext = new_test_ext(); ext.execute_with(|| { let (operator_id, _) = register_operator( @@ -1787,6 +1747,7 @@ pub(crate) mod tests { operator_stake, SSC, pair.public(), + signature, BTreeMap::new(), ); @@ -1898,7 +1859,10 @@ pub(crate) mod tests { let domain_id = DomainId::new(0); let operator_account = 0; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let mut total_balance = nominators.iter().map(|n| n.1).sum::>() + operator_reward + maybe_deposit.unwrap_or(0); @@ -1921,6 +1885,7 @@ pub(crate) mod tests { operator_stake, minimum_nominator_stake, pair.public(), + signature, nominators, ); @@ -2552,7 +2517,10 @@ pub(crate) mod tests { let operator_stake = 200 * SSC; let operator_extra_deposit = 40 * SSC; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let nominator_account = 2; let nominator_free_balance = 150 * SSC; let nominator_stake = 100 * SSC; @@ -2582,6 +2550,7 @@ pub(crate) mod tests { operator_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(nominators), ); @@ -2700,6 +2669,21 @@ pub(crate) mod tests { let pair_2 = OperatorPair::from_seed(&U256::from(1u32).into()); let pair_3 = OperatorPair::from_seed(&U256::from(2u32).into()); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account_1, + }; + let signature_1 = pair_1.sign(&data.encode()); + + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account_2, + }; + let signature_2 = pair_2.sign(&data.encode()); + + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account_3, + }; + let signature_3 = pair_3.sign(&data.encode()); + let mut ext = new_test_ext(); ext.execute_with(|| { let (operator_id_1, _) = register_operator( @@ -2709,6 +2693,7 @@ pub(crate) mod tests { operator_stake, 10 * SSC, pair_1.public(), + signature_1, Default::default(), ); @@ -2719,6 +2704,7 @@ pub(crate) mod tests { operator_stake, 10 * SSC, pair_2.public(), + signature_2, Default::default(), ); @@ -2729,6 +2715,7 @@ pub(crate) mod tests { operator_stake, 10 * SSC, pair_3.public(), + signature_3, Default::default(), ); @@ -2816,6 +2803,10 @@ pub(crate) mod tests { let operator_stake = 80 * SSC; let operator_storage_fee_deposit = 20 * SSC; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let nominator_account = 2; let mut ext = new_test_ext(); @@ -2827,6 +2818,7 @@ pub(crate) mod tests { operator_total_stake, SSC, pair.public(), + signature, BTreeMap::default(), ); diff --git a/crates/pallet-domains/src/staking_epoch.rs b/crates/pallet-domains/src/staking_epoch.rs index 8a3557a87b..1d0718cc53 100644 --- a/crates/pallet-domains/src/staking_epoch.rs +++ b/crates/pallet-domains/src/staking_epoch.rs @@ -560,10 +560,13 @@ mod tests { }; use crate::tests::{new_test_ext, Test}; use crate::{BalanceOf, Config, HoldIdentifier, NominatorId}; + use codec::Encode; use frame_support::assert_ok; use frame_support::traits::fungible::InspectHold; use sp_core::{Pair, U256}; - use sp_domains::{ConfirmedDomainBlock, DomainId, OperatorPair}; + use sp_domains::{ + ConfirmedDomainBlock, DomainId, OperatorPair, OperatorSigningKeyProofOfOwnershipData, + }; use sp_runtime::traits::Zero; use sp_runtime::{PerThing, Percent}; use std::collections::BTreeMap; @@ -654,6 +657,10 @@ mod tests { let domain_id = DomainId::new(0); let operator_account = 1; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let minimum_free_balance = 10 * SSC; let mut nominators = BTreeMap::from_iter( nominators @@ -682,6 +689,7 @@ mod tests { operator_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(nominators.clone()), ); @@ -795,7 +803,10 @@ mod tests { let domain_id = DomainId::new(0); let operator_account = 0; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); - + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let FinalizeDomainParams { total_deposit, rewards, @@ -829,6 +840,7 @@ mod tests { operator_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(nominators), ); @@ -902,6 +914,10 @@ mod tests { let domain_id = DomainId::new(0); let operator_account = 1; let pair = OperatorPair::from_seed(&U256::from(0u32).into()); + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: operator_account, + }; + let signature = pair.sign(&data.encode()); let operator_rewards = 10 * SSC; let mut nominators = BTreeMap::from_iter(vec![(1, (110 * SSC, 100 * SSC)), (2, (60 * SSC, 50 * SSC))]); @@ -917,6 +933,7 @@ mod tests { operator_stake, 10 * SSC, pair.public(), + signature, BTreeMap::from_iter(nominators), ); diff --git a/crates/sp-domains/src/lib.rs b/crates/sp-domains/src/lib.rs index 7aec659dcb..7735ebd493 100644 --- a/crates/sp-domains/src/lib.rs +++ b/crates/sp-domains/src/lib.rs @@ -1271,6 +1271,14 @@ pub fn operator_block_fees_final_key() -> Vec { .to_vec() } +/// Preimage to verify the proof of ownership of Operator Signing key. +/// Operator owner is used to ensure the signature is used by anyone except +/// the owner of the Signing key pair. +#[derive(Debug, Encode)] +pub struct OperatorSigningKeyProofOfOwnershipData { + pub operator_owner: AccountId, +} + sp_api::decl_runtime_apis! { /// API necessary for domains pallet. #[api_version(3)] diff --git a/crates/subspace-malicious-operator/src/malicious_bundle_producer.rs b/crates/subspace-malicious-operator/src/malicious_bundle_producer.rs index b0f7a219dc..643620824e 100644 --- a/crates/subspace-malicious-operator/src/malicious_bundle_producer.rs +++ b/crates/subspace-malicious-operator/src/malicious_bundle_producer.rs @@ -20,9 +20,12 @@ use sp_consensus_subspace::FarmerPublicKey; use sp_core::crypto::UncheckedFrom; use sp_core::Get; use sp_domains::core_api::DomainCoreApi; -use sp_domains::{BundleProducerElectionApi, DomainId, DomainsApi, OperatorId, OperatorPublicKey}; +use sp_domains::{ + BundleProducerElectionApi, DomainId, DomainsApi, OperatorId, OperatorPublicKey, + OperatorSignature, OperatorSigningKeyProofOfOwnershipData, +}; use sp_keyring::Sr25519Keyring; -use sp_keystore::KeystorePtr; +use sp_keystore::{Keystore, KeystorePtr}; use sp_runtime::traits::Block as BlockT; use sp_runtime::{generic, RuntimeAppPublic}; use sp_transaction_pool::runtime_api::TaggedTransactionQueue; @@ -268,6 +271,19 @@ where } }; + let data = OperatorSigningKeyProofOfOwnershipData { + operator_owner: self.sudo_account.clone(), + }; + let signature = OperatorSignature::from( + self.operator_keystore + .sr25519_sign( + OperatorPublicKey::ID, + signing_key.clone().as_ref(), + &data.encode(), + )? + .expect("key pair must be avaible on keystore for signing"), + ); + let maybe_operator_id = self .consensus_client .runtime_api() @@ -282,6 +298,7 @@ where self.submit_register_operator( nonce, signing_key, + signature, // Ideally we should use the `next_total_stake` but it is tricky to get MALICIOUS_OPR_STAKE_MULTIPLIER * current_total_stake, )?; @@ -329,6 +346,7 @@ where &self, nonce: Nonce, signing_key: OperatorPublicKey, + signature: OperatorSignature, staking_amount: Balance, ) -> Result<(), Box> { let call = pallet_domains::Call::register_operator { @@ -339,6 +357,7 @@ where minimum_nominator_stake: Balance::MAX, nomination_tax: Default::default(), }, + signing_key_proof_of_ownership: signature, }; self.submit_consensus_extrinsic(Some(nonce), call.into()) } From 116fa6815c98396a0009ecbb97dae51827948f13 Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Thu, 16 May 2024 18:18:25 +0300 Subject: [PATCH 07/15] Log details in case solution response sending resulted in failure --- crates/subspace-farmer/src/cluster/controller.rs | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/crates/subspace-farmer/src/cluster/controller.rs b/crates/subspace-farmer/src/cluster/controller.rs index 1e347c6249..b08095b376 100644 --- a/crates/subspace-farmer/src/cluster/controller.rs +++ b/crates/subspace-farmer/src/cluster/controller.rs @@ -526,11 +526,21 @@ where while let Some(notification) = subscription.next().await { debug!(?notification, "Solution notification"); + let slot = notification.solution_response.slot_number; + let public_key = notification.solution_response.solution.public_key; + let sector_index = notification.solution_response.solution.sector_index; + if let Err(error) = node_client .submit_solution_response(notification.solution_response) .await { - warn!(%error, "Failed to send solution response"); + warn!( + %error, + %slot, + %public_key, + %sector_index, + "Failed to send solution response" + ); } } From bd36f82770a46320ee765c6bb9b822bee1968b48 Mon Sep 17 00:00:00 2001 From: qy3u Date: Thu, 16 May 2024 15:04:36 +0800 Subject: [PATCH 08/15] refactor: num_matches to has_match --- crates/subspace-proof-of-space/src/chiapos/table.rs | 9 ++++----- crates/subspace-proof-of-space/src/chiapos/tables.rs | 8 +++----- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/crates/subspace-proof-of-space/src/chiapos/table.rs b/crates/subspace-proof-of-space/src/chiapos/table.rs index 4ecec6b6aa..93362c80de 100644 --- a/crates/subspace-proof-of-space/src/chiapos/table.rs +++ b/crates/subspace-proof-of-space/src/chiapos/table.rs @@ -259,7 +259,7 @@ pub(super) fn compute_f1_simd( /// `rmap_scratch` is just an optimization to reuse allocations between calls. /// -/// For verification purposes use [`num_matches`] instead. +/// For verification purposes use [`has_match`] instead. /// /// Returns `None` if either of buckets is empty. fn find_matches<'a>( @@ -326,20 +326,19 @@ fn find_matches<'a>( } /// Simplified version of [`find_matches`] for verification purposes. -pub(super) fn num_matches(left_y: Y, right_y: Y) -> usize { +pub(super) fn has_match(left_y: Y, right_y: Y) -> bool { let right_r = usize::from(right_y) % usize::from(PARAM_BC); let parity = (usize::from(left_y) / usize::from(PARAM_BC)) % 2; let left_r = usize::from(left_y) % usize::from(PARAM_BC); - let mut matches = 0; for m in 0..usize::from(PARAM_M) { let r_target = calculate_left_target_on_demand(parity, left_r, m); if r_target == right_r { - matches += 1; + return true; } } - matches + false } pub(super) fn compute_fn( diff --git a/crates/subspace-proof-of-space/src/chiapos/tables.rs b/crates/subspace-proof-of-space/src/chiapos/tables.rs index b38a52cb72..2980ca985f 100644 --- a/crates/subspace-proof-of-space/src/chiapos/tables.rs +++ b/crates/subspace-proof-of-space/src/chiapos/tables.rs @@ -7,7 +7,7 @@ extern crate alloc; use crate::chiapos::table::types::{Metadata, Position, X, Y}; pub use crate::chiapos::table::TablesCache; use crate::chiapos::table::{ - compute_f1, compute_fn, metadata_size_bytes, num_matches, partial_y, Table, + compute_f1, compute_fn, has_match, metadata_size_bytes, partial_y, Table, COMPUTE_F1_SIMD_FACTOR, }; use crate::chiapos::utils::EvaluatableUsize; @@ -375,14 +375,12 @@ where ys_and_metadata .array_chunks::<2>() .map(|&[(left_y, left_metadata), (right_y, right_metadata)]| { - (num_matches(left_y, right_y) == 1).then_some(compute_fn::< + has_match(left_y, right_y).then_some(compute_fn::< K, TABLE_NUMBER, PARENT_TABLE_NUMBER, >( - left_y, - left_metadata, - right_metadata, + left_y, left_metadata, right_metadata )) }) .collect() From 3a08af8ac61f6eafb9f438c6747f9086adf7dcca Mon Sep 17 00:00:00 2001 From: dastansam Date: Fri, 17 May 2024 16:52:30 +0200 Subject: [PATCH 09/15] Bump polkadot-sdk and frontier deps --- Cargo.lock | 276 +++++++++--------- Cargo.toml | 78 ++--- crates/pallet-domains/Cargo.toml | 28 +- crates/pallet-feeds/Cargo.toml | 10 +- .../Cargo.toml | 16 +- crates/pallet-object-store/Cargo.toml | 10 +- crates/pallet-offences-subspace/Cargo.toml | 12 +- crates/pallet-rewards/Cargo.toml | 14 +- crates/pallet-runtime-configs/Cargo.toml | 12 +- crates/pallet-subspace-mmr/Cargo.toml | 12 +- crates/pallet-subspace/Cargo.toml | 20 +- crates/pallet-transaction-fees/Cargo.toml | 4 +- crates/sc-consensus-subspace-rpc/Cargo.toml | 18 +- crates/sc-consensus-subspace/Cargo.toml | 28 +- crates/sc-domains/Cargo.toml | 18 +- crates/sc-proof-of-time/Cargo.toml | 20 +- crates/sc-subspace-block-relay/Cargo.toml | 16 +- crates/sp-consensus-subspace/Cargo.toml | 22 +- crates/sp-domains-fraud-proof/Cargo.toml | 46 +-- crates/sp-domains/Cargo.toml | 22 +- crates/sp-lightclient/Cargo.toml | 12 +- crates/sp-objects/Cargo.toml | 2 +- crates/sp-subspace-mmr/Cargo.toml | 14 +- crates/subspace-fake-runtime-api/Cargo.toml | 32 +- crates/subspace-malicious-operator/Cargo.toml | 52 ++-- crates/subspace-node/Cargo.toml | 48 +-- crates/subspace-runtime-primitives/Cargo.toml | 12 +- crates/subspace-runtime/Cargo.toml | 56 ++-- crates/subspace-service/Cargo.toml | 80 ++--- domains/client/block-builder/Cargo.toml | 16 +- domains/client/block-preprocessor/Cargo.toml | 28 +- .../client/consensus-relay-chain/Cargo.toml | 12 +- .../cross-domain-message-gossip/Cargo.toml | 14 +- domains/client/domain-operator/Cargo.toml | 54 ++-- domains/client/eth-service/Cargo.toml | 42 +-- domains/client/relayer/Cargo.toml | 18 +- domains/pallets/auto-id/Cargo.toml | 10 +- domains/pallets/block-fees/Cargo.toml | 10 +- domains/pallets/domain-id/Cargo.toml | 10 +- domains/pallets/evm_nonce_tracker/Cargo.toml | 8 +- domains/pallets/executive/Cargo.toml | 24 +- domains/pallets/messenger/Cargo.toml | 18 +- domains/pallets/transporter/Cargo.toml | 16 +- domains/primitives/auto-id/Cargo.toml | 6 +- domains/primitives/block-fees/Cargo.toml | 4 +- domains/primitives/digests/Cargo.toml | 2 +- domains/primitives/executive/Cargo.toml | 2 +- .../messenger-host-functions/Cargo.toml | 14 +- domains/primitives/messenger/Cargo.toml | 14 +- domains/primitives/runtime/Cargo.toml | 14 +- domains/runtime/auto-id/Cargo.toml | 48 +-- domains/runtime/evm/Cargo.toml | 68 ++--- domains/service/Cargo.toml | 68 ++--- domains/test/primitives/Cargo.toml | 2 +- domains/test/runtime/evm/Cargo.toml | 62 ++-- domains/test/service/Cargo.toml | 50 ++-- orml/vesting/Cargo.toml | 14 +- test/subspace-test-client/Cargo.toml | 14 +- test/subspace-test-primitives/Cargo.toml | 6 +- test/subspace-test-runtime/Cargo.toml | 50 ++-- test/subspace-test-service/Cargo.toml | 58 ++-- 61 files changed, 883 insertions(+), 883 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9479a607be..38b2065796 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3548,7 +3548,7 @@ checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" [[package]] name = "fc-api" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "async-trait", "fp-storage", @@ -3560,7 +3560,7 @@ dependencies = [ [[package]] name = "fc-consensus" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "async-trait", "fp-consensus", @@ -3576,7 +3576,7 @@ dependencies = [ [[package]] name = "fc-db" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "async-trait", "fc-api", @@ -3595,7 +3595,7 @@ dependencies = [ [[package]] name = "fc-mapping-sync" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "fc-db", "fc-storage", @@ -3616,7 +3616,7 @@ dependencies = [ [[package]] name = "fc-rpc" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -3671,7 +3671,7 @@ dependencies = [ [[package]] name = "fc-rpc-core" version = "1.1.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -3686,7 +3686,7 @@ dependencies = [ [[package]] name = "fc-storage" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -3825,7 +3825,7 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" [[package]] name = "fork-tree" version = "12.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", ] @@ -3842,7 +3842,7 @@ dependencies = [ [[package]] name = "fp-account" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "hex", "impl-serde", @@ -3861,7 +3861,7 @@ dependencies = [ [[package]] name = "fp-consensus" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "parity-scale-codec", @@ -3873,7 +3873,7 @@ dependencies = [ [[package]] name = "fp-ethereum" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -3886,7 +3886,7 @@ dependencies = [ [[package]] name = "fp-evm" version = "3.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "evm", "frame-support", @@ -3902,7 +3902,7 @@ dependencies = [ [[package]] name = "fp-rpc" version = "3.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -3919,7 +3919,7 @@ dependencies = [ [[package]] name = "fp-self-contained" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "frame-support", "parity-scale-codec", @@ -3931,7 +3931,7 @@ dependencies = [ [[package]] name = "fp-storage" version = "2.0.0" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "parity-scale-codec", "serde", @@ -3946,7 +3946,7 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa" [[package]] name = "frame-benchmarking" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-support", "frame-support-procedural", @@ -3971,7 +3971,7 @@ dependencies = [ [[package]] name = "frame-benchmarking-cli" version = "32.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "Inflector", "array-bytes 6.2.2", @@ -4019,7 +4019,7 @@ dependencies = [ [[package]] name = "frame-executive" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "aquamarine 0.3.3", "frame-support", @@ -4050,7 +4050,7 @@ dependencies = [ [[package]] name = "frame-support" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "aquamarine 0.5.0", "array-bytes 6.2.2", @@ -4091,7 +4091,7 @@ dependencies = [ [[package]] name = "frame-support-procedural" version = "23.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "Inflector", "cfg-expr", @@ -4110,7 +4110,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools" version = "10.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-support-procedural-tools-derive", "proc-macro-crate 3.1.0", @@ -4122,7 +4122,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools-derive" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "proc-macro2", "quote", @@ -4132,7 +4132,7 @@ dependencies = [ [[package]] name = "frame-system" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "cfg-if", "docify", @@ -4152,7 +4152,7 @@ dependencies = [ [[package]] name = "frame-system-benchmarking" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-benchmarking", "frame-support", @@ -4167,7 +4167,7 @@ dependencies = [ [[package]] name = "frame-system-rpc-runtime-api" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "sp-api", @@ -4176,7 +4176,7 @@ dependencies = [ [[package]] name = "frame-try-runtime" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-support", "parity-scale-codec", @@ -6883,7 +6883,7 @@ dependencies = [ [[package]] name = "mmr-gadget" version = "29.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "futures", "log", @@ -6902,7 +6902,7 @@ dependencies = [ [[package]] name = "mmr-rpc" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -7493,7 +7493,7 @@ dependencies = [ [[package]] name = "pallet-balances" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "docify", "frame-benchmarking", @@ -7509,7 +7509,7 @@ dependencies = [ [[package]] name = "pallet-base-fee" version = "1.0.0" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "fp-evm", "frame-support", @@ -7585,7 +7585,7 @@ dependencies = [ [[package]] name = "pallet-ethereum" version = "4.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "ethereum", "ethereum-types", @@ -7608,7 +7608,7 @@ dependencies = [ [[package]] name = "pallet-evm" version = "6.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "environmental", "evm", @@ -7634,7 +7634,7 @@ dependencies = [ [[package]] name = "pallet-evm-chain-id" version = "1.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "frame-support", "frame-system", @@ -7657,7 +7657,7 @@ dependencies = [ [[package]] name = "pallet-evm-precompile-modexp" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "fp-evm", "num", @@ -7666,7 +7666,7 @@ dependencies = [ [[package]] name = "pallet-evm-precompile-sha3fips" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "fp-evm", "tiny-keccak", @@ -7675,7 +7675,7 @@ dependencies = [ [[package]] name = "pallet-evm-precompile-simple" version = "2.0.0-dev" -source = "git+https://github.com/subspace/frontier?rev=f1039d3b588b2524a3fc29726435077f5c87ce92#f1039d3b588b2524a3fc29726435077f5c87ce92" +source = "git+https://github.com/subspace/frontier?rev=0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641#0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" dependencies = [ "fp-evm", "ripemd", @@ -7743,7 +7743,7 @@ dependencies = [ [[package]] name = "pallet-mmr" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-benchmarking", "frame-support", @@ -7872,7 +7872,7 @@ dependencies = [ [[package]] name = "pallet-sudo" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "docify", "frame-benchmarking", @@ -7888,7 +7888,7 @@ dependencies = [ [[package]] name = "pallet-timestamp" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "docify", "frame-benchmarking", @@ -7919,7 +7919,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-support", "frame-system", @@ -7935,7 +7935,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc" version = "30.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "jsonrpsee", "pallet-transaction-payment-rpc-runtime-api", @@ -7951,7 +7951,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc-runtime-api" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "pallet-transaction-payment", "parity-scale-codec", @@ -7982,7 +7982,7 @@ dependencies = [ [[package]] name = "pallet-utility" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-benchmarking", "frame-support", @@ -9580,7 +9580,7 @@ dependencies = [ [[package]] name = "sc-allocator" version = "23.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "log", "sp-core", @@ -9591,7 +9591,7 @@ dependencies = [ [[package]] name = "sc-basic-authorship" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "futures", "futures-timer", @@ -9613,7 +9613,7 @@ dependencies = [ [[package]] name = "sc-block-builder" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "sp-api", @@ -9628,7 +9628,7 @@ dependencies = [ [[package]] name = "sc-chain-spec" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "docify", @@ -9654,7 +9654,7 @@ dependencies = [ [[package]] name = "sc-chain-spec-derive" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -9665,7 +9665,7 @@ dependencies = [ [[package]] name = "sc-cli" version = "0.36.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "chrono", @@ -9706,7 +9706,7 @@ dependencies = [ [[package]] name = "sc-client-api" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "fnv", "futures", @@ -9733,7 +9733,7 @@ dependencies = [ [[package]] name = "sc-client-db" version = "0.35.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "hash-db", "kvdb", @@ -9758,7 +9758,7 @@ dependencies = [ [[package]] name = "sc-consensus" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-lock 3.3.0", "async-trait", @@ -9785,7 +9785,7 @@ dependencies = [ [[package]] name = "sc-consensus-aura" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "futures", @@ -9814,7 +9814,7 @@ dependencies = [ [[package]] name = "sc-consensus-slots" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "futures", @@ -9928,7 +9928,7 @@ dependencies = [ [[package]] name = "sc-executor" version = "0.32.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "parking_lot 0.12.2", @@ -9951,7 +9951,7 @@ dependencies = [ [[package]] name = "sc-executor-common" version = "0.29.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "polkavm", "sc-allocator", @@ -9964,7 +9964,7 @@ dependencies = [ [[package]] name = "sc-executor-polkavm" version = "0.29.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "log", "polkavm", @@ -9975,7 +9975,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmtime" version = "0.29.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "anyhow", "cfg-if", @@ -9993,7 +9993,7 @@ dependencies = [ [[package]] name = "sc-informant" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ansi_term", "futures", @@ -10010,7 +10010,7 @@ dependencies = [ [[package]] name = "sc-keystore" version = "25.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "parking_lot 0.12.2", @@ -10024,7 +10024,7 @@ dependencies = [ [[package]] name = "sc-mixnet" version = "0.4.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 4.2.0", "arrayvec", @@ -10053,7 +10053,7 @@ dependencies = [ [[package]] name = "sc-network" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "async-channel 1.9.0", @@ -10096,7 +10096,7 @@ dependencies = [ [[package]] name = "sc-network-bitswap" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-channel 1.9.0", "cid", @@ -10116,7 +10116,7 @@ dependencies = [ [[package]] name = "sc-network-common" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "bitflags 1.3.2", @@ -10133,7 +10133,7 @@ dependencies = [ [[package]] name = "sc-network-gossip" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ahash 0.8.11", "futures", @@ -10152,7 +10152,7 @@ dependencies = [ [[package]] name = "sc-network-light" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "async-channel 1.9.0", @@ -10173,7 +10173,7 @@ dependencies = [ [[package]] name = "sc-network-sync" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "async-channel 1.9.0", @@ -10209,7 +10209,7 @@ dependencies = [ [[package]] name = "sc-network-transactions" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "futures", @@ -10228,7 +10228,7 @@ dependencies = [ [[package]] name = "sc-offchain" version = "29.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "bytes", @@ -10292,7 +10292,7 @@ dependencies = [ [[package]] name = "sc-proposer-metrics" version = "0.17.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "log", "substrate-prometheus-endpoint", @@ -10301,7 +10301,7 @@ dependencies = [ [[package]] name = "sc-rpc" version = "29.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "futures", "jsonrpsee", @@ -10333,7 +10333,7 @@ dependencies = [ [[package]] name = "sc-rpc-api" version = "0.33.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -10353,7 +10353,7 @@ dependencies = [ [[package]] name = "sc-rpc-server" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "futures", "governor", @@ -10371,7 +10371,7 @@ dependencies = [ [[package]] name = "sc-rpc-spec-v2" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "futures", @@ -10402,7 +10402,7 @@ dependencies = [ [[package]] name = "sc-service" version = "0.35.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "directories", @@ -10466,7 +10466,7 @@ dependencies = [ [[package]] name = "sc-state-db" version = "0.30.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "log", "parity-scale-codec", @@ -10477,7 +10477,7 @@ dependencies = [ [[package]] name = "sc-storage-monitor" version = "0.16.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "clap", "fs4 0.7.0", @@ -10518,7 +10518,7 @@ version = "0.1.0" [[package]] name = "sc-sysinfo" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "derive_more", "futures", @@ -10539,7 +10539,7 @@ dependencies = [ [[package]] name = "sc-telemetry" version = "15.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "chrono", "futures", @@ -10558,7 +10558,7 @@ dependencies = [ [[package]] name = "sc-tracing" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ansi_term", "chrono", @@ -10588,7 +10588,7 @@ dependencies = [ [[package]] name = "sc-tracing-proc-macro" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "proc-macro-crate 3.1.0", "proc-macro2", @@ -10599,7 +10599,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "futures", @@ -10626,7 +10626,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool-api" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "futures", @@ -10642,7 +10642,7 @@ dependencies = [ [[package]] name = "sc-utils" version = "14.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-channel 1.9.0", "futures", @@ -11166,7 +11166,7 @@ dependencies = [ [[package]] name = "sp-api" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "hash-db", "log", @@ -11188,7 +11188,7 @@ dependencies = [ [[package]] name = "sp-api-proc-macro" version = "15.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "Inflector", "blake2 0.10.6", @@ -11202,7 +11202,7 @@ dependencies = [ [[package]] name = "sp-application-crypto" version = "30.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "scale-info", @@ -11215,7 +11215,7 @@ dependencies = [ [[package]] name = "sp-arithmetic" version = "23.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "docify", "integer-sqrt", @@ -11261,7 +11261,7 @@ dependencies = [ [[package]] name = "sp-block-builder" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "sp-api", "sp-inherents", @@ -11282,7 +11282,7 @@ dependencies = [ [[package]] name = "sp-blockchain" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "futures", "log", @@ -11300,7 +11300,7 @@ dependencies = [ [[package]] name = "sp-consensus" version = "0.32.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "futures", @@ -11315,7 +11315,7 @@ dependencies = [ [[package]] name = "sp-consensus-aura" version = "0.32.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "parity-scale-codec", @@ -11331,7 +11331,7 @@ dependencies = [ [[package]] name = "sp-consensus-beefy" version = "13.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "lazy_static", "parity-scale-codec", @@ -11351,7 +11351,7 @@ dependencies = [ [[package]] name = "sp-consensus-grandpa" version = "13.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "finality-grandpa", "log", @@ -11368,7 +11368,7 @@ dependencies = [ [[package]] name = "sp-consensus-slots" version = "0.32.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "scale-info", @@ -11405,7 +11405,7 @@ dependencies = [ [[package]] name = "sp-core" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "bandersnatch_vrfs", @@ -11452,7 +11452,7 @@ dependencies = [ [[package]] name = "sp-crypto-ec-utils" version = "0.10.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ark-bls12-377", "ark-bls12-377-ext", @@ -11472,7 +11472,7 @@ dependencies = [ [[package]] name = "sp-crypto-hashing" version = "0.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "blake2b_simd", "byteorder", @@ -11485,7 +11485,7 @@ dependencies = [ [[package]] name = "sp-crypto-hashing-proc-macro" version = "0.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "quote", "sp-crypto-hashing", @@ -11495,7 +11495,7 @@ dependencies = [ [[package]] name = "sp-database" version = "10.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "kvdb", "parking_lot 0.12.2", @@ -11504,7 +11504,7 @@ dependencies = [ [[package]] name = "sp-debug-derive" version = "14.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "proc-macro2", "quote", @@ -11615,7 +11615,7 @@ dependencies = [ [[package]] name = "sp-externalities" version = "0.25.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "environmental", "parity-scale-codec", @@ -11625,7 +11625,7 @@ dependencies = [ [[package]] name = "sp-genesis-builder" version = "0.7.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "serde_json", "sp-api", @@ -11635,7 +11635,7 @@ dependencies = [ [[package]] name = "sp-inherents" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "impl-trait-for-tuples", @@ -11648,7 +11648,7 @@ dependencies = [ [[package]] name = "sp-io" version = "30.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "bytes", "ed25519-dalek", @@ -11674,7 +11674,7 @@ dependencies = [ [[package]] name = "sp-keyring" version = "31.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "sp-core", "sp-runtime", @@ -11684,7 +11684,7 @@ dependencies = [ [[package]] name = "sp-keystore" version = "0.34.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "parking_lot 0.12.2", @@ -11695,7 +11695,7 @@ dependencies = [ [[package]] name = "sp-maybe-compressed-blob" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "thiserror", "zstd 0.12.4", @@ -11743,7 +11743,7 @@ dependencies = [ [[package]] name = "sp-metadata-ir" version = "0.6.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-metadata", "parity-scale-codec", @@ -11753,7 +11753,7 @@ dependencies = [ [[package]] name = "sp-mixnet" version = "0.4.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "scale-info", @@ -11764,7 +11764,7 @@ dependencies = [ [[package]] name = "sp-mmr-primitives" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ckb-merkle-mountain-range", "log", @@ -11790,7 +11790,7 @@ dependencies = [ [[package]] name = "sp-offchain" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "sp-api", "sp-core", @@ -11800,7 +11800,7 @@ dependencies = [ [[package]] name = "sp-panic-handler" version = "13.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "backtrace", "lazy_static", @@ -11810,7 +11810,7 @@ dependencies = [ [[package]] name = "sp-rpc" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "rustc-hash", "serde", @@ -11820,7 +11820,7 @@ dependencies = [ [[package]] name = "sp-runtime" version = "31.0.1" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "docify", "either", @@ -11844,7 +11844,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface" version = "24.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "bytes", "impl-trait-for-tuples", @@ -11863,7 +11863,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface-proc-macro" version = "17.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "Inflector", "expander", @@ -11876,7 +11876,7 @@ dependencies = [ [[package]] name = "sp-session" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "scale-info", @@ -11890,7 +11890,7 @@ dependencies = [ [[package]] name = "sp-staking" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "impl-trait-for-tuples", "parity-scale-codec", @@ -11903,7 +11903,7 @@ dependencies = [ [[package]] name = "sp-state-machine" version = "0.35.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "hash-db", "log", @@ -11923,7 +11923,7 @@ dependencies = [ [[package]] name = "sp-statement-store" version = "10.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "aes-gcm", "curve25519-dalek 4.1.2", @@ -11947,12 +11947,12 @@ dependencies = [ [[package]] name = "sp-std" version = "14.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" [[package]] name = "sp-storage" version = "19.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "impl-serde", "parity-scale-codec", @@ -11980,7 +11980,7 @@ dependencies = [ [[package]] name = "sp-timestamp" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "parity-scale-codec", @@ -11992,7 +11992,7 @@ dependencies = [ [[package]] name = "sp-tracing" version = "16.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "tracing", @@ -12003,7 +12003,7 @@ dependencies = [ [[package]] name = "sp-transaction-pool" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "sp-api", "sp-runtime", @@ -12012,7 +12012,7 @@ dependencies = [ [[package]] name = "sp-transaction-storage-proof" version = "26.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "async-trait", "parity-scale-codec", @@ -12026,7 +12026,7 @@ dependencies = [ [[package]] name = "sp-trie" version = "29.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "ahash 0.8.11", "hash-db", @@ -12049,7 +12049,7 @@ dependencies = [ [[package]] name = "sp-version" version = "29.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "impl-serde", "parity-scale-codec", @@ -12066,7 +12066,7 @@ dependencies = [ [[package]] name = "sp-version-proc-macro" version = "13.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "parity-scale-codec", "proc-macro2", @@ -12077,7 +12077,7 @@ dependencies = [ [[package]] name = "sp-wasm-interface" version = "20.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "anyhow", "impl-trait-for-tuples", @@ -12089,7 +12089,7 @@ dependencies = [ [[package]] name = "sp-weights" version = "27.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "bounded-collections", "parity-scale-codec", @@ -12962,7 +12962,7 @@ dependencies = [ [[package]] name = "substrate-bip39" version = "0.4.7" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "hmac 0.12.1", "pbkdf2", @@ -12987,12 +12987,12 @@ dependencies = [ [[package]] name = "substrate-build-script-utils" version = "11.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" [[package]] name = "substrate-frame-rpc-system" version = "28.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "frame-system-rpc-runtime-api", "futures", @@ -13011,7 +13011,7 @@ dependencies = [ [[package]] name = "substrate-prometheus-endpoint" version = "0.17.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "hyper", "log", @@ -13023,7 +13023,7 @@ dependencies = [ [[package]] name = "substrate-test-client" version = "2.0.1" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "array-bytes 6.2.2", "async-trait", @@ -13050,7 +13050,7 @@ dependencies = [ [[package]] name = "substrate-wasm-builder" version = "17.0.0" -source = "git+https://github.com/subspace/polkadot-sdk?rev=808269708cf5375526755797e8f9a9986016727d#808269708cf5375526755797e8f9a9986016727d" +source = "git+https://github.com/subspace/polkadot-sdk?rev=9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee#9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" dependencies = [ "build-helper", "cargo_metadata", diff --git a/Cargo.toml b/Cargo.toml index 02d7ab15e2..beb6014dcf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -92,45 +92,45 @@ lto = "fat" # Reason: We need to patch substrate dependency of frontier to our fork # TODO: Remove if/when we are using upstream substrate instead of fork [patch."https://github.com/paritytech/polkadot-sdk.git"] -frame-benchmarking = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-db = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-crypto-ec-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-crypto-hashing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-database = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-storage = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-db = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-crypto-ec-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-crypto-hashing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-database = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-storage = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } # TODO: Importing https://github.com/supranational/blst/pull/203 to take advantage of optimizations introduced there, # switch to upstream once merged or once similar performance improvements land upstream diff --git a/crates/pallet-domains/Cargo.toml b/crates/pallet-domains/Cargo.toml index bb1268406e..6308f42bab 100644 --- a/crates/pallet-domains/Cargo.toml +++ b/crates/pallet-domains/Cargo.toml @@ -14,32 +14,32 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } log = { version = "0.4.21", default-features = false } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", default-features = false, path = "../sp-consensus-subspace" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", default-features = false, path = "../sp-domains-fraud-proof" } -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", features = ["serde"] } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", features = ["serde"] } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } [dev-dependencies] domain-pallet-executive = { version = "0.1.0", default-features = false, path = "../../domains/pallets/executive" } hex-literal = "0.4.1" -pallet-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-block-fees = { version = "0.1.0", default-features = false, path = "../../domains/pallets/block-fees" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/crates/pallet-feeds/Cargo.toml b/crates/pallet-feeds/Cargo.toml index c033c0c7cf..90619ddfa2 100644 --- a/crates/pallet-feeds/Cargo.toml +++ b/crates/pallet-feeds/Cargo.toml @@ -14,15 +14,15 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } [dev-dependencies] -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/crates/pallet-grandpa-finality-verifier/Cargo.toml b/crates/pallet-grandpa-finality-verifier/Cargo.toml index dcca09fdb8..bfba280bf5 100644 --- a/crates/pallet-grandpa-finality-verifier/Cargo.toml +++ b/crates/pallet-grandpa-finality-verifier/Cargo.toml @@ -19,17 +19,17 @@ serde = { version = "1.0.199", optional = true } # Substrate Dependencies -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-consensus-grandpa = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-consensus-grandpa = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } [dev-dependencies] ed25519-dalek = { version = "2.1.1", default-features = false } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/crates/pallet-object-store/Cargo.toml b/crates/pallet-object-store/Cargo.toml index 9cfa113f39..3421252a52 100644 --- a/crates/pallet-object-store/Cargo.toml +++ b/crates/pallet-object-store/Cargo.toml @@ -14,17 +14,17 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } hex = { version = "0.4.3", default-features = false, features = ["alloc"] } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } [dev-dependencies] -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/crates/pallet-offences-subspace/Cargo.toml b/crates/pallet-offences-subspace/Cargo.toml index 8655af6081..0a265e7414 100644 --- a/crates/pallet-offences-subspace/Cargo.toml +++ b/crates/pallet-offences-subspace/Cargo.toml @@ -14,16 +14,16 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } sp-consensus-subspace = { version = "0.1.0", default-features = false, path = "../sp-consensus-subspace" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [dev-dependencies] -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } schnorrkel = "0.11.4" [features] diff --git a/crates/pallet-rewards/Cargo.toml b/crates/pallet-rewards/Cargo.toml index 59cdabcacf..f387d848e1 100644 --- a/crates/pallet-rewards/Cargo.toml +++ b/crates/pallet-rewards/Cargo.toml @@ -19,19 +19,19 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } serde = { version = "1.0.199", default-features = false, features = ["alloc", "derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } [dev-dependencies] -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/crates/pallet-runtime-configs/Cargo.toml b/crates/pallet-runtime-configs/Cargo.toml index b121e73c1f..267b061f48 100644 --- a/crates/pallet-runtime-configs/Cargo.toml +++ b/crates/pallet-runtime-configs/Cargo.toml @@ -17,13 +17,13 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [features] default = ["std"] diff --git a/crates/pallet-subspace-mmr/Cargo.toml b/crates/pallet-subspace-mmr/Cargo.toml index 4dd41724f6..d3574c805d 100644 --- a/crates/pallet-subspace-mmr/Cargo.toml +++ b/crates/pallet-subspace-mmr/Cargo.toml @@ -17,13 +17,13 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../sp-subspace-mmr" } [features] diff --git a/crates/pallet-subspace/Cargo.toml b/crates/pallet-subspace/Cargo.toml index 602f155fcf..07e1382a74 100644 --- a/crates/pallet-subspace/Cargo.toml +++ b/crates/pallet-subspace/Cargo.toml @@ -14,18 +14,18 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } schnorrkel = { version = "0.11.4", default-features = false } serde = { version = "1.0.199", optional = true, default-features = false, features = ["derive"] } sp-consensus-subspace = { version = "0.1.0", default-features = false, path = "../sp-consensus-subspace" } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } subspace-verification = { version = "0.1.0", path = "../subspace-verification", default-features = false } @@ -33,11 +33,11 @@ subspace-verification = { version = "0.1.0", path = "../subspace-verification", [dev-dependencies] env_logger = "0.11.3" futures = "0.3.29" -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-offences-subspace = { version = "0.1.0", path = "../pallet-offences-subspace" } rand = { version = "0.8.5", features = ["min_const_gen"] } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-archiving = { version = "0.1.0", path = "../subspace-archiving" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-farmer-components = { version = "0.1.0", path = "../subspace-farmer-components" } diff --git a/crates/pallet-transaction-fees/Cargo.toml b/crates/pallet-transaction-fees/Cargo.toml index 107f7747ca..834ad653a1 100644 --- a/crates/pallet-transaction-fees/Cargo.toml +++ b/crates/pallet-transaction-fees/Cargo.toml @@ -19,8 +19,8 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } diff --git a/crates/sc-consensus-subspace-rpc/Cargo.toml b/crates/sc-consensus-subspace-rpc/Cargo.toml index 3d7c7d529c..ef08bc3c64 100644 --- a/crates/sc-consensus-subspace-rpc/Cargo.toml +++ b/crates/sc-consensus-subspace-rpc/Cargo.toml @@ -20,18 +20,18 @@ jsonrpsee = { version = "0.22.5", features = ["server", "macros"] } parity-scale-codec = "3.6.9" parking_lot = "0.12.2" schnellru = "0.2.3" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-consensus-subspace = { version = "0.1.0", path = "../sc-consensus-subspace" } -sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-objects = { version = "0.1.0", path = "../sp-objects" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-archiving = { version = "0.1.0", path = "../subspace-archiving" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-farmer-components = { version = "0.1.0", path = "../subspace-farmer-components" } diff --git a/crates/sc-consensus-subspace/Cargo.toml b/crates/sc-consensus-subspace/Cargo.toml index c0efc1db65..e2525366d0 100644 --- a/crates/sc-consensus-subspace/Cargo.toml +++ b/crates/sc-consensus-subspace/Cargo.toml @@ -22,23 +22,23 @@ rand_chacha = "0.3.1" rayon = "1.10.0" schnellru = "0.2.3" schnorrkel = "0.11.4" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-proof-of-time = { version = "0.1.0", path = "../sc-proof-of-time" } -sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-objects = { version = "0.1.0", path = "../sp-objects" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-archiving = { version = "0.1.0", path = "../subspace-archiving" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-proof-of-space = { version = "0.1.0", path = "../subspace-proof-of-space" } diff --git a/crates/sc-domains/Cargo.toml b/crates/sc-domains/Cargo.toml index 1171389848..0957b77322 100644 --- a/crates/sc-domains/Cargo.toml +++ b/crates/sc-domains/Cargo.toml @@ -16,19 +16,19 @@ include = [ targets = ["x86_64-unknown-linux-gnu"] [dependencies] -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-auto-id = { version = "0.1.0", path = "../../domains/primitives/auto-id" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", default-features = false, path = "../sp-domains-fraud-proof" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger-host-functions = { version = "0.1.0", path = "../../domains/primitives/messenger-host-functions" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", path = "../sp-subspace-mmr" } [features] diff --git a/crates/sc-proof-of-time/Cargo.toml b/crates/sc-proof-of-time/Cargo.toml index 8045b98e67..7b3273a0e6 100644 --- a/crates/sc-proof-of-time/Cargo.toml +++ b/crates/sc-proof-of-time/Cargo.toml @@ -19,17 +19,17 @@ parity-scale-codec = { version = "3.6.9", features = ["derive"] } parking_lot = "0.12.2" rayon = "1.10.0" schnellru = "0.2.3" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-gossip = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-gossip = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-proof-of-time = { version = "0.1.0", path = "../subspace-proof-of-time" } thread-priority = "1.1.0" diff --git a/crates/sc-subspace-block-relay/Cargo.toml b/crates/sc-subspace-block-relay/Cargo.toml index 8ff04ac88a..40b11b35e9 100644 --- a/crates/sc-subspace-block-relay/Cargo.toml +++ b/crates/sc-subspace-block-relay/Cargo.toml @@ -17,16 +17,16 @@ codec = { package = "parity-scale-codec", version = "3.6.5", default-features = derive_more = "0.99.17" futures = "0.3.29" parking_lot = "0.12.2" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } strum_macros = "0.26.2" -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } thiserror = "1.0.59" tracing = "0.1.40" diff --git a/crates/sp-consensus-subspace/Cargo.toml b/crates/sp-consensus-subspace/Cargo.toml index 9107ce2d99..e0a3d29d6c 100644 --- a/crates/sp-consensus-subspace/Cargo.toml +++ b/crates/sp-consensus-subspace/Cargo.toml @@ -18,17 +18,17 @@ codec = { package = "parity-scale-codec", version = "3.6.5", default-features = log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } schnorrkel = { version = "0.11.4", default-features = false } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-application-crypto = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-application-crypto = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives", default-features = false } subspace-proof-of-space = { version = "0.1.0", path = "../subspace-proof-of-space", default-features = false } subspace-verification = { version = "0.1.0", path = "../subspace-verification", default-features = false } diff --git a/crates/sp-domains-fraud-proof/Cargo.toml b/crates/sp-domains-fraud-proof/Cargo.toml index 1258fccb11..0431764462 100644 --- a/crates/sp-domains-fraud-proof/Cargo.toml +++ b/crates/sp-domains-fraud-proof/Cargo.toml @@ -14,25 +14,25 @@ include = [ codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-block-preprocessor = { version = "0.1.0", default-features = false, path = "../../domains/client/block-preprocessor", optional = true } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } hash-db = { version = "0.16.0", default-features = false } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false, optional = true } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false, optional = true } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domain-digests = { version = "0.1.0", default-features = false, path = "../../domains/primitives/digests" } sp-domains = { version = "0.1.0", default-features = false, path = "../sp-domains" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } trie-db = { version = "0.28.0", default-features = false } @@ -43,21 +43,21 @@ domain-block-builder = { version = "0.1.0", path = "../../domains/client/block-b domain-block-preprocessor = { version = "0.1.0", path = "../../domains/client/block-preprocessor" } domain-test-service = { version = "0.1.0", path = "../../domains/test/service" } ethereum = "0.15.0" -fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", features = ['default'] } -fp-self-contained = { version = "1.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", features = ['default'] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", features = ['default'] } +fp-self-contained = { version = "1.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", features = ['default'] } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } futures = "0.3.29" libsecp256k1 = { version = "0.7.1", features = ["static-context", "hmac"] } -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-ethereum = { git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", features = ['default'] } -pallet-evm = { version = "6.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", default-features = false } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-ethereum = { git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", features = ['default'] } +pallet-evm = { version = "6.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", default-features = false } parking_lot = "0.12.2" rand = { version = "0.8.5", features = ["min_const_gen"] } rlp = "0.5.2" -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } subspace-test-client = { version = "0.1.0", path = "../../test/subspace-test-client" } subspace-test-service = { version = "0.1.0", path = "../../test/subspace-test-service" } subspace-runtime-primitives = { version = "0.1.0", path = "../../crates/subspace-runtime-primitives" } diff --git a/crates/sp-domains/Cargo.toml b/crates/sp-domains/Cargo.toml index 86dcb6a841..9e15373de1 100644 --- a/crates/sp-domains/Cargo.toml +++ b/crates/sp-domains/Cargo.toml @@ -14,7 +14,7 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] blake2 = { version = "0.10.6", default-features = false } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } hash-db = { version = "0.16.0", default-features = false } memory-db = { version = "0.32.0", default-features = false } hexlit = "0.5.5" @@ -24,16 +24,16 @@ rand_chacha = { version = "0.3.1", default-features = false } rs_merkle = { version = "1.4.2", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } serde = { version = "1.0.199", default-features = false, features = ["alloc", "derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-application-crypto = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-weights = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-application-crypto = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-weights = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } trie-db = { version = "0.28.0", default-features = false } diff --git a/crates/sp-lightclient/Cargo.toml b/crates/sp-lightclient/Cargo.toml index 44003f9766..cdd82ce700 100644 --- a/crates/sp-lightclient/Cargo.toml +++ b/crates/sp-lightclient/Cargo.toml @@ -19,20 +19,20 @@ include = [ codec = { package = "parity-scale-codec", version = "3.1.2", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } schnorrkel = { version = "0.11.4", default-features = false } -sp-arithmetic = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-arithmetic = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace", default-features = false } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives", default-features = false } subspace-erasure-coding = { version = "0.1.0", path = "../subspace-erasure-coding", default-features = false } subspace-verification = { version = "0.1.0", path = "../subspace-verification", default-features = false } [dev-dependencies] -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } futures = "0.3.29" rand = { version = "0.8.5", features = ["min_const_gen"] } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-archiving = { version = "0.1.0", path = "../subspace-archiving" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-farmer-components = { version = "0.1.0", path = "../subspace-farmer-components" } diff --git a/crates/sp-objects/Cargo.toml b/crates/sp-objects/Cargo.toml index 435a7a176c..f0d42b627c 100644 --- a/crates/sp-objects/Cargo.toml +++ b/crates/sp-objects/Cargo.toml @@ -13,7 +13,7 @@ readme = "README.md" targets = ["x86_64-unknown-linux-gnu"] [dependencies] -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } diff --git a/crates/sp-subspace-mmr/Cargo.toml b/crates/sp-subspace-mmr/Cargo.toml index 0b90e98128..e02e669860 100644 --- a/crates/sp-subspace-mmr/Cargo.toml +++ b/crates/sp-subspace-mmr/Cargo.toml @@ -18,13 +18,13 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { default-features = false, path = "../subspace-core-primitives" } [features] diff --git a/crates/subspace-fake-runtime-api/Cargo.toml b/crates/subspace-fake-runtime-api/Cargo.toml index 01a603bb96..4b654d2bac 100644 --- a/crates/subspace-fake-runtime-api/Cargo.toml +++ b/crates/subspace-fake-runtime-api/Cargo.toml @@ -14,27 +14,27 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { default-features = false, path = "../sp-consensus-subspace" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", default-features = false, path = "../sp-domains-fraud-proof" } -sp-genesis-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-genesis-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { default-features = false, version = "0.1.0", path = "../../domains/primitives/messenger" } sp-objects = { default-features = false, path = "../sp-objects" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } diff --git a/crates/subspace-malicious-operator/Cargo.toml b/crates/subspace-malicious-operator/Cargo.toml index 736c0127b7..e2e1e1e01c 100644 --- a/crates/subspace-malicious-operator/Cargo.toml +++ b/crates/subspace-malicious-operator/Cargo.toml @@ -28,44 +28,44 @@ domain-eth-service = { version = "0.1.0", path = "../../domains/client/eth-servi domain-service = { version = "0.1.0", path = "../../domains/service" } domain-runtime-primitives = { version = "0.1.0", path = "../../domains/primitives/runtime" } evm-domain-runtime = { version = "0.1.0", path = "../../domains/runtime/evm" } -fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } futures = "0.3.29" hex-literal = "0.4.1" log = "0.4.21" mimalloc = "0.1.41" pallet-domains = { version = "0.1.0", default-features = false, path = "../pallet-domains" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } parity-scale-codec = "3.6.9" -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-consensus-subspace = { version = "0.1.0", path = "../sc-consensus-subspace" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-storage-monitor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-storage-monitor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sc-subspace-chain-specs = { version = "0.1.0", path = "../sc-subspace-chain-specs" } -sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } serde_json = "1.0.116" -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../sp-domains" } sp-domain-digests = { version = "0.1.0", path = "../../domains/primitives/digests" } -sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../domains/primitives/messenger" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-networking = { version = "0.1.0", path = "../subspace-networking" } subspace-proof-of-space = { version = "0.1.0", path = "../subspace-proof-of-space" } @@ -78,7 +78,7 @@ rand = "0.8.5" tracing = "0.1.40" [build-dependencies] -substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = [] diff --git a/crates/subspace-node/Cargo.toml b/crates/subspace-node/Cargo.toml index ac0a5d8ae4..168ed948c5 100644 --- a/crates/subspace-node/Cargo.toml +++ b/crates/subspace-node/Cargo.toml @@ -32,44 +32,44 @@ domain-service = { version = "0.1.0", path = "../../domains/service" } domain-runtime-primitives = { version = "0.1.0", path = "../../domains/primitives/runtime" } evm-domain-runtime = { version = "0.1.0", path = "../../domains/runtime/evm" } fdlimit = "0.3.0" -fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -frame-benchmarking = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -frame-benchmarking-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +frame-benchmarking = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +frame-benchmarking-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } futures = "0.3.29" hex = "0.4.3" hex-literal = "0.4.1" mimalloc = "0.1.41" parity-scale-codec = "3.6.9" prometheus-client = "0.22.2" -sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-consensus-subspace = { version = "0.1.0", path = "../sc-consensus-subspace" } sc-domains = { version = "0.1.0", path = "../sc-domains" } -sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-proof-of-time = { version = "0.1.0", path = "../sc-proof-of-time" } sc-subspace-chain-specs = { version = "0.1.0", path = "../sc-subspace-chain-specs" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-storage-monitor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-storage-monitor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } serde_json = "1.0.116" -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../sp-domains" } sp-domain-digests = { version = "0.1.0", path = "../../domains/primitives/digests" } sp-domains-fraud-proof = { version = "0.1.0", path = "../sp-domains-fraud-proof" } -sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../domains/primitives/messenger" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-metrics = { version = "0.1.0", path = "../../shared/subspace-metrics" } subspace-networking = { version = "0.1.0", path = "../subspace-networking" } @@ -77,7 +77,7 @@ subspace-proof-of-space = { version = "0.1.0", path = "../subspace-proof-of-spac subspace-runtime = { version = "0.1.0", path = "../subspace-runtime" } subspace-runtime-primitives = { version = "0.1.0", path = "../subspace-runtime-primitives" } subspace-service = { version = "0.1.0", path = "../subspace-service" } -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } supports-color = "3.0.0" tempfile = "3.10.1" thiserror = "1.0.59" @@ -87,7 +87,7 @@ tracing = "0.1.40" tracing-subscriber = { version = "0.3.18", features = ["env-filter"] } [build-dependencies] -substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = [] diff --git a/crates/subspace-runtime-primitives/Cargo.toml b/crates/subspace-runtime-primitives/Cargo.toml index c0f8456ad1..43150f2130 100644 --- a/crates/subspace-runtime-primitives/Cargo.toml +++ b/crates/subspace-runtime-primitives/Cargo.toml @@ -17,13 +17,13 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } [features] diff --git a/crates/subspace-runtime/Cargo.toml b/crates/subspace-runtime/Cargo.toml index a2863cf832..078eb61b7c 100644 --- a/crates/subspace-runtime/Cargo.toml +++ b/crates/subspace-runtime/Cargo.toml @@ -18,60 +18,60 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-executive = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-executive = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } orml-vesting = { version = "0.9.1", default-features = false, path = "../../orml/vesting" } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-domains = { version = "0.1.0", default-features = false, path = "../pallet-domains" } pallet-messenger = { version = "0.1.0", path = "../../domains/pallets/messenger", default-features = false } -pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-offences-subspace = { version = "0.1.0", default-features = false, path = "../pallet-offences-subspace" } pallet-rewards = { version = "0.1.0", default-features = false, path = "../pallet-rewards" } pallet-runtime-configs = { version = "0.1.0", default-features = false, path = "../pallet-runtime-configs" } pallet-subspace = { version = "0.1.0", default-features = false, features = ["serde"], path = "../pallet-subspace" } pallet-subspace-mmr = { version = "0.1.0", default-features = false, path = "../pallet-subspace-mmr" } -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transaction-fees = { version = "0.1.0", default-features = false, path = "../pallet-transaction-fees" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../domains/pallets/transporter", default-features = false } -pallet-utility = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-utility = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-consensus-subspace = { version = "0.1.0", default-features = false, path = "../sp-consensus-subspace" } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", default-features = false, path = "../sp-domains-fraud-proof" } -sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-messenger = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger-host-functions" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-objects = { version = "0.1.0", default-features = false, path = "../sp-objects" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { default-features = false, path = "../sp-subspace-mmr" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } static_assertions = "1.1.0" subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" } [build-dependencies] -substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [dev-dependencies] hex-literal = "0.4.1" -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-runtime-primitives = { version = "0.1.0", features = ["testing"], path = "../subspace-runtime-primitives" } [features] diff --git a/crates/subspace-service/Cargo.toml b/crates/subspace-service/Cargo.toml index 3da47e8fc1..3fc7fbe56f 100644 --- a/crates/subspace-service/Cargo.toml +++ b/crates/subspace-service/Cargo.toml @@ -19,75 +19,75 @@ targets = ["x86_64-unknown-linux-gnu"] async-trait = "0.1.80" cross-domain-message-gossip = { version = "0.1.0", path = "../../domains/client/cross-domain-message-gossip" } domain-runtime-primitives = { version = "0.1.0", path = "../../domains/primitives/runtime" } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } futures = "0.3.29" hex = "0.4.3" jsonrpsee = { version = "0.22.5", features = ["server"] } -mmr-gadget = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -mmr-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +mmr-gadget = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +mmr-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } parity-scale-codec = "3.6.9" parking_lot = "0.12.2" prometheus-client = "0.22.2" -sc-basic-authorship = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-basic-authorship = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-consensus-subspace = { version = "0.1.0", path = "../sc-consensus-subspace" } sc-consensus-subspace-rpc = { version = "0.1.0", path = "../sc-consensus-subspace-rpc" } -sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-domains = { version = "0.1.0", path = "../sc-domains" } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-proof-of-time = { version = "0.1.0", path = "../sc-proof-of-time" } -sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc-spec-v2 = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc-spec-v2 = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sc-subspace-block-relay = { version = "0.1.0", path = "../sc-subspace-block-relay" } -sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } schnorrkel = "0.11.4" -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../sp-consensus-subspace" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", path = "../sp-domains-fraud-proof" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../domains/primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", path = "../../domains/primitives/messenger-host-functions" } -sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-objects = { version = "0.1.0", path = "../sp-objects" } -sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", path = "../sp-subspace-mmr" } -sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } static_assertions = "1.1.0" subspace-archiving = { version = "0.1.0", path = "../subspace-archiving" } subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives" } subspace-networking = { version = "0.1.0", path = "../subspace-networking" } subspace-proof-of-space = { version = "0.1.0", path = "../subspace-proof-of-space" } subspace-runtime-primitives = { version = "0.1.0", path = "../subspace-runtime-primitives" } -substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } thiserror = "1.0.59" tokio = { version = "1.37.0", features = ["sync"] } tracing = "0.1.40" -sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] runtime-benchmarks = [ diff --git a/domains/client/block-builder/Cargo.toml b/domains/client/block-builder/Cargo.toml index 496458cf03..38579376bc 100644 --- a/domains/client/block-builder/Cargo.toml +++ b/domains/client/block-builder/Cargo.toml @@ -14,12 +14,12 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", features = ["derive"] } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } tracing = "0.1.40" diff --git a/domains/client/block-preprocessor/Cargo.toml b/domains/client/block-preprocessor/Cargo.toml index 0cfe91a2b2..49c982196a 100644 --- a/domains/client/block-preprocessor/Cargo.toml +++ b/domains/client/block-preprocessor/Cargo.toml @@ -15,26 +15,26 @@ include = [ async-trait = { version = "0.1.57" } codec = { package = "parity-scale-codec", version = "3.6.5", features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-executor-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-executor-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-block-fees = { version = "0.1.0", path = "../../primitives/block-fees" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains" } sp-executive = { version = "0.1.0", path = "../../primitives/executive" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../primitives/messenger" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../crates/subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives" } tracing = "0.1.40" [dev-dependencies] -sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } diff --git a/domains/client/consensus-relay-chain/Cargo.toml b/domains/client/consensus-relay-chain/Cargo.toml index 7f75087d33..f89f8f8069 100644 --- a/domains/client/consensus-relay-chain/Cargo.toml +++ b/domains/client/consensus-relay-chain/Cargo.toml @@ -7,9 +7,9 @@ edition = "2021" [dependencies] async-trait = "0.1.80" -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } diff --git a/domains/client/cross-domain-message-gossip/Cargo.toml b/domains/client/cross-domain-message-gossip/Cargo.toml index cd7c7f56d1..85674e69a4 100644 --- a/domains/client/cross-domain-message-gossip/Cargo.toml +++ b/domains/client/cross-domain-message-gossip/Cargo.toml @@ -15,12 +15,12 @@ include = [ futures = "0.3.29" parity-scale-codec = { version = "3.6.9", features = ["derive"] } parking_lot = "0.12.2" -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-gossip = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-gossip = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } tracing = "0.1.40" diff --git a/domains/client/domain-operator/Cargo.toml b/domains/client/domain-operator/Cargo.toml index 64d09560af..54c51d9f82 100644 --- a/domains/client/domain-operator/Cargo.toml +++ b/domains/client/domain-operator/Cargo.toml @@ -12,30 +12,30 @@ domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtim futures = "0.3.29" futures-timer = "3.0.3" parking_lot = "0.12.2" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", path = "../../../crates/sp-domains-fraud-proof" } sp-domain-digests = { version = "0.1.0", path = "../../primitives/digests" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-keystore = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../primitives/messenger" } -sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } -sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-weights = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-weights = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../crates/subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives" } tracing = "0.1.40" @@ -46,17 +46,17 @@ tokio = { version = "1.37.0", features = ["macros"] } domain-test-service = { version = "0.1.0", path = "../../test/service" } domain-test-primitives = { version = "0.1.0", path = "../../test/primitives" } evm-domain-test-runtime = { version = "0.1.0", path = "../../test/runtime/evm" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-domains = { version = "0.1.0", path = "../../../crates/pallet-domains" } pallet-messenger = { version = "0.1.0", path = "../../../domains/pallets/messenger" } -pallet-sudo = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../../domains/pallets/transporter" } -sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-cli = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../../../crates/subspace-core-primitives" } subspace-test-runtime = { version = "0.1.0", path = "../../../test/subspace-test-runtime" } subspace-test-service = { version = "0.1.0", path = "../../../test/subspace-test-service" } diff --git a/domains/client/eth-service/Cargo.toml b/domains/client/eth-service/Cargo.toml index 82e70d6dbd..69a396fb72 100644 --- a/domains/client/eth-service/Cargo.toml +++ b/domains/client/eth-service/Cargo.toml @@ -15,28 +15,28 @@ include = [ clap = { version = "4.5.4", features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime" } domain-service = { version = "0.1.0", path = "../../service" } -fc-consensus = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fc-db = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", default-features = false } -fc-mapping-sync = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", default-features = false } -fc-rpc = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", default-features = false, features = ['rpc-binary-search-estimate'] } -fc-rpc-core = { version = "1.1.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fc-storage = { version = "1.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", features = ['default'] } +fc-consensus = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fc-db = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", default-features = false } +fc-mapping-sync = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", default-features = false } +fc-rpc = { version = "2.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", default-features = false, features = ['rpc-binary-search-estimate'] } +fc-rpc-core = { version = "1.1.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fc-storage = { version = "1.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", features = ['default'] } futures = "0.3.29" jsonrpsee = { version = "0.22.5", features = ["server"] } -pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } parity-scale-codec = "3.6.9" -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } serde = { version = "1.0.199", features = ["derive"] } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } diff --git a/domains/client/relayer/Cargo.toml b/domains/client/relayer/Cargo.toml index 2de65b9a2d..fff8c19796 100644 --- a/domains/client/relayer/Cargo.toml +++ b/domains/client/relayer/Cargo.toml @@ -16,16 +16,16 @@ async-channel = "1.9.0" cross-domain-message-gossip = { path = "../../client/cross-domain-message-gossip" } futures = "0.3.29" parity-scale-codec = { version = "3.6.9", features = ["derive"] } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-state-db = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-state-db = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains" } sp-messenger = { version = "0.1.0", path = "../../primitives/messenger" } -sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } tracing = "0.1.40" diff --git a/domains/pallets/auto-id/Cargo.toml b/domains/pallets/auto-id/Cargo.toml index 544ee80694..5ac48e4a70 100644 --- a/domains/pallets/auto-id/Cargo.toml +++ b/domains/pallets/auto-id/Cargo.toml @@ -14,18 +14,18 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } sp-auto-id = { version = "0.1.0", default-features = false, path = "../../primitives/auto-id" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../../crates/subspace-runtime-primitives" } [dev-dependencies] pem = "3.0.4" ring = "0.17.8" -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } x509-parser = { version = "0.16.0" } [features] diff --git a/domains/pallets/block-fees/Cargo.toml b/domains/pallets/block-fees/Cargo.toml index 8226ca1a7c..f685a897b2 100644 --- a/domains/pallets/block-fees/Cargo.toml +++ b/domains/pallets/block-fees/Cargo.toml @@ -15,14 +15,14 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime", default-features = false } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } sp-block-fees = { version = "0.1.0", path = "../../primitives/block-fees", default-features = false } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains", default-features = false } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/pallets/domain-id/Cargo.toml b/domains/pallets/domain-id/Cargo.toml index f73e34dab9..40ee230d93 100644 --- a/domains/pallets/domain-id/Cargo.toml +++ b/domains/pallets/domain-id/Cargo.toml @@ -14,15 +14,15 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } sp-domains = { version = "0.1.0", default-features = false, path = "../../../crates/sp-domains" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [dev-dependencies] -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/pallets/evm_nonce_tracker/Cargo.toml b/domains/pallets/evm_nonce_tracker/Cargo.toml index d0d56850ad..19db06781d 100644 --- a/domains/pallets/evm_nonce_tracker/Cargo.toml +++ b/domains/pallets/evm_nonce_tracker/Cargo.toml @@ -14,11 +14,11 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/pallets/executive/Cargo.toml b/domains/pallets/executive/Cargo.toml index 42f9268fc4..b6e2aeeb9f 100644 --- a/domains/pallets/executive/Cargo.toml +++ b/domains/pallets/executive/Cargo.toml @@ -13,23 +13,23 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-executive = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-executive = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } sp-executive = { version = "0.1.0", path = "../../primitives/executive", default-features = false } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-std = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } [dev-dependencies] -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/pallets/messenger/Cargo.toml b/domains/pallets/messenger/Cargo.toml index bdcc0deca5..d65418722f 100644 --- a/domains/pallets/messenger/Cargo.toml +++ b/domains/pallets/messenger/Cargo.toml @@ -15,24 +15,24 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../../../crates/sp-domains" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } [dev-dependencies] domain-runtime-primitives = { path = "../../primitives/runtime" } -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../transporter" } -sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-state-machine = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/pallets/transporter/Cargo.toml b/domains/pallets/transporter/Cargo.toml index 335b849d4e..994fb91d2e 100644 --- a/domains/pallets/transporter/Cargo.toml +++ b/domains/pallets/transporter/Cargo.toml @@ -16,19 +16,19 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { path = "../../primitives/runtime", default-features = false } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../../../crates/sp-domains" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [dev-dependencies] -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/primitives/auto-id/Cargo.toml b/domains/primitives/auto-id/Cargo.toml index 6ac126cc50..57e68cd40c 100644 --- a/domains/primitives/auto-id/Cargo.toml +++ b/domains/primitives/auto-id/Cargo.toml @@ -16,9 +16,9 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives", default-features = false } x509-parser = { version = "0.16.0", features = ["verify"], optional = true } diff --git a/domains/primitives/block-fees/Cargo.toml b/domains/primitives/block-fees/Cargo.toml index 1f97757d94..db46dc24ad 100644 --- a/domains/primitives/block-fees/Cargo.toml +++ b/domains/primitives/block-fees/Cargo.toml @@ -16,8 +16,8 @@ include = [ async-trait = { version = "0.1.80", optional = true } codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../runtime" } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/primitives/digests/Cargo.toml b/domains/primitives/digests/Cargo.toml index ec1dfbdd95..4aab835042 100644 --- a/domains/primitives/digests/Cargo.toml +++ b/domains/primitives/digests/Cargo.toml @@ -15,7 +15,7 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false, features = ["derive"] } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/primitives/executive/Cargo.toml b/domains/primitives/executive/Cargo.toml index fd22f267dd..9d71a95396 100644 --- a/domains/primitives/executive/Cargo.toml +++ b/domains/primitives/executive/Cargo.toml @@ -16,7 +16,7 @@ include = [ [dependencies] async-trait = { version = "0.1.80", optional = true } codec = { package = "parity-scale-codec", version = "3.1.5", default-features = false, features = ["derive"] } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/primitives/messenger-host-functions/Cargo.toml b/domains/primitives/messenger-host-functions/Cargo.toml index 8e0000aa85..4fc49715c0 100644 --- a/domains/primitives/messenger-host-functions/Cargo.toml +++ b/domains/primitives/messenger-host-functions/Cargo.toml @@ -17,15 +17,15 @@ include = [ codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-block-preprocessor = { version = "0.1.0", default-features = false, path = "../../../domains/client/block-preprocessor", optional = true } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false, optional = true } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false, optional = true } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../../../crates/sp-domains" } -sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime-interface = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/primitives/messenger/Cargo.toml b/domains/primitives/messenger/Cargo.toml index e285089ca0..e0659925bd 100644 --- a/domains/primitives/messenger/Cargo.toml +++ b/domains/primitives/messenger/Cargo.toml @@ -16,18 +16,18 @@ include = [ [dependencies] async-trait = { version = "0.1.80", optional = true } codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } hash-db = { version = "0.16.0", default-features = false } log = { version = "0.4.21", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } serde = { version = "1.0.199", default-features = false, features = ["alloc", "derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../../../crates/sp-domains" } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-trie = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } [features] diff --git a/domains/primitives/runtime/Cargo.toml b/domains/primitives/runtime/Cargo.toml index fd418a9a50..5ff6bce300 100644 --- a/domains/primitives/runtime/Cargo.toml +++ b/domains/primitives/runtime/Cargo.toml @@ -12,18 +12,18 @@ description = "Common primitives of subspace domain runtime" targets = ["x86_64-unknown-linux-gnu"] [dependencies] -fp-account = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +fp-account = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } parity-scale-codec = { version = "3.6.9", default-features = false, features = ["derive"] } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } serde = { version = "1.0.199", default-features = false, features = ["alloc", "derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../crates/subspace-core-primitives", default-features = false } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives", default-features = false } -sp-weights = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-weights = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/domains/runtime/auto-id/Cargo.toml b/domains/runtime/auto-id/Cargo.toml index 3e1c4bce27..de4d486e10 100644 --- a/domains/runtime/auto-id/Cargo.toml +++ b/domains/runtime/auto-id/Cargo.toml @@ -20,39 +20,39 @@ targets = ["x86_64-unknown-linux-gnu"] codec = { package = "parity-scale-codec", version = "3.2.1", default-features = false, features = ["derive"] } domain-pallet-executive = { version = "0.1.0", path = "../../pallets/executive", default-features = false } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime", default-features = false } -frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-auto-id = { version = "0.1.0", path = "../../pallets/auto-id", default-features = false } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-block-fees = { version = "0.1.0", path = "../../pallets/block-fees", default-features = false } pallet-domain-id = { version = "0.1.0", path = "../../pallets/domain-id", default-features = false } pallet-messenger = { version = "0.1.0", path = "../../pallets/messenger", default-features = false } -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../pallets/transporter", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains", default-features = false } -sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", default-features = false, path = "../../primitives/messenger-host-functions" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-storage = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-storage = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../crates/subspace-core-primitives", default-features = false } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives", default-features = false } @@ -60,7 +60,7 @@ subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subsp subspace-runtime-primitives = { version = "0.1.0", features = ["testing"], path = "../../../crates/subspace-runtime-primitives" } [build-dependencies] -substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [features] default = [ diff --git a/domains/runtime/evm/Cargo.toml b/domains/runtime/evm/Cargo.toml index 094b4ff4cc..bdc0d48694 100644 --- a/domains/runtime/evm/Cargo.toml +++ b/domains/runtime/evm/Cargo.toml @@ -20,49 +20,49 @@ targets = ["x86_64-unknown-linux-gnu"] codec = { package = "parity-scale-codec", version = "3.2.1", default-features = false, features = ["derive"] } domain-pallet-executive = { version = "0.1.0", path = "../../pallets/executive", default-features = false } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime", default-features = false } -fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-rpc = { version = "3.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-self-contained = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-base-fee = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-rpc = { version = "3.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-self-contained = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +frame-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-benchmarking = { default-features = false, optional = true, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-base-fee = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-block-fees = { version = "0.1.0", path = "../../pallets/block-fees", default-features = false } pallet-domain-id = { version = "0.1.0", path = "../../pallets/domain-id", default-features = false } -pallet-ethereum = { default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm = { version = "6.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-chain-id = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +pallet-ethereum = { default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm = { version = "6.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-chain-id = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-evm-nonce-tracker = { version = "0.1.0", path = "../../pallets/evm_nonce_tracker", default-features = false } -pallet-evm-precompile-modexp = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-precompile-sha3fips = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-precompile-simple = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +pallet-evm-precompile-modexp = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-precompile-sha3fips = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-precompile-simple = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-messenger = { version = "0.1.0", path = "../../pallets/messenger", default-features = false } -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../pallets/transporter", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains", default-features = false } -sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", default-features = false, path = "../../primitives/messenger-host-functions" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-storage = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-storage = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../crates/sp-subspace-mmr" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../crates/subspace-core-primitives", default-features = false } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives", default-features = false } @@ -70,7 +70,7 @@ subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subsp subspace-runtime-primitives = { version = "0.1.0", features = ["testing"], path = "../../../crates/subspace-runtime-primitives" } [build-dependencies] -substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [features] default = [ diff --git a/domains/service/Cargo.toml b/domains/service/Cargo.toml index a7aeaa14e9..87a68172a9 100644 --- a/domains/service/Cargo.toml +++ b/domains/service/Cargo.toml @@ -20,57 +20,57 @@ domain-client-consensus-relay-chain = { version = "0.1.0", path = "../client/con domain-client-message-relayer = { version = "0.1.0", path = "../client/relayer" } domain-client-operator = { version = "0.1.0", path = "../client/domain-operator" } domain-runtime-primitives = { version = "0.1.0", path = "../primitives/runtime" } -frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +frame-benchmarking = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } futures = "0.3.29" jsonrpsee = { version = "0.22.5", features = ["server"] } log = "0.4.21" -pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } parity-scale-codec = "3.6.9" -sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-io = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-domains = { version = "0.1.0", path = "../../crates/sc-domains" } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-transactions = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-rpc-spec-v2 = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-informant = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-common = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-transactions = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-rpc-spec-v2 = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-telemetry = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } serde = { version = "1.0.199", features = ["derive"] } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus-slots = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../crates/sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", path = "../../crates/sp-domains-fraud-proof" } sp-messenger = { version = "0.1.0", path = "../../domains/primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", path = "../../domains/primitives/messenger-host-functions" } -sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", path = "../../crates/sp-subspace-mmr" } -sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../crates/subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", path = "../../crates/subspace-runtime-primitives" } -substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-prometheus-endpoint = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } tokio = "1.37.0" tracing = "0.1.40" [build-dependencies] -substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-build-script-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] runtime-benchmarks = [ diff --git a/domains/test/primitives/Cargo.toml b/domains/test/primitives/Cargo.toml index 143377c8af..6821c05891 100644 --- a/domains/test/primitives/Cargo.toml +++ b/domains/test/primitives/Cargo.toml @@ -13,7 +13,7 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false, features = ["derive"] } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-messenger = { version = "0.1.0", default-features = false, path = "../../primitives/messenger" } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives", default-features = false } diff --git a/domains/test/runtime/evm/Cargo.toml b/domains/test/runtime/evm/Cargo.toml index fe311a4765..15fa92bcaf 100644 --- a/domains/test/runtime/evm/Cargo.toml +++ b/domains/test/runtime/evm/Cargo.toml @@ -21,51 +21,51 @@ codec = { package = "parity-scale-codec", version = "3.2.1", default-features = domain-pallet-executive = { version = "0.1.0", path = "../../../pallets/executive", default-features = false } domain-test-primitives = { version = "0.1.0", path = "../../primitives", default-features = false } domain-runtime-primitives = { version = "0.1.0", path = "../../../primitives/runtime", default-features = false } -fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-rpc = { version = "3.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-self-contained = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-base-fee = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-rpc = { version = "3.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-self-contained = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-base-fee = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-block-fees = { version = "0.1.0", path = "../../../pallets/block-fees", default-features = false } pallet-domain-id = { version = "0.1.0", path = "../../../pallets/domain-id", default-features = false } -pallet-ethereum = { default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm = { version = "6.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-chain-id = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +pallet-ethereum = { default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm = { version = "6.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-chain-id = { version = "1.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-evm-nonce-tracker = { version = "0.1.0", path = "../../../pallets/evm_nonce_tracker", default-features = false } -pallet-evm-precompile-modexp = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-precompile-sha3fips = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -pallet-evm-precompile-simple = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +pallet-evm-precompile-modexp = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-precompile-sha3fips = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +pallet-evm-precompile-simple = { version = "2.0.0-dev", default-features = false, git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } pallet-messenger = { version = "0.1.0", path = "../../../pallets/messenger", default-features = false } -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../../pallets/transporter", default-features = false } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../../../crates/sp-domains", default-features = false } -sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-inherents = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../../primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", default-features = false, path = "../../../primitives/messenger-host-functions" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../../../crates/sp-subspace-mmr" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", path = "../../../../crates/subspace-core-primitives", default-features = false } subspace-runtime-primitives = { version = "0.1.0", path = "../../../../crates/subspace-runtime-primitives", default-features = false } [build-dependencies] -substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [features] default = [ diff --git a/domains/test/service/Cargo.toml b/domains/test/service/Cargo.toml index f2fbf87347..71f4ebff28 100644 --- a/domains/test/service/Cargo.toml +++ b/domains/test/service/Cargo.toml @@ -18,39 +18,39 @@ domain-service = { version = "0.1.0", path = "../../service" } domain-test-primitives = { version = "0.1.0", path = "../primitives" } domain-runtime-primitives = { version = "0.1.0", path = "../../primitives/runtime", default-features = false } evm-domain-test-runtime = { version = "0.1.0", path = "../runtime/evm" } -fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } -fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92", features = ['default'] } -frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +fp-account = { version = "1.0.0-dev", default-features = false, features = ["serde"], git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } +fp-rpc = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641", features = ['default'] } +frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } rand = "0.8.5" -pallet-transaction-payment = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-domains = { version = "0.1.0", path = "../../../crates/sc-domains" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } serde = { version = "1.0.199", features = ["derive"] } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-arithmetic = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-arithmetic = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../../../crates/sp-consensus-subspace" } sp-domains = { version = "0.1.0", path = "../../../crates/sp-domains" } -sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../../domains/primitives/messenger" } -sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-offchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-session = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-runtime-primitives = { version = "0.1.0", path = "../../../crates/subspace-runtime-primitives" } subspace-test-client = { version = "0.1.0", path = "../../../test/subspace-test-client" } subspace-test-service = { version = "0.1.0", path = "../../../test/subspace-test-service" } -substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-test-client = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-test-client = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } tokio = { version = "1.37.0", features = ["macros"] } tracing = "0.1.40" diff --git a/orml/vesting/Cargo.toml b/orml/vesting/Cargo.toml index 0293c7063b..b8d39cd98e 100644 --- a/orml/vesting/Cargo.toml +++ b/orml/vesting/Cargo.toml @@ -12,15 +12,15 @@ parity-scale-codec = { version = "3.6.9", default-features = false, features = [ scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } serde = { version = "1.0.199", optional = true } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-io = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [dev-dependencies] -pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] default = ["std"] diff --git a/test/subspace-test-client/Cargo.toml b/test/subspace-test-client/Cargo.toml index ccba96f045..2513565d5b 100644 --- a/test/subspace-test-client/Cargo.toml +++ b/test/subspace-test-client/Cargo.toml @@ -18,19 +18,19 @@ targets = ["x86_64-unknown-linux-gnu"] codec = { package = "parity-scale-codec", version = "3.6.5", features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", path = "../../domains/primitives/runtime" } evm-domain-test-runtime = { version = "0.1.0", path = "../../domains/test/runtime/evm" } -fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "f1039d3b588b2524a3fc29726435077f5c87ce92" } +fp-evm = { version = "3.0.0-dev", git = "https://github.com/subspace/frontier", rev = "0b4f22c3343a7a21783c1e2f0d0e21dfbf66b641" } futures = "0.3.29" schnorrkel = "0.11.4" -sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-chain-spec = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-consensus-subspace = { version = "0.1.0", path = "../../crates/sc-consensus-subspace" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } serde_json = "1.0.116" -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../../crates/sp-consensus-subspace" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../crates/sp-domains" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-archiving = { path = "../../crates/subspace-archiving" } subspace-core-primitives = { path = "../../crates/subspace-core-primitives" } subspace-erasure-coding = { path = "../../crates/subspace-erasure-coding" } diff --git a/test/subspace-test-primitives/Cargo.toml b/test/subspace-test-primitives/Cargo.toml index 248863f6ca..1a54630e9f 100644 --- a/test/subspace-test-primitives/Cargo.toml +++ b/test/subspace-test-primitives/Cargo.toml @@ -13,11 +13,11 @@ include = [ [dependencies] codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false, features = ["derive"] } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-domains = { version = "0.1.0", path = "../../crates/sp-domains", default-features = false } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../crates/sp-subspace-mmr" } subspace-runtime-primitives = { version = "0.1.0", path = "../../crates/subspace-runtime-primitives", default-features = false } diff --git a/test/subspace-test-runtime/Cargo.toml b/test/subspace-test-runtime/Cargo.toml index 416969eb50..bfd4f094c4 100644 --- a/test/subspace-test-runtime/Cargo.toml +++ b/test/subspace-test-runtime/Cargo.toml @@ -18,57 +18,57 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] codec = { package = "parity-scale-codec", version = "3.6.5", default-features = false, features = ["derive"] } domain-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../domains/primitives/runtime" } -frame-executive = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-executive = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-support = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +frame-system = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } orml-vesting = { version = "0.9.1", default-features = false, path = "../../orml/vesting" } -pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-balances = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-domains = { version = "0.1.0", default-features = false, path = "../../crates/pallet-domains" } pallet-messenger = { version = "0.1.0", path = "../../domains/pallets/messenger", default-features = false } -pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-mmr = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-offences-subspace = { version = "0.1.0", default-features = false, path = "../../crates/pallet-offences-subspace" } pallet-rewards = { version = "0.1.0", default-features = false, path = "../../crates/pallet-rewards" } pallet-runtime-configs = { version = "0.1.0", default-features = false, path = "../../crates/pallet-runtime-configs" } pallet-subspace = { version = "0.1.0", default-features = false, features = ["serde"], path = "../../crates/pallet-subspace" } pallet-subspace-mmr = { version = "0.1.0", default-features = false, path = "../../crates/pallet-subspace-mmr" } -pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-sudo = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-timestamp = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transaction-fees = { version = "0.1.0", default-features = false, path = "../../crates/pallet-transaction-fees" } -pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } pallet-transporter = { version = "0.1.0", path = "../../domains/pallets/transporter", default-features = false } -pallet-utility = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-utility = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } scale-info = { version = "2.11.2", default-features = false, features = ["derive"] } -sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", default-features = false, path = "../../crates/sp-consensus-subspace" } -sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-core = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", default-features = false, path = "../../crates/sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", default-features = false, path = "../../crates/sp-domains-fraud-proof" } -sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } +sp-genesis-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } sp-messenger = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", default-features = false, path = "../../domains/primitives/messenger-host-functions" } -sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-objects = { version = "0.1.0", default-features = false, path = "../../crates/sp-objects" } -sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-offchain = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-session = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-std = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { default-features = false, path = "../../crates/sp-subspace-mmr" } -sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-transaction-pool = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-version = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } static_assertions = "1.1.0" subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../../crates/subspace-core-primitives" } subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../../crates/subspace-runtime-primitives" } subspace-test-primitives = { version = "0.1.0", default-features = false, path = "../subspace-test-primitives" } # Used for the node template's RPCs -frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-system-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +pallet-transaction-payment-rpc-runtime-api = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [build-dependencies] -substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", optional = true } +substrate-wasm-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", optional = true } [features] default = ["std"] diff --git a/test/subspace-test-service/Cargo.toml b/test/subspace-test-service/Cargo.toml index eaad1948a1..6884f2ec85 100644 --- a/test/subspace-test-service/Cargo.toml +++ b/test/subspace-test-service/Cargo.toml @@ -20,57 +20,57 @@ cross-domain-message-gossip = { version = "0.1.0", path = "../../domains/client/ codec = { package = "parity-scale-codec", version = "3.2.1", features = ["derive"] } domain-client-message-relayer = { version = "0.1.0", path = "../../domains/client/relayer" } domain-runtime-primitives = { version = "0.1.0", path = "../../domains/primitives/runtime" } -frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +frame-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } futures = "0.3.29" jsonrpsee = { version = "0.22.5", features = ["server"] } -pallet-transaction-payment = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -mmr-gadget = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +pallet-transaction-payment = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +mmr-gadget = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } rand = "0.8.5" pallet-domains = { version = "0.1.0", path = "../../crates/pallet-domains" } parking_lot = "0.12.2" -sc-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-block-builder = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-client-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sc-domains = { version = "0.1.0", path = "../../crates/sc-domains" } -sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d", default-features = false } -sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sc-executor = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-network-sync = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-service = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee", default-features = false } +sc-tracing = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-transaction-pool-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sc-utils = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-api = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-application-crypto = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-blockchain = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-core = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-consensus = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-consensus-subspace = { version = "0.1.0", path = "../../crates/sp-consensus-subspace" } -sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-consensus-slots = { default-features = false, git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-domains = { version = "0.1.0", path = "../../crates/sp-domains" } sp-domains-fraud-proof = { version = "0.1.0", path = "../../crates/sp-domains-fraud-proof" } -sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-externalities = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-messenger = { version = "0.1.0", path = "../../domains/primitives/messenger" } sp-messenger-host-functions = { version = "0.1.0", path = "../../domains/primitives/messenger-host-functions" } -sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-mmr-primitives = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } sp-subspace-mmr = { version = "0.1.0", path = "../../crates/sp-subspace-mmr" } -sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-timestamp = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-inherents = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +sp-runtime = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } subspace-core-primitives = { version = "0.1.0", default-features = false, path = "../../crates/subspace-core-primitives" } subspace-runtime-primitives = { path = "../../crates/subspace-runtime-primitives" } subspace-service = { path = "../../crates/subspace-service" } subspace-test-client = { path = "../subspace-test-client" } subspace-test-primitives = { version = "0.1.0", path = "../subspace-test-primitives" } subspace-test-runtime = { version = "0.1.0", path = "../subspace-test-runtime" } -substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } -substrate-test-client = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +substrate-frame-rpc-system = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } +substrate-test-client = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } tokio = "1.37.0" tracing = "0.1.40" [dev-dependencies] -sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "808269708cf5375526755797e8f9a9986016727d" } +sp-keyring = { git = "https://github.com/subspace/polkadot-sdk", rev = "9b8cdb87de8f1c0e6b48c468b6196d1d99eeabee" } [features] do-not-enforce-cost-of-storage = [ From f9d2a4e7786e5021ae8c17d4df998cc3b27d817c Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Sat, 18 May 2024 01:16:53 +0300 Subject: [PATCH 10/15] Find the actual first matching element when generating PoS proofs or finding quality --- .../src/chiapos/tables.rs | 24 +++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/crates/subspace-proof-of-space/src/chiapos/tables.rs b/crates/subspace-proof-of-space/src/chiapos/tables.rs index 2980ca985f..e8109373f6 100644 --- a/crates/subspace-proof-of-space/src/chiapos/tables.rs +++ b/crates/subspace-proof-of-space/src/chiapos/tables.rs @@ -124,10 +124,20 @@ where .try_into() .expect("Challenge is known to statically have enough bytes; qed"), ) >> (u32::BITS as usize - usize::from(K)); - let first_matching_element = ys + let mut first_matching_element = ys .binary_search_by(|&y| y.first_k_bits::().cmp(&first_k_challenge_bits)) .unwrap_or_else(|insert| insert); + // We only compare first K bits above, which is why `binary_search_by` is not guaranteed to + // find the very first match in case there are multiple + for index in (0..first_matching_element).rev() { + if ys[index].first_k_bits::() == first_k_challenge_bits { + first_matching_element = index; + } else { + break; + } + } + // Iterate just over elements that are matching `first_k_challenge_bits` prefix ys[first_matching_element..] .iter() @@ -197,10 +207,20 @@ where .try_into() .expect("Challenge is known to statically have enough bytes; qed"), ) >> (u32::BITS as usize - usize::from(K)); - let first_matching_element = ys + let mut first_matching_element = ys .binary_search_by(|&y| y.first_k_bits::().cmp(&first_k_challenge_bits)) .unwrap_or_else(|insert| insert); + // We only compare first K bits above, which is why `binary_search_by` is not guaranteed to + // find the very first match in case there are multiple + for index in (0..first_matching_element).rev() { + if ys[index].first_k_bits::() == first_k_challenge_bits { + first_matching_element = index; + } else { + break; + } + } + // Iterate just over elements that are matching `first_k_challenge_bits` prefix ys[first_matching_element..] .iter() From 504e17a1e7182c1e08139da8f2629803afb9b218 Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Sat, 18 May 2024 03:05:23 +0300 Subject: [PATCH 11/15] Store left tables in a flat vector instead of multidimensional --- .../src/chiapos/table.rs | 63 ++++++++++++------- 1 file changed, 39 insertions(+), 24 deletions(-) diff --git a/crates/subspace-proof-of-space/src/chiapos/table.rs b/crates/subspace-proof-of-space/src/chiapos/table.rs index 93362c80de..c37c1760b4 100644 --- a/crates/subspace-proof-of-space/src/chiapos/table.rs +++ b/crates/subspace-proof-of-space/src/chiapos/table.rs @@ -91,27 +91,30 @@ pub(super) fn partial_y( (output, skip_bits) } -fn calculate_left_targets() -> Vec>> { +#[derive(Debug, Clone)] +struct LeftTargets { + left_targets: Vec, +} + +fn calculate_left_targets() -> LeftTargets { + let mut left_targets = Vec::with_capacity(2 * usize::from(PARAM_BC) * usize::from(PARAM_M)); + let param_b = u32::from(PARAM_B); let param_c = u32::from(PARAM_C); - (0..=1u32) - .map(|parity| { - (0..u32::from(PARAM_BC)) - .map(|r| { - let c = r / param_c; - - (0..u32::from(PARAM_M)) - .map(|m| { - let target = ((c + m) % param_b) * param_c - + (((2 * m + parity) * (2 * m + parity) + r) % param_c); - Position::from(target) - }) - .collect() - }) - .collect() - }) - .collect() + for parity in 0..=1u32 { + for r in 0..u32::from(PARAM_BC) { + let c = r / param_c; + + for m in 0..u32::from(PARAM_M) { + let target = ((c + m) % param_b) * param_c + + (((2 * m + parity) * (2 * m + parity) + r) % param_c); + left_targets.push(Position::from(target)); + } + } + } + + LeftTargets { left_targets } } fn calculate_left_target_on_demand(parity: usize, r: usize, m: usize) -> usize { @@ -128,7 +131,7 @@ fn calculate_left_target_on_demand(parity: usize, r: usize, m: usize) -> usize { pub struct TablesCache { buckets: Vec, rmap_scratch: Vec, - left_targets: Vec>>, + left_targets: LeftTargets, } impl Default for TablesCache { @@ -268,7 +271,7 @@ fn find_matches<'a>( right_bucket_ys: &'a [Y], right_bucket_start_position: Position, rmap_scratch: &'a mut Vec, - left_targets: &'a [Vec>], + left_targets: &'a LeftTargets, ) -> Option + 'a> { // Clear and set to correct size with zero values rmap_scratch.clear(); @@ -299,7 +302,16 @@ fn find_matches<'a>( // `PARAM_BC` away from the previous one in terms of divisor by `PARAM_BC` let base = base - usize::from(PARAM_BC); let parity = (usize::from(first_left_bucket_y) / usize::from(PARAM_BC)) % 2; - let left_targets = &left_targets[parity]; + let left_targets_parity = { + let (a, b) = left_targets + .left_targets + .split_at(left_targets.left_targets.len() / 2); + if parity == 0 { + a + } else { + b + } + }; Some( left_bucket_ys @@ -307,10 +319,13 @@ fn find_matches<'a>( .zip(left_bucket_start_position..) .flat_map(move |(&y, left_position)| { let r = usize::from(y) - base; - let left_targets = &left_targets[r]; + let left_targets_r = left_targets_parity + .chunks_exact(left_targets_parity.len() / usize::from(PARAM_BC)) + .nth(r) + .expect("r is valid"); (0..usize::from(PARAM_M)).flat_map(move |m| { - let r_target = left_targets[m]; + let r_target = left_targets_r[m]; let rmap_item = rmap[usize::from(r_target)]; (rmap_item.start_position..rmap_item.start_position + rmap_item.count).map( @@ -455,7 +470,7 @@ fn match_and_compute_fn<'a, const K: u8, const TABLE_NUMBER: u8, const PARENT_TA left_bucket: Bucket, right_bucket: Bucket, rmap_scratch: &'a mut Vec, - left_targets: &'a [Vec>], + left_targets: &'a LeftTargets, results_table: &mut Vec<(Y, [Position; 2], Metadata)>, ) where EvaluatableUsize<{ metadata_size_bytes(K, PARENT_TABLE_NUMBER) }>: Sized, From c3794455112dfb70997ec64f7b1420e56267fcd4 Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Sat, 18 May 2024 04:19:30 +0300 Subject: [PATCH 12/15] Improve parallel table generation performance by spreading more work across different threads --- Cargo.lock | 2 + crates/subspace-proof-of-space/Cargo.toml | 5 + .../src/chiapos/table.rs | 92 +++++++++++-------- 3 files changed, 60 insertions(+), 39 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 38b2065796..5e446c4838 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12606,10 +12606,12 @@ dependencies = [ "chacha20", "criterion", "derive_more", + "parking_lot 0.12.2", "rand", "rayon", "seq-macro", "sha2 0.10.8", + "spin 0.9.8", "subspace-chiapos", "subspace-core-primitives", ] diff --git a/crates/subspace-proof-of-space/Cargo.toml b/crates/subspace-proof-of-space/Cargo.toml index df5c4b4d1a..b6604a60c3 100644 --- a/crates/subspace-proof-of-space/Cargo.toml +++ b/crates/subspace-proof-of-space/Cargo.toml @@ -18,9 +18,12 @@ bench = false [dependencies] chacha20 = { version = "0.9.1", default-features = false } derive_more = "0.99.17" +parking_lot = { version = "0.12.2", optional = true } rayon = { version = "1.10.0", optional = true } seq-macro = "0.3.5" sha2 = { version = "0.10.7", default-features = false } +# Replacement for `parking_lot` in `no_std` environment +spin = "0.9.7" subspace-core-primitives = { version = "0.1.0", path = "../subspace-core-primitives", default-features = false } [dev-dependencies] @@ -38,6 +41,8 @@ harness = false default = ["std"] std = [ "chacha20/std", + # In no-std environment we use `spin` + "parking_lot", "sha2/std", "subspace-core-primitives/std", ] diff --git a/crates/subspace-proof-of-space/src/chiapos/table.rs b/crates/subspace-proof-of-space/src/chiapos/table.rs index c37c1760b4..aee830738e 100644 --- a/crates/subspace-proof-of-space/src/chiapos/table.rs +++ b/crates/subspace-proof-of-space/src/chiapos/table.rs @@ -18,11 +18,13 @@ use chacha20::{ChaCha8, Key, Nonce}; use core::mem; use core::simd::num::SimdUint; use core::simd::Simd; -#[cfg(any(feature = "parallel", test))] -use core::sync::atomic::{AtomicUsize, Ordering}; +#[cfg(all(feature = "std", any(feature = "parallel", test)))] +use parking_lot::Mutex; #[cfg(any(feature = "parallel", test))] use rayon::prelude::*; use seq_macro::seq; +#[cfg(all(not(feature = "std"), any(feature = "parallel", test)))] +use spin::Mutex; use subspace_core_primitives::crypto::{blake3_hash, blake3_hash_list}; pub(super) const COMPUTE_F1_SIMD_FACTOR: usize = 8; @@ -739,60 +741,72 @@ where where EvaluatableUsize<{ metadata_size_bytes(K, PARENT_TABLE_NUMBER) }>: Sized, { - let buckets = &mut cache.buckets; let left_targets = &cache.left_targets; - let mut bucket = Bucket { - bucket_index: 0, + let mut first_bucket = Bucket { + bucket_index: u32::from(last_table.ys()[0]) / u32::from(PARAM_BC), start_position: Position::ZERO, size: Position::ZERO, }; + for &y in last_table.ys() { + let bucket_index = u32::from(y) / u32::from(PARAM_BC); - let last_y = *last_table - .ys() - .last() - .expect("List of y values is never empty; qed"); - buckets.clear(); - buckets.reserve(1 + usize::from(last_y) / usize::from(PARAM_BC)); - last_table - .ys() - .iter() - .zip(Position::ZERO..) - .for_each(|(&y, position)| { - let bucket_index = u32::from(y) / u32::from(PARAM_BC); - - if bucket_index == bucket.bucket_index { - bucket.size += Position::ONE; - return; - } - - buckets.push(bucket); - - bucket = Bucket { - bucket_index, - start_position: position, - size: Position::ONE, - }; - }); - // Iteration stopped, but we did not store the last bucket yet - buckets.push(bucket); + if bucket_index == first_bucket.bucket_index { + first_bucket.size += Position::ONE; + } else { + break; + } + } - let counter = AtomicUsize::new(0); + let previous_bucket = Mutex::new(first_bucket); let t_n = rayon::broadcast(|_ctx| { let mut entries = Vec::new(); let mut rmap_scratch = Vec::new(); loop { - let offset = counter.fetch_add(1, Ordering::Relaxed); - if offset >= buckets.len() - 1 { - break; + let left_bucket; + let right_bucket; + { + let mut previous_bucket = previous_bucket.lock(); + + let right_bucket_start_position = + previous_bucket.start_position + previous_bucket.size; + let right_bucket_index = match last_table + .ys() + .get(usize::from(right_bucket_start_position)) + { + Some(&y) => u32::from(y) / u32::from(PARAM_BC), + None => { + break; + } + }; + let mut right_bucket_size = Position::ZERO; + + for &y in &last_table.ys()[usize::from(right_bucket_start_position)..] { + let bucket_index = u32::from(y) / u32::from(PARAM_BC); + + if bucket_index == right_bucket_index { + right_bucket_size += Position::ONE; + } else { + break; + } + } + + right_bucket = Bucket { + bucket_index: right_bucket_index, + start_position: right_bucket_start_position, + size: right_bucket_size, + }; + + left_bucket = *previous_bucket; + *previous_bucket = right_bucket; } match_and_compute_fn::( last_table, - buckets[offset], - buckets[offset + 1], + left_bucket, + right_bucket, &mut rmap_scratch, left_targets, &mut entries, From e36cdc91744f0d42475097fa00fbb12fba1ad6fd Mon Sep 17 00:00:00 2001 From: Nazar Mokrynskyi Date: Sat, 18 May 2024 04:24:47 +0300 Subject: [PATCH 13/15] Tiny cleanup of `calculate_left_target_on_demand` function signature for consistency --- .../subspace-proof-of-space/src/chiapos/table.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/crates/subspace-proof-of-space/src/chiapos/table.rs b/crates/subspace-proof-of-space/src/chiapos/table.rs index aee830738e..5380622123 100644 --- a/crates/subspace-proof-of-space/src/chiapos/table.rs +++ b/crates/subspace-proof-of-space/src/chiapos/table.rs @@ -119,9 +119,9 @@ fn calculate_left_targets() -> LeftTargets { LeftTargets { left_targets } } -fn calculate_left_target_on_demand(parity: usize, r: usize, m: usize) -> usize { - let param_b = usize::from(PARAM_B); - let param_c = usize::from(PARAM_C); +fn calculate_left_target_on_demand(parity: u32, r: u32, m: u32) -> u32 { + let param_b = u32::from(PARAM_B); + let param_c = u32::from(PARAM_C); let c = r / param_c; @@ -344,11 +344,11 @@ fn find_matches<'a>( /// Simplified version of [`find_matches`] for verification purposes. pub(super) fn has_match(left_y: Y, right_y: Y) -> bool { - let right_r = usize::from(right_y) % usize::from(PARAM_BC); - let parity = (usize::from(left_y) / usize::from(PARAM_BC)) % 2; - let left_r = usize::from(left_y) % usize::from(PARAM_BC); + let right_r = u32::from(right_y) % u32::from(PARAM_BC); + let parity = (u32::from(left_y) / u32::from(PARAM_BC)) % 2; + let left_r = u32::from(left_y) % u32::from(PARAM_BC); - for m in 0..usize::from(PARAM_M) { + for m in 0..u32::from(PARAM_M) { let r_target = calculate_left_target_on_demand(parity, left_r, m); if r_target == right_r { return true; From d535c4af3033f084e67a2d3cd8cd1f00d01bd632 Mon Sep 17 00:00:00 2001 From: dastansam Date: Mon, 20 May 2024 02:43:52 +0200 Subject: [PATCH 14/15] Remove `Clone` from `NodeClient` super trait --- crates/subspace-farmer/src/node_client.rs | 2 +- crates/subspace-farmer/src/single_disk_farm.rs | 12 +++++++++--- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/crates/subspace-farmer/src/node_client.rs b/crates/subspace-farmer/src/node_client.rs index 07cb3cb6ce..c0a1787c05 100644 --- a/crates/subspace-farmer/src/node_client.rs +++ b/crates/subspace-farmer/src/node_client.rs @@ -14,7 +14,7 @@ pub type Error = Box; /// Abstraction of the Node Client #[async_trait] -pub trait NodeClient: Clone + fmt::Debug + Send + Sync + 'static { +pub trait NodeClient: fmt::Debug + Send + Sync + 'static { /// Get farmer app info async fn farmer_app_info(&self) -> Result; diff --git a/crates/subspace-farmer/src/single_disk_farm.rs b/crates/subspace-farmer/src/single_disk_farm.rs index fb5bfdd332..ae85468848 100644 --- a/crates/subspace-farmer/src/single_disk_farm.rs +++ b/crates/subspace-farmer/src/single_disk_farm.rs @@ -257,7 +257,10 @@ impl PlotMetadataHeader { } /// Options used to open single disk farm -pub struct SingleDiskFarmOptions { +pub struct SingleDiskFarmOptions +where + NC: Clone, +{ /// Path to directory where farm is stored. pub directory: PathBuf, /// Information necessary for farmer application @@ -669,7 +672,7 @@ impl SingleDiskFarm { farm_index: usize, ) -> Result where - NC: NodeClient, + NC: NodeClient + Clone, P: Plotter + Send + 'static, PosTable: Table, { @@ -1056,7 +1059,10 @@ impl SingleDiskFarm { fn init( options: &SingleDiskFarmOptions, - ) -> Result { + ) -> Result + where + NC: Clone, + { let SingleDiskFarmOptions { directory, farmer_app_info, From a4fc254d92eecc6feefe1f5758272360bc0d2645 Mon Sep 17 00:00:00 2001 From: linning Date: Tue, 21 May 2024 18:11:59 +0800 Subject: [PATCH 15/15] Remove the unused InvalidBundleType::InvalidXDM Signed-off-by: linning --- crates/sp-domains-fraud-proof/src/verification.rs | 1 - crates/sp-domains/src/lib.rs | 10 ++++++---- .../domain-operator/src/domain_block_processor.rs | 2 +- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/crates/sp-domains-fraud-proof/src/verification.rs b/crates/sp-domains-fraud-proof/src/verification.rs index 307a789825..fd7e1c35f9 100644 --- a/crates/sp-domains-fraud-proof/src/verification.rs +++ b/crates/sp-domains-fraud-proof/src/verification.rs @@ -658,6 +658,5 @@ where } Ok(()) } - InvalidBundleType::InvalidXDM(_) => Err(VerificationError::InvalidProof), } } diff --git a/crates/sp-domains/src/lib.rs b/crates/sp-domains/src/lib.rs index 8dcc6656af..d39b8165a2 100644 --- a/crates/sp-domains/src/lib.rs +++ b/crates/sp-domains/src/lib.rs @@ -1046,17 +1046,21 @@ pub enum ReceiptValidity { /// Bundle invalidity type /// /// Each type contains the index of the first invalid extrinsic within the bundle +// TODO: `#[codec(index = 3)]` is reserved for the reomved `InvalidBundleType::InvalidXDM` +// we can only reuse index 3 in the next network #[derive(Debug, Decode, Encode, TypeInfo, Clone, PartialEq, Eq)] pub enum InvalidBundleType { /// Failed to decode the opaque extrinsic. + #[codec(index = 0)] UndecodableTx(u32), /// Transaction is out of the tx range. + #[codec(index = 1)] OutOfRangeTx(u32), /// Transaction is illegal (unable to pay the fee, etc). + #[codec(index = 2)] IllegalTx(u32), - /// Transaction is an invalid XDM - InvalidXDM(u32), /// Transaction is an inherent extrinsic. + #[codec(index = 4)] InherentExtrinsic(u32), } @@ -1069,7 +1073,6 @@ impl InvalidBundleType { Self::UndecodableTx(_) => 1, Self::OutOfRangeTx(_) => 2, Self::InherentExtrinsic(_) => 3, - Self::InvalidXDM(_) => 4, Self::IllegalTx(_) => 5, } } @@ -1079,7 +1082,6 @@ impl InvalidBundleType { Self::UndecodableTx(i) => *i, Self::OutOfRangeTx(i) => *i, Self::IllegalTx(i) => *i, - Self::InvalidXDM(i) => *i, Self::InherentExtrinsic(i) => *i, } } diff --git a/domains/client/domain-operator/src/domain_block_processor.rs b/domains/client/domain-operator/src/domain_block_processor.rs index 798f5374da..6fe23b4209 100644 --- a/domains/client/domain-operator/src/domain_block_processor.rs +++ b/domains/client/domain-operator/src/domain_block_processor.rs @@ -654,7 +654,7 @@ where Ordering::Greater => BundleMismatchType::FalseInvalid(external_invalid_type), // If both the `local_invalid_type` and `external_invalid_type` point to the same extrinsic, // the extrinsic can be considered as invalid due to multiple `invalid_type` (i.e. an extrinsic - // can be `OutOfRangeTx` and `InvalidXDM` at the same time) thus use the checking order and + // can be `OutOfRangeTx` and `IllegalTx` at the same time) thus use the checking order and // consider the first check as the mismatch. Ordering::Equal => match local_invalid_type .checking_order()