Merge branch 'main' into subnet_hyperparameters_fix

.github/workflows/check-rust.yml

@@ -48,7 +48,7 @@ env:
 jobs:
   check:
     name: Tests targeting ${{ matrix.rust-target }} for OS ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
+    runs-on: SubtensorCI
 
     ##
     # Define multiple targets for builds and tests
@@ -86,8 +86,8 @@ jobs:
 
       - name: Install dependencies
         run: |
-          sudo apt update &&
-          sudo apt install -y git clang curl libssl-dev llvm libudev-dev protobuf-compiler
+          sudo apt-get update &&
+          sudo apt-get install -y git clang curl libssl-dev llvm libudev-dev protobuf-compiler
 
       - name: Install Rust ${{ matrix.rust-branch }}
         uses: actions-rs/[email protected]
@@ -100,11 +100,13 @@ jobs:
         with:
           key: ${{ matrix.os }}-${{ env.RUST_BIN_DIR }}
 
+      - name: cargo fmt
+        run: cargo fmt --check
+
       ## TODO: maybe use `if` conditions in tests to target `--package <name>`
-      - name: Run tests
+      - name: cargo test
         # timeout-minutes: 30
-        run: |
-          cargo test --tests
+        run: cargo test --workspace
 
       - name: Run benchmarks
         # timeout-minutes: 30
@@ -114,6 +116,5 @@ jobs:
 
       - name: Build executable
         # timeout-minutes: 30
-        run: |
-          cargo build --release
+        run: cargo build --release
 

node/Cargo.toml

@@ -18,7 +18,7 @@ name = "node-subtensor"
 
 [dependencies]
 clap = { version = "4.0.9", features = ["derive"] }
-futures = { version = "0.3.21", features = ["thread-pool"]}
+futures = { version = "0.3.21", features = ["thread-pool"] }
 serde = { version = "1.0.145", features = ["derive"] }
 
 # Storage import
@@ -47,7 +47,7 @@ sp-inherents = { version = "4.0.0-dev", git = "https://github.com/paritytech/sub
 sp-keyring = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.39" }
 frame-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.39" }
 pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.39" }
-pallet-commitments = {path="../pallets/commitments"}
+pallet-commitments = { path = "../pallets/commitments" }
 
 # These dependencies are used for the subtensor's RPCs
 jsonrpsee = { version = "0.16.2", features = ["server"] }
@@ -87,4 +87,7 @@ pow-faucet = []
 
 # Enable features that allow the runtime to be tried and debugged. Name might be subject to change
 # in the near future.
-try-runtime = ["node-subtensor-runtime/try-runtime", "try-runtime-cli/try-runtime"]
+try-runtime = [
+	"node-subtensor-runtime/try-runtime",
+	"try-runtime-cli/try-runtime",
+]

node/src/benchmarking.rs

@@ -5,165 +5,173 @@
 use crate::service::FullClient;
 
 use node_subtensor_runtime as runtime;
+use node_subtensor_runtime::pallet_subtensor;
 use runtime::{AccountId, Balance, BalancesCall, SystemCall};
 use sc_cli::Result;
 use sc_client_api::BlockBackend;
 use sp_core::{Encode, Pair};
 use sp_inherents::{InherentData, InherentDataProvider};
 use sp_keyring::Sr25519Keyring;
 use sp_runtime::{OpaqueExtrinsic, SaturatedConversion};
-use node_subtensor_runtime::pallet_subtensor;
 
 use std::{sync::Arc, time::Duration};
 
 // Generates extrinsics for the `benchmark overhead` command.
 //
 // Note: Should only be used for benchmarking.
 pub struct RemarkBuilder {
-	client: Arc<FullClient>,
+    client: Arc<FullClient>,
 }
 
 impl RemarkBuilder {
-	// Creates a new [`Self`] from the given client.
-	pub fn new(client: Arc<FullClient>) -> Self {
-		Self { client }
-	}
+    // Creates a new [`Self`] from the given client.
+    pub fn new(client: Arc<FullClient>) -> Self {
+        Self { client }
+    }
 }
 
 impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder {
-	fn pallet(&self) -> &str {
-		"system"
-	}
-
-	fn extrinsic(&self) -> &str {
-		"remark"
-	}
-
-	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
-		let acc = Sr25519Keyring::Bob.pair();
-		let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
-			self.client.as_ref(),
-			acc,
-			SystemCall::remark { remark: vec![] }.into(),
-			nonce,
-		)
-		.into();
-
-		Ok(extrinsic)
-	}
+    fn pallet(&self) -> &str {
+        "system"
+    }
+
+    fn extrinsic(&self) -> &str {
+        "remark"
+    }
+
+    fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+        let acc = Sr25519Keyring::Bob.pair();
+        let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
+            self.client.as_ref(),
+            acc,
+            SystemCall::remark { remark: vec![] }.into(),
+            nonce,
+        )
+        .into();
+
+        Ok(extrinsic)
+    }
 }
 
 // Generates `Balances::TransferKeepAlive` extrinsics for the benchmarks.
 //
 // Note: Should only be used for benchmarking.
 pub struct TransferKeepAliveBuilder {
-	client: Arc<FullClient>,
-	dest: AccountId,
-	value: Balance,
+    client: Arc<FullClient>,
+    dest: AccountId,
+    value: Balance,
 }
 
 impl TransferKeepAliveBuilder {
-	// Creates a new [`Self`] from the given client.
-	pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
-		Self { client, dest, value }
-	}
+    // Creates a new [`Self`] from the given client.
+    pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
+        Self {
+            client,
+            dest,
+            value,
+        }
+    }
 }
 
 impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
