Merge branch 'feat/reject-incorrect-sudo-exts' of github.com:opentensor/subtensor into feat/reject-incorrect-sudo-exts

grbIzl · grbIzl · commit b717be501597 · 2025-12-11T17:34:46.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/chain-extensions/Cargo.toml b/chain-extensions/Cargo.toml
@@ -34,6 +34,7 @@ pallet-subtensor-proxy.workspace = true
 pallet-drand.workspace = true
 subtensor-swap-interface.workspace = true
 num_enum.workspace = true
+substrate-fixed.workspace = true
 
 [lints]
 workspace = true
@@ -64,4 +65,5 @@ std = [
 	"pallet-drand/std",
 	"subtensor-swap-interface/std",
 	"num_enum/std",
+	"substrate-fixed/std",
 ]
diff --git a/chain-extensions/src/lib.rs b/chain-extensions/src/lib.rs
@@ -18,7 +18,9 @@ use pallet_subtensor_proxy as pallet_proxy;
 use pallet_subtensor_proxy::WeightInfo;
 use sp_runtime::{DispatchError, Weight, traits::StaticLookup};
 use sp_std::marker::PhantomData;
+use substrate_fixed::types::U96F32;
 use subtensor_runtime_common::{AlphaCurrency, NetUid, ProxyType, TaoCurrency};
+use subtensor_swap_interface::SwapHandler;
 
 #[derive(DebugNoBound)]
 pub struct SubtensorChainExtension<T>(PhantomData<T>);
@@ -33,7 +35,8 @@ impl<T> ChainExtension<T> for SubtensorChainExtension<T>
 where
     T: pallet_subtensor::Config
         + pallet_contracts::Config
-        + pallet_proxy::Config<ProxyType = ProxyType>,
+        + pallet_proxy::Config<ProxyType = ProxyType>
+        + pallet_subtensor_swap::Config,
     T::AccountId: Clone,
     <<T as SysConfig>::Lookup as StaticLookup>::Source: From<<T as SysConfig>::AccountId>,
 {
@@ -54,7 +57,8 @@ impl<T> SubtensorChainExtension<T>
 where
     T: pallet_subtensor::Config
         + pallet_contracts::Config
-        + pallet_proxy::Config<ProxyType = ProxyType>,
+        + pallet_proxy::Config<ProxyType = ProxyType>
+        + pallet_subtensor_swap::Config,
     T::AccountId: Clone,
 {
     fn dispatch<Env>(env: &mut Env) -> Result<RetVal, DispatchError>
@@ -506,6 +510,26 @@ where
                     }
                 }
             }
+            FunctionId::GetAlphaPriceV1 => {
+                let netuid: NetUid = env
+                    .read_as()
+                    .map_err(|_| DispatchError::Other("Failed to decode input parameters"))?;
+
+                let current_alpha_price =
+                    <pallet_subtensor_swap::Pallet<T> as SwapHandler>::current_alpha_price(
+                        netuid.into(),
+                    );
+
+                let price = current_alpha_price.saturating_mul(U96F32::from_num(1_000_000_000));
+                let price: u64 = price.saturating_to_num();
+
+                let encoded_result = price.encode();
+
+                env.write_output(&encoded_result)
+                    .map_err(|_| DispatchError::Other("Failed to write output"))?;
+
+                Ok(RetVal::Converging(Output::Success as u32))
+            }
         }
     }
 }
diff --git a/chain-extensions/src/tests.rs b/chain-extensions/src/tests.rs
@@ -2,14 +2,15 @@
 
 use super::{SubtensorChainExtension, SubtensorExtensionEnv, mock};
 use crate::types::{FunctionId, Output};
-use codec::Encode;
+use codec::{Decode, Encode};
 use frame_support::{assert_ok, weights::Weight};
 use frame_system::RawOrigin;
 use pallet_contracts::chain_extension::RetVal;
 use pallet_subtensor::DefaultMinStake;
 use sp_core::Get;
 use sp_core::U256;
 use sp_runtime::DispatchError;
+use substrate_fixed::types::U96F32;
 use subtensor_runtime_common::{AlphaCurrency, Currency as CurrencyTrait, NetUid, TaoCurrency};
 use subtensor_swap_interface::SwapHandler;
 
@@ -964,3 +965,41 @@ fn unstake_all_success_unstakes_balance() {
         assert!(post_balance > pre_balance);
     });
 }
