Merge branch 'devnet-ready' into hybrid-node

Author: liamaharon

Dockerfile

@@ -18,7 +18,7 @@ LABEL ai.opentensor.image.authors="operations@opentensor.ai" \
 
 # Rust targets
 RUN rustup update stable && \
-  rustup target add wasm32-unknown-unknown --toolchain stable
+  rustup target add wasm32v1-none --toolchain stable
 
 # Build prerequisites
 ENV RUST_BACKTRACE=1

Dockerfile-localnet

@@ -27,7 +27,7 @@ WORKDIR /build
 RUN set -o pipefail && curl https://sh.rustup.rs -sSf | sh -s -- -y
 ENV PATH="/root/.cargo/bin:${PATH}"
 RUN rustup toolchain install
-RUN rustup target add wasm32-unknown-unknown
+RUN rustup target add wasm32v1-none
 
 ## Build fast-blocks node
 RUN ./scripts/localnet.sh --build-only

docs/consensus.md

@@ -297,11 +297,10 @@ ssh -L 8888:localhost:8888 root@<your_vps_ip_address> -p <your_vps_port> -i ~/.s
    ```bash
    sudo apt-get update && sudo apt install -y build-essential clang curl git make libssl-dev llvm libudev-dev protobuf-compiler python3 python3-pip \
    && curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y \
-   && source ~/.cargo/env && rustup default stable && rustup update \
-   && rustup target add wasm32-unknown-unknown \
-   && rustup toolchain install nightly \
-   && rustup target add --toolchain nightly wasm32-unknown-unknown
-
+   && source ~/.cargo/env \
+   && rustup default stable \
+   && rustup update \
+   && rustup target add wasm32v1-none
    ```
 
 3. **Clone the Subtensor repository and checkout the relevant branch:**

docs/rust-setup.md

@@ -2,7 +2,7 @@
 title: Installation
 ---
 This guide is for reference only, please check the latest information on getting starting with Substrate
