Merge pull request #1988 from opentensor/testnet

mainnet deploy 8/27/2025

Author: sam0x17

Cargo.lock

@@ -52,6 +52,10 @@ COPY --from=builder /build/snapshot.json /snapshot.json
 COPY --from=builder /build/scripts/localnet.sh scripts/localnet.sh
 RUN chmod +x /scripts/localnet.sh
 
+# Copy WebAssembly artifacts
+COPY --from=builder /build/target/fast-runtime/release/wbuild/node-subtensor-runtime/node_subtensor_runtime.compact.compressed.wasm target/fast-runtime/release/node_subtensor_runtime.compact.compressed.wasm
+COPY --from=builder /build/target/non-fast-runtime/release/wbuild/node-subtensor-runtime/node_subtensor_runtime.compact.compressed.wasm target/non-fast-runtime/release/node_subtensor_runtime.compact.compressed.wasm
+
 ## Ubdate certificates
 RUN apt-get update && apt-get install -y ca-certificates
 

Dockerfile-localnet

@@ -0,0 +1,36 @@
+## Transaction Priority
+
+### Overview
+In Subtensor, transaction priority is determined by custom transaction extensions, which alter or override the default Substrate SDK behavior. Extensions affecting transaction priority are:
+
+- **`ChargeTransactionPaymentWrapper`** (wraps `ChargeTransactionPayment`)
+- **`DrandPriority`**
+
+Substrate SDK combines priorities from all transaction extensions using addition. 
+
+---
+
+### 1. `ChargeTransactionPaymentWrapper`
+In the Substrate SDK, `ChargeTransactionPayment` normally calculates transaction priority based on:
+- **Tip** — an extra fee paid by the sender.
+- **Weight** — computational complexity of the transaction.
+- **Dispatch class** — category of the transaction (`Normal`, `Operational`, `Mandatory`).
+
+However, in Subtensor, `ChargeTransactionPaymentWrapper` **overrides** this logic.  
+It replaces the dynamic calculation with a **flat priority scale** based only on the dispatch class.
+
+#### Current priority values:
+| Dispatch Class      | Priority Value    | Notes                                                        |
+|---------------------|-------------------|--------------------------------------------------------------|
+| `Normal`            | `1`               | Standard transactions                                        |
+| `Mandatory`         | `1`               | Rarely used, same as `Normal`                                |
+| `Operational`       | `10_000_000_000`  | Reserved for critical system extrinsics (e.g.: `sudo` calls) |
+
+
+---
+
+### 2. `DrandPriority`
+
+Special pallet_drand priority: 10_000 for `write_pulse` extrinsic.
+
+---

docs/transaction-priority.md

@@ -168,30 +168,31 @@ export async function waitForTransactionCompletion(api: TypedApi<typeof devnet>,
     // })
 }
 