+
+#[test]
+fn get_alpha_price_returns_encoded_price() {
+    mock::new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(8001);
+        let owner_coldkey = U256::from(8002);
+        let caller = U256::from(8003);
+
+        let netuid = mock::add_dynamic_network(&owner_hotkey, &owner_coldkey);
+
+        // Set up reserves to establish a price
+        let tao_reserve = TaoCurrency::from(150_000_000_000u64);
+        let alpha_reserve = AlphaCurrency::from(100_000_000_000u64);
+        mock::setup_reserves(netuid, tao_reserve, alpha_reserve);
+
+        // Get expected price from swap handler
+        let expected_price =
+            <pallet_subtensor_swap::Pallet<mock::Test> as SwapHandler>::current_alpha_price(
+                netuid.into(),
+            );
+        let expected_price_scaled = expected_price.saturating_mul(U96F32::from_num(1_000_000_000));
+        let expected_price_u64: u64 = expected_price_scaled.saturating_to_num();
+
+        let mut env = MockEnv::new(FunctionId::GetAlphaPriceV1, caller, netuid.encode());
+
+        let ret = SubtensorChainExtension::<mock::Test>::dispatch(&mut env).unwrap();
+        assert_success(ret);
+        assert!(env.charged_weight().is_none());
+
+        // Decode the output
+        let output_price: u64 = Decode::decode(&mut &env.output()[..]).unwrap();
+
+        assert_eq!(
+            output_price, expected_price_u64,
+            "Price should match expected value"
+        );
+    });
+}
diff --git a/chain-extensions/src/types.rs b/chain-extensions/src/types.rs
@@ -20,6 +20,7 @@ pub enum FunctionId {
     SetColdkeyAutoStakeHotkeyV1 = 12,
     AddProxyV1 = 13,
     RemoveProxyV1 = 14,
+    GetAlphaPriceV1 = 15,
 }
 
 #[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, Debug)]
diff --git a/contract-tests/bittensor/lib.rs b/contract-tests/bittensor/lib.rs
@@ -22,6 +22,7 @@ pub enum FunctionId {
     SetColdkeyAutoStakeHotkeyV1 = 12,
     AddProxyV1 = 13,
     RemoveProxyV1 = 14,
+    GetAlphaPriceV1 = 15,
 }
 
 #[ink::chain_extension(extension = 0x1000)]
@@ -127,6 +128,9 @@ pub trait RuntimeReadWrite {
 
     #[ink(function = 14)]
     fn remove_proxy(delegate: <CustomEnvironment as ink::env::Environment>::AccountId);
+
+    #[ink(function = 15)]
+    fn get_alpha_price(netuid: NetUid) -> u64;
 }
 
 #[ink::scale_derive(Encode, Decode, TypeInfo)]
@@ -412,5 +416,13 @@ mod bittensor {
                 .remove_proxy(delegate.into())
                 .map_err(|_e| ReadWriteErrorCode::WriteFailed)
         }
+
+        #[ink(message)]
+        pub fn get_alpha_price(&self, netuid: u16) -> Result<u64, ReadWriteErrorCode> {
+            self.env()
+                .extension()
+                .get_alpha_price(netuid.into())
+                .map_err(|_e| ReadWriteErrorCode::ReadFailed)
+        }
     }
 }
diff --git a/contract-tests/run-ci.sh b/contract-tests/run-ci.sh
@@ -2,6 +2,16 @@
 
 echo "start run-ci.sh"
 
+cd contract-tests
+
+cd bittensor
+
+rustup component add rust-src
+cargo install cargo-contract 
+cargo contract build --release 
+
+cd ../..
+
 scripts/localnet.sh &>/dev/null &
 
 i=1
@@ -15,7 +25,7 @@ while [ $i -le 2000 ]; do
 done
 
 # port not available exit with error
-if [ "$i" -eq 1000 ]; then
+if [ "$i" -eq 2000 ]; then
     exit 1
 fi
 
@@ -28,14 +38,6 @@ fi
 
 cd contract-tests
 
-cd bittensor
-
-rustup component add rust-src
-cargo install cargo-contract 
-cargo contract build --release 
-
-cd ..
-
 # required for papi in get-metadata.sh, but we cannot run yarn before papi as it adds the descriptors to the package.json which won't resolve
 npm i -g polkadot-api
 
diff --git a/contract-tests/test/wasm.contract.test.ts b/contract-tests/test/wasm.contract.test.ts
@@ -563,4 +563,25 @@ describe("Test wasm contract", () => {
         assert.ok(proxiesAfterRemove !== undefined)
         assert.ok(proxiesAfterRemove[0].length === 0)
     })