-	fn pallet(&self) -> &str {
-		"balances"
-	}
-
-	fn extrinsic(&self) -> &str {
-		"transfer_keep_alive"
-	}
-
-	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
-		let acc = Sr25519Keyring::Bob.pair();
-		let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
-			self.client.as_ref(),
-			acc,
-			BalancesCall::transfer_keep_alive {
-				dest: self.dest.clone().into(),
-				value: self.value.into(),
-			}
-			.into(),
-			nonce,
-		)
-		.into();
-
-		Ok(extrinsic)
-	}
+    fn pallet(&self) -> &str {
+        "balances"
+    }
+
+    fn extrinsic(&self) -> &str {
+        "transfer_keep_alive"
+    }
+
+    fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+        let acc = Sr25519Keyring::Bob.pair();
+        let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
+            self.client.as_ref(),
+            acc,
+            BalancesCall::transfer_keep_alive {
+                dest: self.dest.clone().into(),
+                value: self.value.into(),
+            }
+            .into(),
+            nonce,
+        )
+        .into();
+
+        Ok(extrinsic)
+    }
 }
 
 // Create a transaction using the given `call`.
 //
 // Note: Should only be used for benchmarking.
 pub fn create_benchmark_extrinsic(
-	client: &FullClient,
-	sender: sp_core::sr25519::Pair,
-	call: runtime::RuntimeCall,
-	nonce: u32,
+    client: &FullClient,
+    sender: sp_core::sr25519::Pair,
+    call: runtime::RuntimeCall,
+    nonce: u32,
 ) -> runtime::UncheckedExtrinsic {
-	let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
-	let best_hash = client.chain_info().best_hash;
-	let best_block = client.chain_info().best_number;
-
-	let period = runtime::BlockHashCount::get()
-		.checked_next_power_of_two()
-		.map(|c| c / 2)
-		.unwrap_or(2) as u64;
-	let extra: runtime::SignedExtra = (
-		frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
-		frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
-		frame_system::CheckTxVersion::<runtime::Runtime>::new(),
-		frame_system::CheckGenesis::<runtime::Runtime>::new(),
-		frame_system::CheckEra::<runtime::Runtime>::from(sp_runtime::generic::Era::mortal(
-			period,
-			best_block.saturated_into(),
-		)),
-		frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
-		frame_system::CheckWeight::<runtime::Runtime>::new(),
-		pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-		pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new(),
-		pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new()
-	);
-
-	let raw_payload = runtime::SignedPayload::from_raw(
-		call.clone(),
-		extra.clone(),
-		(
-			(),
-			runtime::VERSION.spec_version,
-			runtime::VERSION.transaction_version,
-			genesis_hash,
-			best_hash,
-			(),
-			(),
-			(),
-			(),
-			()
-		),
-	);
-	let signature = raw_payload.using_encoded(|e| sender.sign(e));
-
-	runtime::UncheckedExtrinsic::new_signed(
-		call.clone(),
-		sp_runtime::AccountId32::from(sender.public()).into(),
-		runtime::Signature::Sr25519(signature.clone()),
-		extra.clone(),
-	)
+    let genesis_hash = client
+        .block_hash(0)
+        .ok()
+        .flatten()
+        .expect("Genesis block exists; qed");
+    let best_hash = client.chain_info().best_hash;
+    let best_block = client.chain_info().best_number;
+
+    let period = runtime::BlockHashCount::get()
+        .checked_next_power_of_two()
+        .map(|c| c / 2)
+        .unwrap_or(2) as u64;
+    let extra: runtime::SignedExtra = (
+        frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
+        frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
+        frame_system::CheckTxVersion::<runtime::Runtime>::new(),
+        frame_system::CheckGenesis::<runtime::Runtime>::new(),
+        frame_system::CheckEra::<runtime::Runtime>::from(sp_runtime::generic::Era::mortal(
+            period,
+            best_block.saturated_into(),
+        )),
+        frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
+        frame_system::CheckWeight::<runtime::Runtime>::new(),
+        pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+        pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new(),
+        pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new(),
+    );
+
+    let raw_payload = runtime::SignedPayload::from_raw(
+        call.clone(),
+        extra.clone(),
+        (
+            (),
+            runtime::VERSION.spec_version,
+            runtime::VERSION.transaction_version,
+            genesis_hash,
+            best_hash,
+            (),
+            (),
+            (),
+            (),
+            (),
+        ),
+    );
+    let signature = raw_payload.using_encoded(|e| sender.sign(e));
+
+    runtime::UncheckedExtrinsic::new_signed(
+        call.clone(),
+        sp_runtime::AccountId32::from(sender.public()).into(),
+        runtime::Signature::Sr25519(signature.clone()),
+        extra.clone(),
+    )
 }
 
 // Generates inherent data for the `benchmark overhead` command.
 //
 // Note: Should only be used for benchmarking.
 pub fn inherent_benchmark_data() -> Result<InherentData> {
-	let mut inherent_data = InherentData::new();
-	let d = Duration::from_millis(0);
-	let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
+    let mut inherent_data = InherentData::new();
+    let d = Duration::from_millis(0);
+    let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
 
-	futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
-		.map_err(|e| format!("creating inherent data: {:?}", e))?;
-	Ok(inherent_data)
+    futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
+        .map_err(|e| format!("creating inherent data: {:?}", e))?;
+    Ok(inherent_data)
 }