Merge branch 'devnet-ready' into enable-multi-block-per-slot

Author: open-junius

.github/workflows/contract-tests.yml

@@ -24,7 +24,7 @@ permissions:
 
 jobs:
   run:
-    runs-on: ubuntu-latest
+    runs-on: [self-hosted, type-ccx13]
     env:
       RUST_BACKTRACE: full
     steps:
@@ -52,7 +52,7 @@ jobs:
       - name: Run tests
         uses: nick-fields/retry@v3
         with:
-          timeout_minutes: 90
+          timeout_minutes: 120
           max_attempts: 3
           retry_wait_seconds: 60
           command: |

contract-tests/src/contracts/addressMapping.ts

@@ -0,0 +1,23 @@
+export const IADDRESS_MAPPING_ADDRESS = "0x000000000000000000000000000000000000080c";
+
+export const IAddressMappingABI = [
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "target_address",
+                "type": "address"
+            }
+        ],
+        "name": "addressMapping",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+];

contract-tests/src/contracts/staking.ts

@@ -233,6 +233,30 @@ export const IStakingV2ABI = [
         "stateMutability": "view",
         "type": "function"
     },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes32",
+                "name": "coldkey",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "uint256",
+                "name": "netuid",
+                "type": "uint256"
+            }
+        ],
+        "name": "getTotalColdkeyStakeOnSubnet",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
     {
         "inputs": [
             {

contract-tests/test/addressMapping.precompile.test.ts

@@ -0,0 +1,87 @@
+import * as assert from "assert";
+import { ethers } from "ethers";
+import { generateRandomEthersWallet } from "../src/utils";
+import { IADDRESS_MAPPING_ADDRESS, IAddressMappingABI } from "../src/contracts/addressMapping";
+import { convertH160ToPublicKey } from "../src/address-utils";
+import { u8aToHex } from "@polkadot/util";
+
+describe("Test address mapping precompile", () => {
+    const wallet1 = generateRandomEthersWallet();
+    const wallet2 = generateRandomEthersWallet();
+
+    it("Address mapping converts H160 to AccountId32 correctly", async () => {
+        const contract = new ethers.Contract(
+            IADDRESS_MAPPING_ADDRESS,
+            IAddressMappingABI,
+            wallet1
+        );
+
+        // Test with wallet1's address
+        const evmAddress = wallet1.address;
+        const accountId32 = await contract.addressMapping(evmAddress);
+        const expectedAcccountId32 = convertH160ToPublicKey(evmAddress);
+
+        // Verify the result is a valid bytes32 (32 bytes)
+        assert.ok(accountId32.length === 66, "AccountId32 should be 32 bytes (66 hex chars with 0x)");
+        assert.ok(accountId32.startsWith("0x"), "AccountId32 should start with 0x");
+
+        // Verify it's not all zeros
+        assert.notEqual(
+            accountId32,
+            "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "AccountId32 should not be all zeros"
+        );
+
+        console.log("accountId32: {}", accountId32);
+        console.log("expectedAcccountId32: {}", expectedAcccountId32);
+
+        assert.equal(accountId32, u8aToHex(expectedAcccountId32), "AccountId32 should be the same as the expected AccountId32");
+    });
+
+    it("Address mapping works with different addresses", async () => {
+        const contract = new ethers.Contract(
+            IADDRESS_MAPPING_ADDRESS,
+            IAddressMappingABI,
+            wallet1
+        );
+
+        // Test with wallet2's address
+        const evmAddress1 = wallet1.address;
+        const evmAddress2 = wallet2.address;
+
+        const accountId1 = await contract.addressMapping(evmAddress1);
+        const accountId2 = await contract.addressMapping(evmAddress2);
+
+        // Different addresses should map to different AccountIds
+        assert.notEqual(
+            accountId1,
+            accountId2,
+            "Different EVM addresses should map to different AccountIds"
+        );
+
+        // Both should be valid bytes32
+        assert.ok(accountId1.length === 66, "AccountId1 should be 32 bytes");
+        assert.ok(accountId2.length === 66, "AccountId2 should be 32 bytes");
+    });
+
+    it("Address mapping is deterministic", async () => {
+        const contract = new ethers.Contract(
+            IADDRESS_MAPPING_ADDRESS,
+            IAddressMappingABI,
+            wallet1
+        );
+
+        const evmAddress = wallet1.address;
+
+        // Call multiple times with the same address
+        const accountId1 = await contract.addressMapping(evmAddress);
+        const accountId2 = await contract.addressMapping(evmAddress);
+
+        // All calls should return the same result
+        assert.equal(
+            accountId1,
+            accountId2,
+            "First and second calls should return the same AccountId"
+        );
+    });
+});

contract-tests/test/staking.precompile.add-remove.test.ts

@@ -162,6 +162,15 @@ describe("Test neuron precompile add remove stake", () => {
 
         assert.equal(stakeFromContractV1, tao(stakeFromContractV2))
 
+        const totalColdkeyStakeOnSubnet = Number(
+            await contractV2.getTotalColdkeyStakeOnSubnet(convertH160ToPublicKey(wallet1.address), netuid)
+        );
+
+        // check the value is not undefined and is greater than or equal to the stake from contract V2
+        assert.ok(totalColdkeyStakeOnSubnet != undefined)
+        // is greater than or equal to the stake from contract V2 because of emission 
+        assert.ok(totalColdkeyStakeOnSubnet >= stakeFromContractV2)
+
     })
 
     it("Can remove stake", async () => {

node/src/chain_spec/localnet.rs

@@ -124,8 +124,5 @@ fn localnet_genesis(
         "evmChainId": {
             "chainId": 42,
         },
-        "subtensorModule": {
-            "startCallDelay": 10,
-        },
     })
 }

pallets/admin-utils/src/lib.rs

@@ -143,6 +143,8 @@ pub mod pallet {
         Proxy,
         /// Leasing precompile
         Leasing,
+        /// Address mapping precompile
+        AddressMapping,
     }
 
     #[pallet::type_value]

pallets/admin-utils/src/tests/mock.rs

@@ -145,7 +145,7 @@ parameter_types! {
     pub const InitialDissolveNetworkScheduleDuration: u64 = 5 * 24 * 60 * 60 / 12; // 5 days
     pub const InitialTaoWeight: u64 = u64::MAX/10; // 10% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
-    pub const InitialStartCallDelay: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
+    pub const InitialStartCallDelay: u64 = 0; // 0 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
     pub const HotkeySwapOnSubnetInterval: u64 = 7 * 24 * 60 * 60 / 12; // 7 days
     pub const LeaseDividendsDistributionInterval: u32 = 100; // 100 blocks

pallets/admin-utils/src/tests/mod.rs

@@ -2898,10 +2898,7 @@ fn test_sudo_set_start_call_delay_permissions_and_zero_delay() {
 
         // Get initial delay value (should be non-zero)
         let initial_delay = pallet_subtensor::StartCallDelay::<Test>::get();
-        assert!(
-            initial_delay > 0,
-            "Initial delay should be greater than zero"
-        );
+        assert_eq!(initial_delay, 0);
 
         // Test 1: Non-root account should fail to set delay
         assert_noop!(
@@ -2925,20 +2922,16 @@ fn test_sudo_set_start_call_delay_permissions_and_zero_delay() {
             "Default owner should be account 0"
         );
 
-        // Test 3: Try to start the subnet immediately - should FAIL (delay not passed)
-        assert_err!(
-            pallet_subtensor::Pallet::<Test>::start_call(
-                <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
-                netuid
-            ),
-            pallet_subtensor::Error::<Test>::NeedWaitingMoreBlocksToStarCall
-        );
+        // Test 3: Can successfully start the subnet immediately
+        assert_ok!(pallet_subtensor::Pallet::<Test>::start_call(
+            <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
+            netuid
+        ));
 
-        // Verify emission has not been set
-        assert_eq!(
-            pallet_subtensor::FirstEmissionBlockNumber::<Test>::get(netuid),
-            None,
-            "Emission should not be set yet"
+        // Verify emission has been set
+        assert!(
+            pallet_subtensor::FirstEmissionBlockNumber::<Test>::get(netuid).is_some(),
+            "Emission should be set"
         );
 
         // Test 4: Root sets delay to zero
@@ -2957,12 +2950,15 @@ fn test_sudo_set_start_call_delay_permissions_and_zero_delay() {
             pallet_subtensor::Event::StartCallDelaySet(0),
         ));
 
-        // Test 5: Try to start the subnet again - should SUCCEED (delay is now zero)
+        // Test 5: Try to start the subnet again - should be FAILED (first emission block already set)
         let current_block = frame_system::Pallet::<Test>::block_number();
-        assert_ok!(pallet_subtensor::Pallet::<Test>::start_call(
-            <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
-            netuid
-        ));
+        assert_err!(
+            pallet_subtensor::Pallet::<Test>::start_call(
+                <<Test as Config>::RuntimeOrigin>::signed(coldkey_account_id),
+                netuid
+            ),
+            pallet_subtensor::Error::<Test>::FirstEmissionBlockNumberAlreadySet
+        );
 
         assert_eq!(
             pallet_subtensor::FirstEmissionBlockNumber::<Test>::get(netuid),

pallets/subtensor/src/staking/helpers.rs

@@ -91,6 +91,43 @@ impl<T: Config> Pallet<T> {
             .into()
     }
 
+    // Returns the total amount of stake under a coldkey on a subnet
+    //
+    pub fn get_total_stake_for_coldkey_on_subnet(
+        coldkey: &T::AccountId,
+        netuid: NetUid,
+    ) -> TaoCurrency {
+        let hotkeys = StakingHotkeys::<T>::get(coldkey);
+        hotkeys
+            .iter()
+            .map(|hotkey| {
+                Alpha::<T>::iter_prefix((hotkey, coldkey))
+                    .map(|(netuid_on_storage, _)| {
+                        if netuid_on_storage == netuid {
+                            let alpha_stake = Self::get_stake_for_hotkey_and_coldkey_on_subnet(
+                                hotkey, coldkey, netuid,
+                            );
+                            let order = GetTaoForAlpha::<T>::with_amount(alpha_stake);
+                            T::SwapInterface::sim_swap(netuid.into(), order)
+                                .map(|r| {
+                                    let fee: u64 = U96F32::saturating_from_num(r.fee_paid)
+                                        .saturating_mul(T::SwapInterface::current_alpha_price(
+                                            netuid.into(),
+                                        ))
+                                        .saturating_to_num();
+                                    r.amount_paid_out.to_u64().saturating_add(fee)
+                                })
+                                .unwrap_or_default()
+                        } else {
+                            0
+                        }
+                    })
+                    .sum::<u64>()
+            })
+            .sum::<u64>()
+            .into()
+    }
+
     // Creates a cold - hot pairing account if the hotkey is not already an active account.
     //
     pub fn create_account_if_non_existent(coldkey: &T::AccountId, hotkey: &T::AccountId) {