Merge pull request #1492 from opentensor/devnet-ready

devnet deploy 4/1/2025

Author: sam0x17

evm-tests/src/config.ts

@@ -2,7 +2,7 @@ export const ETH_LOCAL_URL = 'http://localhost:9944'
 export const SUB_LOCAL_URL = 'ws://localhost:9944'
 export const SS58_PREFIX = 42;
 // set the tx timeout as 2 second when eable the fast-blocks feature.
-export const TX_TIMEOUT = 2000;
+export const TX_TIMEOUT = 3000;
 
 export const IED25519VERIFY_ADDRESS = "0x0000000000000000000000000000000000000402";
 export const IEd25519VerifyABI = [

evm-tests/src/contracts/staking.ts

@@ -137,6 +137,30 @@ export const IStakingV2ABI = [
         "stateMutability": "payable",
         "type": "function"
     },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "hotkey",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "uint256",
+                "name": "netuid",
+                "type": "uint256"
+            }
+        ],
+        "name": "getAlphaStakedValidators",
+        "outputs": [
+            {
+                "internalType": "uint256[]",
+                "name": "",
+                "type": "uint256[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
     {
         "inputs": [
             {
@@ -166,6 +190,30 @@ export const IStakingV2ABI = [
         "stateMutability": "view",
         "type": "function"
     },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "hotkey",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "uint256",
+                "name": "netuid",
+                "type": "uint256"
+            }
+        ],
+        "name": "getTotalAlphaStaked",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
     {
         "inputs": [
             {

evm-tests/test/staking.precompile.stake-get.test.ts

@@ -0,0 +1,57 @@
+import * as assert from "assert";
+import { getDevnetApi, getRandomSubstrateKeypair } from "../src/substrate"
+import { devnet } from "@polkadot-api/descriptors"
+import { TypedApi } from "polkadot-api";
+import { convertPublicKeyToSs58 } from "../src/address-utils"
+import { tao } from "../src/balance-math"
+import {
+    forceSetBalanceToSs58Address, addNewSubnetwork, addStake,
+} from "../src/subtensor"
+import { ethers } from "ethers";
+import { generateRandomEthersWallet } from "../src/utils"
+import { ISTAKING_V2_ADDRESS, IStakingV2ABI } from "../src/contracts/staking"
+import { log } from "console";
+
+describe("Test staking precompile get methods", () => {
+    const hotkey = getRandomSubstrateKeypair();
+    const coldkey = getRandomSubstrateKeypair();
+    const wallet1 = generateRandomEthersWallet();
+
+    let api: TypedApi<typeof devnet>
+
+    before(async () => {
+        api = await getDevnetApi()
+        await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(hotkey.publicKey))
+        await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(coldkey.publicKey))
+        let netuid = await addNewSubnetwork(api, hotkey, coldkey)
+        console.log("will test in subnet: ", netuid)
+    })
+
+    it("Staker receives rewards", async () => {
+        let netuid = (await api.query.SubtensorModule.TotalNetworks.getValue()) - 1
+
+        await addStake(api, netuid, convertPublicKeyToSs58(hotkey.publicKey), tao(1), coldkey)
+
+        const contract = new ethers.Contract(
+            ISTAKING_V2_ADDRESS,
+            IStakingV2ABI,
+            wallet1
+        );
+
+        const stake = BigInt(
+            await contract.getStake(hotkey.publicKey, coldkey.publicKey, netuid)
+        );
+
+        // validator returned as bigint now. 
+        const validators =
+            await contract.getAlphaStakedValidators(hotkey.publicKey, netuid)
+
+        const alpha = BigInt(
+            await contract.getTotalAlphaStaked(hotkey.publicKey, netuid)
+        );
+        assert.ok(stake > 0)
+        assert.equal(validators.length, 1)
+        assert.ok(alpha > 0)
+
+    })
+})

pallets/commitments/src/lib.rs

@@ -172,7 +172,7 @@ pub mod pallet {
         u16,
         Twox64Concat,
         T::AccountId,
-        RevealedData<BalanceOf<T>, T::MaxFields, BlockNumberFor<T>>,
+        Vec<(Vec<u8>, u64)>, // Reveals<(Data, RevealBlock)>
         OptionQuery,
     >;
 
@@ -221,11 +221,13 @@ pub mod pallet {
 
             let cur_block = <frame_system::Pallet<T>>::block_number();
 
+            let min_used_space: u64 = 100;
             let required_space: u64 = info
                 .fields
                 .iter()
                 .map(|field| field.len_for_rate_limit())
-                .sum();
+                .sum::<u64>()
+                .max(min_used_space);
 
             let mut usage = UsedSpaceOf::<T>::get(netuid, &who).unwrap_or_default();
             let cur_block_u64 = cur_block.saturated_into::<u64>();
@@ -478,7 +480,6 @@ where
 
 impl<T: Config> Pallet<T> {
     pub fn reveal_timelocked_commitments() -> DispatchResult {
-        let current_block = <frame_system::Pallet<T>>::block_number();
         let index = TimelockedIndex::<T>::get();
         for (netuid, who) in index.clone() {
             let Some(mut registration) = <CommitmentOf<T>>::get(netuid, &who) else {
@@ -528,10 +529,7 @@ impl<T: Config> Pallet<T> {
                             .ok();
 
                         let Some(sig) = sig else {
-                            remain_fields.push(Data::TimelockEncrypted {
-                                encrypted,
-                                reveal_round,
-                            });
+                            log::warn!("No sig after deserialization");
                             continue;
                         };
 
@@ -547,10 +545,7 @@ impl<T: Config> Pallet<T> {
                             .ok();
 
                         let Some(commit) = commit else {
-                            remain_fields.push(Data::TimelockEncrypted {
-                                encrypted,
-                                reveal_round,
-                            });
+                            log::warn!("No commit after deserialization");
                             continue;
                         };
 
@@ -563,61 +558,41 @@ impl<T: Config> Pallet<T> {
                                 .unwrap_or_default();
 
                         if decrypted_bytes.is_empty() {
-                            remain_fields.push(Data::TimelockEncrypted {
-                                encrypted,
-                                reveal_round,
-                            });
+                            log::warn!("Bytes were decrypted for {:?} but they are empty", who);
                             continue;
                         }
 
-                        let mut reader = &decrypted_bytes[..];
-                        let revealed_info: CommitmentInfo<T::MaxFields> =
-                            match Decode::decode(&mut reader) {
-                                Ok(info) => info,
-                                Err(e) => {
-                                    log::warn!(
-                                        "Failed to decode decrypted data for {:?}: {:?}",
-                                        who,
-                                        e
-                                    );
-                                    remain_fields.push(Data::TimelockEncrypted {
-                                        encrypted,
-                                        reveal_round,
-                                    });
-                                    continue;
-                                }
-                            };
-
-                        revealed_fields.push(revealed_info);
+                        revealed_fields.push(decrypted_bytes);
                     }
 
                     other => remain_fields.push(other),
                 }
             }
 
             if !revealed_fields.is_empty() {
-                let mut all_revealed_data = Vec::new();
-                for info in revealed_fields {
-                    all_revealed_data.extend(info.fields.into_inner());
-                }
+                let mut existing_reveals =
+                    RevealedCommitments::<T>::get(netuid, &who).unwrap_or_default();
 
-                let bounded_revealed = BoundedVec::try_from(all_revealed_data)
-                    .map_err(|_| "Could not build BoundedVec for revealed fields")?;
+                let current_block = <frame_system::Pallet<T>>::block_number();
+                let block_u64 = current_block.saturated_into::<u64>();
 
-                let combined_revealed_info = CommitmentInfo {
-                    fields: bounded_revealed,
-                };
+                // Push newly revealed items onto the tail of existing_reveals and emit the event
+                for revealed_bytes in revealed_fields {
+                    existing_reveals.push((revealed_bytes, block_u64));
 
-                let revealed_data = RevealedData {
-                    info: combined_revealed_info,
-                    revealed_block: current_block,
-                    deposit: registration.deposit,
-                };
-                <RevealedCommitments<T>>::insert(netuid, &who, revealed_data);
-                Self::deposit_event(Event::CommitmentRevealed {
-                    netuid,
-                    who: who.clone(),
-                });
+                    Self::deposit_event(Event::CommitmentRevealed {
+                        netuid,
+                        who: who.clone(),
+                    });
+                }
+
+                const MAX_REVEALS: usize = 10;
+                if existing_reveals.len() > MAX_REVEALS {
+                    let remove_count = existing_reveals.len().saturating_sub(MAX_REVEALS);
+                    existing_reveals.drain(0..remove_count);
+                }
+
+                RevealedCommitments::<T>::insert(netuid, &who, existing_reveals);
             }
 
             registration.info.fields = BoundedVec::try_from(remain_fields)

pallets/commitments/src/mock.rs

@@ -207,6 +207,7 @@ use tle::{ibe::fullident::Identity, stream_ciphers::AESGCMStreamCipherProvider,
 pub const DRAND_QUICKNET_PUBKEY_HEX: &str = "83cf0f2896adee7eb8b5f01fcad3912212c437e0073e911fb90022d3e760183c8c4b450b6\
      a0a6c3ac6a5776a2d1064510d1fec758c921cc22b0e17e63aaf4bcb5ed66304de9cf809b\
      d274ca73bab4af5a6e9c76a4bc09e76eae8991ef5ece45a";
+pub const DRAND_QUICKNET_SIG_2000_HEX: &str = "b6cb8f482a0b15d45936a4c4ea08e98a087e71787caee3f4d07a8a9843b1bc5423c6b3c22f446488b3137eaca799c77e"; // round 20000
 pub const DRAND_QUICKNET_SIG_HEX: &str = "b44679b9a59af2ec876b1a6b1ad52ea9b1615fc3982b19576350f93447cb1125e342b73a8dd2bacbe47e4b6b63ed5e39";
 
 /// Inserts a Drand pulse for `round` with the given `signature_bytes`.