+
+    it("Can get alpha price", async () => {
+        const message = inkClient.message("get_alpha_price")
+        const data = message.encode({
+            netuid: netuid,
+        })
+
+        const response = await api.apis.ContractsApi.call(
+            convertPublicKeyToSs58(hotkey.publicKey),
+            contractAddress,
+            BigInt(0),
+            undefined,
+            undefined,
+            Binary.fromBytes(data.asBytes()),
+        )
+
+        assert.ok(response.result.success)
+        const result = message.decode(response.result.value).value.value
+
+        assert.ok(result !== undefined)
+    })
 });
diff --git a/node/src/mev_shield/author.rs b/node/src/mev_shield/author.rs
@@ -316,7 +316,8 @@ pub async fn submit_announce_extrinsic<B, C, Pool>(
 ) -> anyhow::Result<()>
 where
     B: sp_runtime::traits::Block,
-    C: sc_client_api::HeaderBackend<B> + Send + Sync + 'static,
+    C: sc_client_api::HeaderBackend<B> + sp_api::ProvideRuntimeApi<B> + Send + Sync + 'static,
+    C::Api: sp_api::Core<B>,
     Pool: sc_transaction_pool_api::TransactionPool<Block = B> + Send + Sync + 'static,
     B::Extrinsic: From<sp_runtime::OpaqueExtrinsic>,
     B::Hash: AsRef<[u8]>,
@@ -325,12 +326,13 @@ where
     use runtime::{RuntimeCall, SignedPayload, UncheckedExtrinsic};
 
     use sc_transaction_pool_api::TransactionSource;