-[here](https://docs.polkadot.com/main-docs/install/).
+[here](https://docs.polkadot.com/develop/parachains/install-polkadot-sdk/).
 
 This page will guide you through the **2 steps** needed to prepare a computer for **Substrate** development.
 Since Substrate is built with [the Rust programming language](https://www.rust-lang.org/), the first
@@ -65,18 +65,15 @@ Open the Terminal application and execute the following commands:
 # Install Homebrew if necessary https://brew.sh/
 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
 
-# Make sure Homebrew is up-to-date, install openssl
+# Make sure Homebrew is up-to-date, install protobuf and openssl
 brew update
-brew install openssl
+brew install protobuf openssl
 ```
 
 ### Windows
 
 **_PLEASE NOTE:_** Native Windows development of Substrate is _not_ very well supported! It is _highly_
-recommend to use [Windows Subsystem Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
-(WSL) and follow the instructions for [Ubuntu/Debian](#ubuntudebian).
-Please refer to the separate
-[guide for native Windows development](https://docs.polkadot.com/main-docs/install/windows/).
+recommend to use [Windows Subsystem Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) (WSL) and follow the following [instructions](https://docs.polkadot.com/develop/parachains/install-polkadot-sdk/#windows-wsl).
 
 ## Rust developer environment
 
@@ -90,13 +87,12 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 source ~/.cargo/env
 ```
 
-Configure the Rust toolchain to default to the latest stable version, add nightly and the nightly wasm target:
+Configure the Rust toolchain to default to the latest stable version:
 
 ```bash
 rustup default stable
 rustup update
-rustup update nightly
-rustup target add wasm32-unknown-unknown --toolchain nightly
+rustup target add wasm32v1-none
 ```
 
 ## Test your set-up
@@ -125,38 +121,26 @@ rustup home:  /home/user/.rustup
 
 installed toolchains
 --------------------
-
 stable-x86_64-unknown-linux-gnu (default)
-nightly-2020-10-06-x86_64-unknown-linux-gnu
 nightly-x86_64-unknown-linux-gnu
 
-installed targets for active toolchain
---------------------------------------
-
-wasm32-unknown-unknown
-x86_64-unknown-linux-gnu
-
 active toolchain
 ----------------
-
-stable-x86_64-unknown-linux-gnu (default)
-rustc 1.50.0 (cb75ad5db 2021-02-10)
+name: stable-x86_64-unknown-linux-gnu
+active because: it's the default toolchain
+installed targets:
+  x86_64-unknown-linux-gnu
+  wasm32v1-none
 ```
 
 As you can see above, the default toolchain is stable, and the
-`nightly-x86_64-unknown-linux-gnu` toolchain as well as its `wasm32-unknown-unknown` target is installed.
-You also see that `nightly-2020-10-06-x86_64-unknown-linux-gnu` is installed, but is not used unless explicitly defined as illustrated in the [specify your nightly version](#specifying-nightly-version)
+`stable-x86_64-unknown-linux-gnu` toolchain as well as its `wasm32v1-none` target is installed.
+You also see that `nightly-x86_64-unknown-linux-gnu` is installed, but is not used unless explicitly defined as illustrated in the [specify your nightly version](#specifying-nightly-version)
 section.
 
 ### WebAssembly compilation
 
-Substrate uses [WebAssembly](https://webassembly.org) (Wasm) to produce portable blockchain
-runtimes. You will need to configure your Rust compiler to use
-[`nightly` builds](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html) to allow you to
-compile Substrate runtime code to the Wasm target.
-
-> There are upstream issues in Rust that need to be resolved before all of Substrate can use the stable Rust toolchain.
-> [This is our tracking issue](https://github.com/paritytech/substrate/issues/1252) if you're curious as to why and how this will be resolved.
+Substrate uses [WebAssembly](https://webassembly.org) (Wasm) to produce portable blockchain runtimes.
 
 #### Latest nightly for Substrate `master`
 
@@ -168,7 +152,7 @@ To ensure your Rust compiler is always up to date, you should run:
 ```bash
 rustup update
 rustup update nightly
-rustup target add wasm32-unknown-unknown --toolchain nightly
+rustup target add wasm32v1-none --toolchain nightly
 ```
 
 > NOTE: It may be necessary to occasionally rerun `rustup update` if a change in the upstream Substrate
@@ -197,7 +181,7 @@ rustup install nightly-<yyyy-MM-dd>
 Now, configure the nightly version to work with the Wasm compilation target:
 
 ```bash
-rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
+rustup target add wasm32v1-none --toolchain nightly-<yyyy-MM-dd>
 ```
 
 ### Specifying nightly version
@@ -220,6 +204,6 @@ specific nightly version, follow these steps:
 ```bash
 rustup uninstall nightly
 rustup install nightly-<yyyy-MM-dd>
-rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
+rustup target add wasm32v1-none --toolchain nightly-<yyyy-MM-dd>
 ```
 

pallets/subtensor/src/lib.rs

@@ -1918,6 +1918,9 @@ pub enum CustomTransactionError {
     BadRequest,
     ZeroMaxAmount,
     InvalidRevealRound,
+    CommitNotFound,
+    CommitBlockNotInRevealRange,
+    InputLengthsUnequal,
 }
 
 impl From<CustomTransactionError> for u8 {
@@ -1940,6 +1943,9 @@ impl From<CustomTransactionError> for u8 {
             CustomTransactionError::BadRequest => 255,
             CustomTransactionError::ZeroMaxAmount => 14,
             CustomTransactionError::InvalidRevealRound => 15,
+            CustomTransactionError::CommitNotFound => 16,
+            CustomTransactionError::CommitBlockNotInRevealRange => 17,
+            CustomTransactionError::InputLengthsUnequal => 18,
         }
     }
 }
@@ -2081,20 +2087,84 @@ where
                     Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
-            Some(Call::reveal_weights { netuid, .. }) => {
+            Some(Call::reveal_weights {
+                netuid,
+                uids,
+                values,
+                salt,
+                version_key,
+            }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
-                    let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    let validity = Self::validity_ok(priority);
-                    Ok((validity, Some(who.clone()), origin))
+                    let provided_hash = Pallet::<T>::get_commit_hash(
+                        who,
+                        *netuid,
+                        uids,
+                        values,
+                        salt,
+                        *version_key,
+                    );
+                    match Pallet::<T>::find_commit_block_via_hash(provided_hash) {
+                        Some(commit_block) => {
+                            if Pallet::<T>::is_reveal_block_range(*netuid, commit_block) {
+                                let priority: u64 = Self::get_priority_set_weights(who, *netuid);
+                                let validity = Self::validity_ok(priority);
+                                Ok((validity, Some(who.clone()), origin))
+                            } else {
+                                Err(CustomTransactionError::CommitBlockNotInRevealRange.into())
+                            }
+                        }
+                        None => Err(CustomTransactionError::CommitNotFound.into()),
+                    }
                 } else {
                     Err(CustomTransactionError::StakeAmountTooLow.into())
                 }
             }
-            Some(Call::batch_reveal_weights { netuid, .. }) => {
+            Some(Call::batch_reveal_weights {
+                netuid,
+                uids_list,
+                values_list,
+                salts_list,
+                version_keys,
+            }) => {
                 if Self::check_weights_min_stake(who, *netuid) {
-                    let priority: u64 = Self::get_priority_set_weights(who, *netuid);
-                    let validity = Self::validity_ok(priority);
-                    Ok((validity, Some(who.clone()), origin))
+                    let num_reveals = uids_list.len();
+                    if num_reveals == values_list.len()
+                        && num_reveals == salts_list.len()
+                        && num_reveals == version_keys.len()
+                    {
+                        let provided_hashs = (0..num_reveals)
+                            .map(|i| {
+                                Pallet::<T>::get_commit_hash(
+                                    who,
+                                    *netuid,
+                                    uids_list.get(i).unwrap_or(&Vec::new()),
+                                    values_list.get(i).unwrap_or(&Vec::new()),
+                                    salts_list.get(i).unwrap_or(&Vec::new()),
+                                    *version_keys.get(i).unwrap_or(&0_u64),
+                                )
+                            })
+                            .collect::<Vec<_>>();
+
+                        let batch_reveal_block = provided_hashs
+                            .iter()
+                            .filter_map(|hash| Pallet::<T>::find_commit_block_via_hash(*hash))
+                            .collect::<Vec<_>>();
+
+                        if provided_hashs.len() == batch_reveal_block.len() {
+                            if Pallet::<T>::is_batch_reveal_block_range(*netuid, batch_reveal_block)
+                            {
+                                let priority: u64 = Self::get_priority_set_weights(who, *netuid);
+                                let validity = Self::validity_ok(priority);
+                                Ok((validity, Some(who.clone()), origin))
+                            } else {
+                                Err(CustomTransactionError::CommitBlockNotInRevealRange.into())
+                            }
+                        } else {
+                            Err(CustomTransactionError::CommitNotFound.into())
+                        }
+                    } else {
+                        Err(CustomTransactionError::InputLengthsUnequal.into())
+                    }
                 } else {
                     Err(CustomTransactionError::StakeAmountTooLow.into())
                 }

pallets/subtensor/src/macros/dispatches.rs

@@ -279,7 +279,7 @@ mod dispatches {
         ///   - Attempting to commit when the user has more than the allowed limit of unrevealed commits.
         ///
         #[pallet::call_index(99)]
-        #[pallet::weight((Weight::from_parts(50_980_000, 0)
+        #[pallet::weight((Weight::from_parts(62_300_000, 0)
 		.saturating_add(T::DbWeight::get().reads(7_u64))
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Normal, Pays::No))]
         pub fn commit_crv3_weights(
@@ -827,7 +827,7 @@ mod dispatches {
         /// 	- The ip type v4 or v6.
         ///
         #[pallet::call_index(5)]
-        #[pallet::weight((Weight::from_parts(23_180_000, 0)
+        #[pallet::weight((Weight::from_parts(22_640_000, 0)
 		.saturating_add(T::DbWeight::get().reads(4))
 		.saturating_add(T::DbWeight::get().writes(1)), DispatchClass::Normal, Pays::No))]
         pub fn serve_prometheus(
@@ -1045,7 +1045,7 @@ mod dispatches {
         ///
         #[pallet::call_index(69)]
         #[pallet::weight((
-            Weight::from_parts(3_630_000, 0)
+            Weight::from_parts(4_690_000, 0)
             .saturating_add(T::DbWeight::get().reads(0))
             .saturating_add(T::DbWeight::get().writes(1)),
             DispatchClass::Operational,
@@ -1327,7 +1327,7 @@ mod dispatches {
         /// - Consider adding checks to prevent scheduling too far into the future.
         /// TODO: Benchmark this call
         #[pallet::call_index(73)]
-        #[pallet::weight((Weight::from_parts(28_770_000, 0)
+        #[pallet::weight((Weight::from_parts(47_820_000, 0)
 		.saturating_add(T::DbWeight::get().reads(4))
 		.saturating_add(T::DbWeight::get().writes(2)), DispatchClass::Operational, Pays::Yes))]
         pub fn schedule_swap_coldkey(

pallets/subtensor/src/subnets/weights.rs

@@ -377,14 +377,8 @@ impl<T: Config> Pallet<T> {
             }
 
             // --- 5. Hash the provided data.
-            let provided_hash: H256 = BlakeTwo256::hash_of(&(
-                who.clone(),
-                netuid,
-                uids.clone(),
-                values.clone(),
-                salt.clone(),
-                version_key,
-            ));
+            let provided_hash: H256 =
+                Self::get_commit_hash(&who, netuid, &uids, &values, &salt, version_key);
 
             // --- 6. After removing expired commits, check if any commits are left.
             if commits.is_empty() {
@@ -1083,4 +1077,30 @@ impl<T: Config> Pallet<T> {
             .saturating_mul(tempo_plus_one)
             .saturating_sub(netuid_plus_one)
     }
+
+    pub fn get_commit_hash(
+        who: &T::AccountId,
+        netuid: NetUid,
+        uids: &[u16],
+        values: &[u16],
+        salt: &[u16],
+        version_key: u64,
+    ) -> H256 {
+        BlakeTwo256::hash_of(&(who.clone(), netuid, uids, values, salt, version_key))
+    }
+
+    pub fn find_commit_block_via_hash(hash: H256) -> Option<u64> {
+        WeightCommits::<T>::iter().find_map(|(_, _, commits)| {
+            commits
+                .iter()
+                .find(|(h, _, _, _)| *h == hash)
+                .map(|(_, commit_block, _, _)| *commit_block)
+        })
+    }
+
+    pub fn is_batch_reveal_block_range(netuid: NetUid, commit_block: Vec<u64>) -> bool {
+        commit_block
+            .iter()
+            .all(|block| Self::is_reveal_block_range(netuid, *block))
+    }
 }