Merge branch 'devnet-ready' into root-claim-alpha-maps

Author: shamil-gadelshin

.github/workflows/cargo-audit.yml

@@ -46,4 +46,6 @@ jobs:
           cargo audit --ignore RUSTSEC-2023-0091 \
                       --ignore RUSTSEC-2024-0438 \
                       --ignore RUSTSEC-2025-0009 \
-                      --ignore RUSTSEC-2025-0055
+                      --ignore RUSTSEC-2025-0055 \
+                      --ignore RUSTSEC-2025-0073 \
+                      --ignore RUSTSEC-2025-0118

.github/workflows/check-rust.yml

@@ -38,7 +38,7 @@ jobs:
       - name: Install Rust Nightly
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly
+          toolchain: stable
           components: rustfmt
 
       - name: Utilize Shared Rust Cache
@@ -48,7 +48,22 @@ jobs:
           cache-on-failure: true
 
       - name: cargo fmt
-        run: cargo +nightly fmt --check --all
+        run: |
+          set -euo pipefail
+          # Run cargo fmt and capture both stdout and stderr
+          output=$(cargo fmt --check --all 2>&1) || {
+            echo "❌ cargo fmt failed with non-zero exit code"
+            echo "$output"
+            exit 1
+          }
+          # Check for panic/ICE messages even if exit code was 0
+          if echo "$output" | grep -qiE "(the compiler unexpectedly panicked|panicked at|Internal Compiler Error|ICE|error: the compiler unexpectedly panicked)"; then
+            echo "❌ rustfmt panicked (ICE detected) - this should fail the build"
+            echo "$output"
+            exit 1
+          fi
+          echo "$output"
+          echo "✅ cargo fmt completed successfully"
 
   cargo-clippy-default-features:
     name: cargo clippy

.gitignore