+
 export async function getTransactionWatchPromise(tx: Transaction<{}, string, string, void>, signer: PolkadotSigner,) {
     return new Promise<void>((resolve, reject) => {
         // store the txHash, then use it in timeout. easier to know which tx is not finalized in time
         let txHash = ""
         const subscription = tx.signSubmitAndWatch(signer).subscribe({
             next(value) {
-                console.log("Event:", value);
                 txHash = value.txHash
 
                 // TODO investigate why finalized not for each extrinsic
                 if (value.type === "finalized") {
                     console.log("Transaction is finalized in block:", value.txHash);
                     subscription.unsubscribe();
+                    clearTimeout(timeoutId);
                     if (!value.ok) {
                         console.log("Transaction threw an error:", value.dispatchError)
                     }
                     // Resolve the promise when the transaction is finalized
                     resolve();
-
                 }
             },
             error(err) {
                 console.error("Transaction failed:", err);
                 subscription.unsubscribe();
+                clearTimeout(timeoutId);
                 // Reject the promise in case of an error
                 reject(err);
 
@@ -201,7 +202,7 @@ export async function getTransactionWatchPromise(tx: Transaction<{}, string, str
             }
         });
 
-        setTimeout(() => {
+        const timeoutId = setTimeout(() => {
             subscription.unsubscribe();
             console.log('unsubscribed because of timeout for tx {}', txHash);
             reject()

evm-tests/src/substrate.ts

@@ -32,7 +32,7 @@ export async function addNewSubnetwork(api: TypedApi<typeof devnet>, hotkey: Key
 // force set balance for a ss58 address
 export async function forceSetBalanceToSs58Address(api: TypedApi<typeof devnet>, ss58Address: string) {
     const alice = getAliceSigner()
-    const balance = tao(1e8)
+    const balance = tao(1e10)
     const internalCall = api.tx.Balances.force_set_balance({ who: MultiAddress.Id(ss58Address), new_free: balance })
     const tx = api.tx.Sudo.sudo({ call: internalCall.decodedCall })
 

evm-tests/src/subtensor.ts

@@ -11,9 +11,9 @@ import { generateRandomEthersWallet } from "../src/utils"
 import { convertH160ToPublicKey } from "../src/address-utils"
 import { blake2AsU8a } from "@polkadot/util-crypto"
 import {
-    forceSetBalanceToEthAddress, forceSetBalanceToSs58Address, addNewSubnetwork, setCommitRevealWeightsEnabled, setWeightsSetRateLimit, burnedRegister,
+    forceSetBalanceToEthAddress, forceSetBalanceToSs58Address, addNewSubnetwork, setWeightsSetRateLimit, burnedRegister,
     setTempo, setCommitRevealWeightsInterval,
-    startCall
+    startCall,
 } from "../src/subtensor"
 
 // hardcode some values for reveal hash
@@ -52,6 +52,7 @@ describe("Test neuron precompile reveal weights", () => {
     const coldkey = getRandomSubstrateKeypair();
 
     let api: TypedApi<typeof devnet>
+    let commitEpoch: number;
 
     // sudo account alice as signer
     let alice: PolkadotSigner;
@@ -65,13 +66,11 @@ describe("Test neuron precompile reveal weights", () => {
         await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(coldkey.publicKey))
         await forceSetBalanceToEthAddress(api, wallet.address)
         let netuid = await addNewSubnetwork(api, hotkey, coldkey)
+        // await disableCommitRevealWeights(api, netuid)
         await startCall(api, netuid, coldkey)
 
         console.log("test the case on subnet ", netuid)
 
-        // enable commit reveal feature
-        await setCommitRevealWeightsEnabled(api, netuid, true)
-        // set it as 0, we can set the weight anytime
         await setWeightsSetRateLimit(api, netuid, BigInt(0))
 
         const ss58Address = convertH160ToSS58(wallet.address)
@@ -90,8 +89,15 @@ describe("Test neuron precompile reveal weights", () => {
         const subnetId = totalNetworks - 1
         const commitHash = getCommitHash(subnetId, wallet.address)
         const contract = new ethers.Contract(INEURON_ADDRESS, INeuronABI, wallet);
-        const tx = await contract.commitWeights(subnetId, commitHash)
-        await tx.wait()
+        try {
+            const tx = await contract.commitWeights(subnetId, commitHash)
+            await tx.wait()
+        } catch (e) {
+            console.log("commitWeights failed", e)
+        }
+
+        const commitBlock = await api.query.System.Number.getValue()
+        commitEpoch = Math.trunc(commitBlock / (100 + 1))
 
         const ss58Address = convertH160ToSS58(wallet.address)
 
@@ -108,9 +114,19 @@ describe("Test neuron precompile reveal weights", () => {
         const netuid = totalNetworks - 1
         const contract = new ethers.Contract(INEURON_ADDRESS, INeuronABI, wallet);
         // set tempo or epoch large, then enough time to reveal weight
-        await setTempo(api, netuid, 60000)
-        // set interval epoch as 0, we can reveal at the same epoch
-        await setCommitRevealWeightsInterval(api, netuid, BigInt(0))
+        await setTempo(api, netuid, 100)
+        // set interval epoch as 1, it is the minimum value now
+        await setCommitRevealWeightsInterval(api, netuid, BigInt(1))
+
+        while (true) {
+            const currentBlock = await api.query.System.Number.getValue()
+            const currentEpoch = Math.trunc(currentBlock / (100 + 1))
+            // wait for one second for fast blocks
+            if (currentEpoch > commitEpoch) {
+                break
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000))
+        }
 
         const tx = await contract.revealWeights(
             netuid,
@@ -120,6 +136,7 @@ describe("Test neuron precompile reveal weights", () => {
             version_key
         );
         await tx.wait()
+
         const ss58Address = convertH160ToSS58(wallet.address)
 
         // check the weight commit is removed after reveal successfully

evm-tests/test/uid.precompile.lookup.test.ts renamed to evm-tests/test/evm-uid.precompile.lookup.test.ts

@@ -5,8 +5,8 @@
 use crate::client::FullClient;
 
 use node_subtensor_runtime as runtime;
-use node_subtensor_runtime::check_nonce;
 use node_subtensor_runtime::pallet_subtensor;
+use node_subtensor_runtime::{check_nonce, transaction_payment_wrapper};
 use runtime::{BalancesCall, SystemCall};
 use sc_cli::Result;
 use sc_client_api::BlockBackend;
@@ -123,21 +123,27 @@ pub fn create_benchmark_extrinsic(
         .checked_next_power_of_two()
         .map(|c| c / 2)
         .unwrap_or(2) as u64;
-    let extra: runtime::TransactionExtensions = (
-        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(),
-        )),
-        check_nonce::CheckNonce::<runtime::Runtime>::from(nonce),
-        frame_system::CheckWeight::<runtime::Runtime>::new(),
-        pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-        pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new(),
-        frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
-    );
+    let extra: runtime::TransactionExtensions =
+        (
+            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(),
+            )),
+            check_nonce::CheckNonce::<runtime::Runtime>::from(nonce),
+            frame_system::CheckWeight::<runtime::Runtime>::new(),
+            transaction_payment_wrapper::ChargeTransactionPaymentWrapper::new(
+                pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+            ),
+            pallet_subtensor::transaction_extension::SubtensorTransactionExtension::<
+                runtime::Runtime,
+            >::new(),
+            pallet_drand::drand_priority::DrandPriority::<runtime::Runtime>::new(),
+            frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
+        );
 
     let raw_payload = runtime::SignedPayload::from_raw(
         call.clone(),
@@ -152,6 +158,7 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
+            (),
             None,
         ),
     );

evm-tests/test/neuron.precompile.reveal-weights.test.ts

@@ -318,14 +318,14 @@ fn customise_config(arg_matches: &ArgMatches, config: Configuration) -> Configur
 
     // If the operator did **not** supply `--rpc-max-subscriptions-per-connection` set to high value.
     config.rpc.max_subs_per_conn = match arg_matches
-        .value_source("rpc-max-subscriptions-per-connection")
+        .value_source("rpc_max_subscriptions_per_connection")
     {
         Some(ValueSource::CommandLine) => cli.run.rpc_params.rpc_max_subscriptions_per_connection,
         _ => 10000,
     };
 
     // If the operator did **not** supply `--rpc-max-connections` set to high value.
-    config.rpc.max_connections = match arg_matches.value_source("rpc-max-connections") {
+    config.rpc.max_connections = match arg_matches.value_source("rpc_max_connections") {
         Some(ValueSource::CommandLine) => cli.run.rpc_params.rpc_max_connections,
         _ => 10000,
     };

node/src/benchmarking.rs

@@ -107,8 +107,6 @@ pub mod pallet {
         BondsMovingAverageMaxReached,
         /// Only root can set negative sigmoid steepness values
         NegativeSigmoidSteepness,
-        /// Reveal Peroid is not within the valid range.
-        RevealPeriodOutOfBounds,
     }
     /// Enum for specifying the type of precompile operation.
     #[derive(
@@ -1311,14 +1309,10 @@ pub mod pallet {
                 Error::<T>::SubnetDoesNotExist
             );
 
-            const MAX_COMMIT_REVEAL_PEROIDS: u64 = 100;
-            ensure!(
-                interval <= MAX_COMMIT_REVEAL_PEROIDS,
-                Error::<T>::RevealPeriodOutOfBounds
-            );
-
-            pallet_subtensor::Pallet::<T>::set_reveal_period(netuid, interval);
             log::debug!("SetWeightCommitInterval( netuid: {netuid:?}, interval: {interval:?} ) ");
+
+            pallet_subtensor::Pallet::<T>::set_reveal_period(netuid, interval)?;
+
             Ok(())
         }
 
@@ -1673,6 +1667,21 @@ pub mod pallet {
             pallet_subtensor::Pallet::<T>::set_commit_reveal_weights_version(version);
             Ok(())
         }
+
+        /// Sets the number of immune owner neurons
+        #[pallet::call_index(72)]
+        #[pallet::weight(Weight::from_parts(15_000_000, 0)
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(1_u64))
+        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
+        pub fn sudo_set_owner_immune_neuron_limit(
+            origin: OriginFor<T>,
+            netuid: NetUid,
+            immune_neurons: u16,
+        ) -> DispatchResult {
+            pallet_subtensor::Pallet::<T>::ensure_subnet_owner_or_root(origin, netuid)?;
+            pallet_subtensor::Pallet::<T>::set_owner_immune_neuron_limit(netuid, immune_neurons)?;
+            Ok(())
+        }
     }
 }