Merge branch 'devnet-ready' into remove-deprecated-extrinsics2

Author: shamil-gadelshin

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

@@ -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

@@ -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,
     };

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

@@ -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(
@@ -1220,14 +1218,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(())
         }
 
@@ -1582,6 +1576,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(())
+        }
     }
 }
 

node/src/command.rs

@@ -1120,7 +1120,7 @@ fn test_sudo_set_commit_reveal_weights_enabled() {
         let netuid = NetUid::from(1);
         add_network(netuid, 10);
 
-        let to_be_set: bool = true;
+        let to_be_set: bool = false;
         let init_value: bool = SubtensorModule::get_commit_reveal_weights_enabled(netuid);
 
         assert_ok!(AdminUtils::sudo_set_commit_reveal_weights_enabled(
@@ -1459,7 +1459,7 @@ fn sudo_set_commit_reveal_weights_interval() {
                 netuid,
                 too_high
             ),
-            Error::<Test>::RevealPeriodOutOfBounds
+            pallet_subtensor::Error::<Test>::RevealPeriodTooLarge
         );
 
         let to_be_set = 55;

pallets/admin-utils/src/lib.rs

@@ -60,6 +60,7 @@ mod pallet_benchmarks {
         Subtensor::<T>::set_network_registration_allowed(netuid, true);
         Subtensor::<T>::set_max_registrations_per_block(netuid, 4096);
         Subtensor::<T>::set_target_registrations_per_interval(netuid, 4096);
+        Subtensor::<T>::set_commit_reveal_weights_enabled(netuid, false);
 
         let mut seed: u32 = 1;
         let mut dests = Vec::new();