@@ -46,4 +46,7 @@ specs/*.json
 bt.snap
 
 # localnet spec
-scripts/specs/local.json
+scripts/specs/local.json
+
+# Node modules
+node_modules

chain-extensions/src/tests.rs

@@ -757,12 +757,12 @@ impl SubtensorExtensionEnv<AccountId> for MockEnv {
     }
 
     fn charge_weight(&mut self, weight: Weight) -> Result<(), DispatchError> {
-        if let Some(expected) = self.expected_weight {
-            if weight != expected {
-                return Err(DispatchError::Other(
-                    "unexpected weight charged by mock env",
-                ));
-            }
+        if let Some(expected) = self.expected_weight
+            && weight != expected
+        {
+            return Err(DispatchError::Other(
+                "unexpected weight charged by mock env",
+            ));
         }
         self.charged_weight = Some(weight);
         Ok(())

common/src/lib.rs

@@ -184,11 +184,37 @@ impl TryFrom<u8> for ProxyType {
             14 => Ok(Self::SudoUncheckedSetCode),
             15 => Ok(Self::SwapHotkey),
             16 => Ok(Self::SubnetLeaseBeneficiary),
+            17 => Ok(Self::RootClaim),
             _ => Err(()),
         }
     }
 }
 
+impl From<ProxyType> for u8 {
+    fn from(proxy_type: ProxyType) -> Self {
+        match proxy_type {
+            ProxyType::Any => 0,
+            ProxyType::Owner => 1,
+            ProxyType::NonCritical => 2,
+            ProxyType::NonTransfer => 3,
+            ProxyType::Senate => 4,
+            ProxyType::NonFungible => 5,
+            ProxyType::Triumvirate => 6,
+            ProxyType::Governance => 7,
+            ProxyType::Staking => 8,
+            ProxyType::Registration => 9,
+            ProxyType::Transfer => 10,
+            ProxyType::SmallTransfer => 11,
+            ProxyType::RootWeights => 12,
+            ProxyType::ChildKeys => 13,
+            ProxyType::SudoUncheckedSetCode => 14,
+            ProxyType::SwapHotkey => 15,
+            ProxyType::SubnetLeaseBeneficiary => 16,
+            ProxyType::RootClaim => 17,
+        }
+    }
+}
+
 impl Default for ProxyType {
     // allow all Calls; required to be most permissive
     fn default() -> Self {

contract-tests/src/contracts/proxy.ts

@@ -144,5 +144,41 @@ export const IProxyABI = [
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "account",
+        "type": "bytes32"
+      }
+    ],
+    "name": "getProxies",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "delegate",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "uint256",
+            "name": "proxy_type",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "delay",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct IProxy.ProxyInfo[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
   }
 ];

contract-tests/test/pure-proxy.precompile.test.ts

@@ -46,8 +46,10 @@ async function getProxies(api: TypedApi<typeof devnet>, address: string) {
 
 describe("Test pure proxy precompile", () => {
     const evmWallet = generateRandomEthersWallet();
+    // only used for edge case and normal proxy
     const evmWallet2 = generateRandomEthersWallet();
     const evmWallet3 = generateRandomEthersWallet();
+    const evmWallet4 = generateRandomEthersWallet();
     const receiver = getRandomSubstrateKeypair();
 
     let api: TypedApi<typeof devnet>
@@ -61,6 +63,7 @@ describe("Test pure proxy precompile", () => {
         await forceSetBalanceToEthAddress(api, evmWallet.address)
         await forceSetBalanceToEthAddress(api, evmWallet2.address)
         await forceSetBalanceToEthAddress(api, evmWallet3.address)
+        await forceSetBalanceToEthAddress(api, evmWallet4.address)
     })
 
     it("Call createPureProxy, then use proxy to call transfer", async () => {
@@ -130,34 +133,78 @@ describe("Test pure proxy precompile", () => {
         const proxies = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
         const contract = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet2)
 
+        const proxiesFromContract = await contract.getProxies(convertH160ToPublicKey(evmWallet2.address))
+        assert.equal(proxiesFromContract.length, proxies[0].length, "proxies length should be equal")
+
         const type = 0;
         const delay = 0;
 
         const tx = await contract.addProxy(convertH160ToPublicKey(evmWallet3.address), type, delay)
         await tx.wait()
 
+        const proxiesAfterAdd = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
+        const proxiesList = proxiesAfterAdd[0].map(proxy => proxy.delegate)
 
-        const proxiesAfterAdd = await await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet2.address))
+        const proxiesFromContractAfterAdd = await contract.getProxies(convertH160ToPublicKey(evmWallet2.address))
 
-        const length = proxiesAfterAdd[0].length
-        assert.equal(length, proxies[0].length + 1, "proxy should be set")
-        const proxy = proxiesAfterAdd[0][proxiesAfterAdd[0].length - 1]
+        assert.equal(proxiesFromContractAfterAdd.length, proxiesList.length, "proxy length should be equal")
 
-        assert.equal(proxy.delegate, convertH160ToSS58(evmWallet3.address), "proxy should be set")
+        for (let index = 0; index < proxiesFromContractAfterAdd.length; index++) {
+            const proxyInfo = proxiesFromContractAfterAdd[index]
+            let proxySs58 = convertPublicKeyToSs58(proxyInfo[0])
+            assert.ok(proxiesList.includes(proxySs58), "proxy should be set")
+            if (index === proxiesFromContractAfterAdd.length - 1) {
+                assert.equal(Number(proxyInfo[1]), type, "proxy_type should match")
+                assert.equal(Number(proxyInfo[2]), delay, "delay should match")
+            }
+        }
 
+        assert.equal(proxiesList.length, proxies[0].length + 1, "proxy should be set")
+        const proxy = proxiesList[proxiesList.length - 1]
 
+        assert.equal(proxy, convertH160ToSS58(evmWallet3.address), "proxy should be set")
         const balance = (await api.query.System.Account.getValue(convertPublicKeyToSs58(receiver.publicKey))).data.free
-
         const amount = 1000000000;
 
         const contract2 = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet3)
-
-
         const callCode = await getTransferCallCode(api, receiver, amount)
         const tx2 = await contract2.proxyCall(convertH160ToPublicKey(evmWallet2.address), [type], callCode)
         await tx2.wait()
 
         const balanceAfter = (await api.query.System.Account.getValue(convertPublicKeyToSs58(receiver.publicKey))).data.free
         assert.equal(balanceAfter, balance + BigInt(amount), "balance should be increased")
     })
+
+    it("Call addProxy many times, then check getProxies is correct", async () => {
+        const proxies = await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet4.address))
+        const contract = new ethers.Contract(IPROXY_ADDRESS, IProxyABI, evmWallet4)
+        assert.equal(proxies[0].length, 0, "proxies length should be 0")
+
+        const proxiesFromContract = await contract.getProxies(convertH160ToPublicKey(evmWallet4.address))
+        assert.equal(proxiesFromContract.length, proxies[0].length, "proxies length should be equal")
+
+        const type = 1;
+        const delay = 2;
+
+        for (let i = 0; i < 5; i++) {
+            const evmWallet = generateRandomEthersWallet()
+            const tx = await contract.addProxy(convertH160ToPublicKey(evmWallet.address), type, delay)
+            await tx.wait()
+        }
+
+        const proxiesAfterAdd = await await api.query.Proxy.Proxies.getValue(convertH160ToSS58(evmWallet4.address))
+        const proxiesList = proxiesAfterAdd[0].map(proxy => proxy.delegate)
+
+        const proxiesFromContractAfterAdd = await contract.getProxies(convertH160ToPublicKey(evmWallet4.address))
+
+        assert.equal(proxiesFromContractAfterAdd.length, proxiesList.length, "proxy length should be equal")
+
+        for (let index = 0; index < proxiesFromContractAfterAdd.length; index++) {
+            const proxyInfo = proxiesFromContractAfterAdd[index]
+            let proxySs58 = convertPublicKeyToSs58(proxyInfo[0])
+            assert.ok(proxiesList.includes(proxySs58), "proxy should be set")
+            assert.equal(Number(proxyInfo[1]), type, "proxy_type should match")
+            assert.equal(Number(proxyInfo[2]), delay, "delay should match")
+        }
+    })
 });

node/src/benchmarking.rs

@@ -5,8 +5,8 @@
 use crate::client::FullClient;
 
 use node_subtensor_runtime as runtime;
-use node_subtensor_runtime::pallet_subtensor;
 use node_subtensor_runtime::{check_nonce, transaction_payment_wrapper};
+use node_subtensor_runtime::{pallet_subtensor, sudo_wrapper};
 use runtime::{BalancesCall, SystemCall};
 use sc_cli::Result;
 use sc_client_api::BlockBackend;
@@ -139,6 +139,7 @@ pub fn create_benchmark_extrinsic(
             transaction_payment_wrapper::ChargeTransactionPaymentWrapper::new(
                 pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
             ),
+            sudo_wrapper::SudoTransactionExtension::<runtime::Runtime>::new(),
             pallet_subtensor::transaction_extension::SubtensorTransactionExtension::<
                 runtime::Runtime,
             >::new(),
@@ -160,6 +161,7 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
+            (),
             None,
         ),
     );

node/src/command.rs

@@ -272,7 +272,7 @@ fn start_babe_service(arg_matches: &ArgMatches) -> Result<(), sc_cli::Error> {
             {
                 log::info!("Failed to aquire DB lock, trying again in 1s...");
                 std::thread::sleep(std::time::Duration::from_secs(1));
-                return start_babe_service(arg_matches);
+                start_babe_service(arg_matches)
             // Unknown error, return it.
             } else {
                 log::error!("Failed to start Babe service: {e:?}");

node/src/consensus/aura_consensus.rs

@@ -120,7 +120,7 @@ impl ConsensusMechanism for AuraConsensus {
         Self {}
     }
 
-    fn build_biq(&mut self) -> Result<BIQ, sc_service::Error>
+    fn build_biq(&mut self) -> Result<BIQ<'_>, sc_service::Error>
     where
         NumberFor<Block>: BlockNumberOps,
     {