+    use sp_api::Core as _;
     use sp_core::H256;
     use sp_runtime::codec::Encode;
     use sp_runtime::{
         BoundedVec, MultiSignature,
         generic::Era,
-        traits::{ConstU32, TransactionExtension},
+        traits::{ConstU32, SaturatedConversion, TransactionExtension},
     };
 
     fn to_h256<H: AsRef<[u8]>>(h: H) -> H256 {
@@ -365,13 +367,23 @@ where
 
     // 2) Build the transaction extensions exactly like the runtime.
     type Extra = runtime::TransactionExtensions;
+
+    let info = client.info();
+    let at_hash = info.best_hash;
+    let at_hash_h256: H256 = to_h256(at_hash);
+    let genesis_h256: H256 = to_h256(info.genesis_hash);
+
+    const ERA_PERIOD: u64 = 12;
+    let current_block: u64 = info.best_number.saturated_into();
+    let era = Era::mortal(ERA_PERIOD, current_block);
+
     let extra: Extra =
         (
             frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
             frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
             frame_system::CheckTxVersion::<runtime::Runtime>::new(),
             frame_system::CheckGenesis::<runtime::Runtime>::new(),
-            frame_system::CheckEra::<runtime::Runtime>::from(Era::Immortal),
+            frame_system::CheckEra::<runtime::Runtime>::from(era),
             node_subtensor_runtime::check_nonce::CheckNonce::<runtime::Runtime>::from(nonce).into(),
             frame_system::CheckWeight::<runtime::Runtime>::new(),
             node_subtensor_runtime::sudo_wrapper::SudoTransactionExtension::<runtime::Runtime>::new(
@@ -391,22 +403,36 @@ where
     // 3) Manually construct the `Implicit` tuple that the runtime will also derive.
     type Implicit = <Extra as TransactionExtension<RuntimeCall>>::Implicit;
 
-    let info = client.info();
-    let genesis_h256: H256 = to_h256(info.genesis_hash);
+    // Try to get the *current* runtime version from on-chain WASM; if that fails,
+    // fall back to the compiled runtime::VERSION.
+    let (spec_version, tx_version) = match client.runtime_api().version(at_hash) {
+        Ok(v) => (v.spec_version, v.transaction_version),
+        Err(e) => {
+            log::debug!(
+                target: "mev-shield",
+                "runtime_api::version failed at_hash={at_hash:?}: {e:?}; \
+                 falling back to compiled runtime::VERSION",
+            );
+            (
+                runtime::VERSION.spec_version,
+                runtime::VERSION.transaction_version,
+            )
+        }
+    };
 
     let implicit: Implicit = (
-        (),                                   // CheckNonZeroSender
-        runtime::VERSION.spec_version,        // CheckSpecVersion::Implicit = u32
-        runtime::VERSION.transaction_version, // CheckTxVersion::Implicit = u32
-        genesis_h256,                         // CheckGenesis::Implicit = Hash
-        genesis_h256,                         // CheckEra::Implicit (Immortal => genesis hash)
-        (),                                   // CheckNonce::Implicit = ()
-        (),                                   // CheckWeight::Implicit = ()
-        (),                                   // SudoTransactionExtension::Implicit = ()
-        (),                                   // ChargeTransactionPaymentWrapper::Implicit = ()
-        (),                                   // SubtensorTransactionExtension::Implicit = ()
-        (),                                   // DrandPriority::Implicit = ()
-        None,                                 // CheckMetadataHash::Implicit = Option<[u8; 32]>
+        (),           // CheckNonZeroSender
+        spec_version, // dynamic or fallback spec_version
+        tx_version,   // dynamic or fallback transaction_version
+        genesis_h256, // CheckGenesis::Implicit = Hash
+        at_hash_h256, // CheckEra::Implicit = hash of the block the tx is created at
+        (),           // CheckNonce::Implicit = ()
+        (),           // CheckWeight::Implicit = ()
+        (),           // SudoTransactionExtension::Implicit = ()
+        (),           // ChargeTransactionPaymentWrapper::Implicit = ()
+        (),           // SubtensorTransactionExtension::Implicit = ()
+        (),           // DrandPriority::Implicit = ()
+        None,         // CheckMetadataHash::Implicit = Option<[u8; 32]>
     );
 
     // 4) Build the exact signable payload from call + extra + implicit.
@@ -436,12 +462,13 @@ where
     let opaque: sp_runtime::OpaqueExtrinsic = uxt.into();
     let xt: <B as sp_runtime::traits::Block>::Extrinsic = opaque.into();
 
-    pool.submit_one(info.best_hash, TransactionSource::Local, xt)
+    pool.submit_one(at_hash, TransactionSource::Local, xt)
         .await?;
 
     log::debug!(
         target: "mev-shield",
-        "announce_next_key submitted: xt=0x{xt_hash_hex}, nonce={nonce:?}",
+        "announce_next_key submitted: xt=0x{xt_hash_hex}, nonce={nonce:?}, \
+         spec_version={spec_version}, tx_version={tx_version}, era={era:?}",
     );
 
     Ok(())
diff --git a/pallets/subtensor/src/staking/remove_stake.rs b/pallets/subtensor/src/staking/remove_stake.rs
diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ pub enum FunctionId {`
`20`	`20`	`SetColdkeyAutoStakeHotkeyV1 = 12,`
`21`	`21`	`AddProxyV1 = 13,`
`22`	`22`	`RemoveProxyV1 = 14,`
	`23`	`+ GetAlphaPriceV1 = 15,`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`#[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ pub enum FunctionId {`
`22`	`22`	`SetColdkeyAutoStakeHotkeyV1 = 12,`
`23`	`23`	`AddProxyV1 = 13,`
`24`	`24`	`RemoveProxyV1 = 14,`
	`25`	`+ GetAlphaPriceV1 = 15,`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`#[ink::chain_extension(extension = 0x1000)]`
`@@ -127,6 +128,9 @@ pub trait RuntimeReadWrite {`
`127`	`128`
`128`	`129`	`#[ink(function = 14)]`
`129`	`130`	`fn remove_proxy(delegate: <CustomEnvironment as ink::env::Environment>::AccountId);`
	`131`	`+`
	`132`	`+ #[ink(function = 15)]`
	`133`	`+ fn get_alpha_price(netuid: NetUid) -> u64;`
`130`	`134`	`}`
`131`	`135`
`132`	`136`	`#[ink::scale_derive(Encode, Decode, TypeInfo)]`
`@@ -412,5 +416,13 @@ mod bittensor {`
`412`	`416`	`.remove_proxy(delegate.into())`
`413`	`417`	`.map_err(\|_e\| ReadWriteErrorCode::WriteFailed)`
`414`	`418`	`}`
	`419`	`+`
	`420`	`+ #[ink(message)]`
	`421`	`+ pub fn get_alpha_price(&self, netuid: u16) -> Result<u64, ReadWriteErrorCode> {`
	`422`	`+ self.env()`
	`423`	`+ .extension()`
	`424`	`+ .get_alpha_price(netuid.into())`
	`425`	`+ .map_err(\|_e\| ReadWriteErrorCode::ReadFailed)`
	`426`	`+ }`
`415`	`427`	`}`
`416`	`428`	`}`