merge with target

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

Cargo.lock

@@ -331,7 +331,7 @@ parameter_types! {
     pub const InitialDissolveNetworkScheduleDuration: u64 =  5 * 24 * 60 * 60 / 12; // Default as 5 days
     pub const InitialTaoWeight: u64 = 0; // 100% global weight.
     pub const InitialEmaPriceHalvingPeriod: u64 = 201_600_u64; // 4 weeks
-    pub const DurationOfStartCall: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
+    pub const InitialStartCallDelay: u64 =  7 * 24 * 60 * 60 / 12; // Default as 7 days
     pub const InitialKeySwapOnSubnetCost: u64 = 10_000_000;
     pub const HotkeySwapOnSubnetInterval: u64 = 15; // 15 block, should be bigger than subnet number, then trigger clean up for all subnets
     pub const MaxContributorsPerLeaseToRemove: u32 = 3;
@@ -402,7 +402,7 @@ impl pallet_subtensor::Config for Test {
     type InitialDissolveNetworkScheduleDuration = InitialDissolveNetworkScheduleDuration;
     type InitialTaoWeight = InitialTaoWeight;
     type InitialEmaPriceHalvingPeriod = InitialEmaPriceHalvingPeriod;
-    type DurationOfStartCall = DurationOfStartCall;
+    type InitialStartCallDelay = InitialStartCallDelay;
     type SwapInterface = pallet_subtensor_swap::Pallet<Self>;
     type KeySwapOnSubnetCost = InitialKeySwapOnSubnetCost;
     type HotkeySwapOnSubnetInterval = HotkeySwapOnSubnetInterval;

chain-extensions/src/mock.rs

@@ -1,6 +1,6 @@
 {
   "scripts": {
-    "test": "mocha --timeout 999999 --retries 3 --file src/setup.ts --require ts-node/register test/*test.ts"
+    "test": "TS_NODE_PREFER_TS_EXTS=1 TS_NODE_TRANSPILE_ONLY=1 mocha --timeout 999999 --retries 3 --file src/setup.ts --require ts-node/register --extension ts \"test/**/*.ts\""
   },
   "keywords": [],
   "author": "",

contract-tests/package.json

@@ -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/addressMapping.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/src/contracts/staking.ts

@@ -296,7 +296,7 @@ export async function setSubtokenEnable(api: TypedApi<typeof devnet>, netuid: nu
 export async function startCall(api: TypedApi<typeof devnet>, netuid: number, keypair: KeyPair) {
     const registerBlock = Number(await api.query.SubtensorModule.NetworkRegisteredAt.getValue(netuid))
     let currentBlock = await api.query.System.Number.getValue()
-    const duration = Number(await api.constants.SubtensorModule.DurationOfStartCall)
+    const duration = Number(await api.constants.SubtensorModule.InitialStartCallDelay)
 
     while (currentBlock - registerBlock <= duration) {
         await new Promise((resolve) => setTimeout(resolve, 2000));

contract-tests/src/subtensor.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/addressMapping.precompile.test.ts

@@ -1,5 +1,5 @@
 import * as assert from "assert";
-import { getAliceSigner, getDevnetApi, getRandomSubstrateKeypair } from "../src/substrate"
+import { getAliceSigner, getDevnetApi, getRandomSubstrateKeypair, waitForTransactionWithRetry } from "../src/substrate"
 import { devnet } from "@polkadot-api/descriptors"
 import { PolkadotSigner, TypedApi } from "polkadot-api";
 import { convertPublicKeyToSs58, convertH160ToSS58 } from "../src/address-utils"
@@ -23,6 +23,16 @@ const values = [5];
 const salt = [9];
 const version_key = 0;
 
+async function setStakeThreshold(
+    api: TypedApi<typeof devnet>,
+    alice: PolkadotSigner,
+    minStake: bigint,
+) {
+    const internalCall = api.tx.AdminUtils.sudo_set_stake_threshold({ min_stake: minStake })
+    const tx = api.tx.Sudo.sudo({ call: internalCall.decodedCall })
+    await waitForTransactionWithRetry(api, tx, alice)
+}
+
 function getCommitHash(netuid: number, address: string) {
     const registry = new TypeRegistry();
     let publicKey = convertH160ToPublicKey(address);
@@ -53,7 +63,7 @@ describe("Test neuron precompile reveal weights", () => {
     const coldkey = getRandomSubstrateKeypair();
 
     let api: TypedApi<typeof devnet>
-    let commitEpoch: number;
+    let commitEpoch: number | undefined;
 
     // sudo account alice as signer
     let alice: PolkadotSigner;
@@ -86,11 +96,52 @@ describe("Test neuron precompile reveal weights", () => {
         assert.equal(uid, uids[0])
     })
 
+    async function ensureCommitEpoch(netuid: number, contract: ethers.Contract) {
+        if (commitEpoch !== undefined) {
+            return
+        }
+
+        const ss58Address = convertH160ToSS58(wallet.address)
+        const existingCommits = await api.query.SubtensorModule.WeightCommits.getValue(
+            netuid,
+            ss58Address
+        )
+        if (Array.isArray(existingCommits) && existingCommits.length > 0) {
+            const entry = existingCommits[0]
+            const commitBlockRaw =
+                Array.isArray(entry) && entry.length > 1 ? entry[1] : undefined
+            const commitBlock =
+                typeof commitBlockRaw === "bigint"
+                    ? Number(commitBlockRaw)
+                    : Number(commitBlockRaw ?? NaN)
+            if (Number.isFinite(commitBlock)) {
+                commitEpoch = Math.trunc(commitBlock / (100 + 1))
+                return
+            }
+        }
+
+        await setStakeThreshold(api, alice, BigInt(0))
+        const commitHash = getCommitHash(netuid, wallet.address)
+        const tx = await contract.commitWeights(netuid, commitHash)
+        await tx.wait()
+
+        const commitBlock = await api.query.System.Number.getValue()
+        commitEpoch = Math.trunc(commitBlock / (100 + 1))
+    }
+
     it("EVM neuron commit weights via call precompile", async () => {
         let totalNetworks = await api.query.SubtensorModule.TotalNetworks.getValue()
         const subnetId = totalNetworks - 1
         const commitHash = getCommitHash(subnetId, wallet.address)
         const contract = new ethers.Contract(INEURON_ADDRESS, INeuronABI, wallet);
+
+        await setStakeThreshold(api, alice, BigInt(1))
+        await assert.rejects(async () => {
+            const tx = await contract.commitWeights(subnetId, commitHash)
+            await tx.wait()
+        })
+        await setStakeThreshold(api, alice, BigInt(0))
+
         try {
             const tx = await contract.commitWeights(subnetId, commitHash)
             await tx.wait()
@@ -120,6 +171,11 @@ describe("Test neuron precompile reveal weights", () => {
         // set interval epoch as 1, it is the minimum value now
         await setCommitRevealWeightsInterval(api, netuid, BigInt(1))
 
+        await ensureCommitEpoch(netuid, contract)
+        if (commitEpoch === undefined) {
+            throw new Error("commitEpoch should be set before revealing weights")
+        }
+
         while (true) {
             const currentBlock = await api.query.System.Number.getValue()
             const currentEpoch = Math.trunc(currentBlock / (100 + 1))
@@ -130,6 +186,19 @@ describe("Test neuron precompile reveal weights", () => {
             await new Promise(resolve => setTimeout(resolve, 1000))
         }
 
+        await setStakeThreshold(api, alice, BigInt(1))
+        await assert.rejects(async () => {
+            const tx = await contract.revealWeights(
+                netuid,
+                uids,
+                values,
+                salt,
+                version_key
+            );
+            await tx.wait()
+        })
+        await setStakeThreshold(api, alice, BigInt(0))
+
         const tx = await contract.revealWeights(
             netuid,
             uids,

contract-tests/test/neuron.precompile.reveal-weights.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 () => {