Merge pull request #2270 from opentensor/mevshield-dynmaic-tx-construction

MevShield - Dynamic Transaction Construction

Author: sam0x17

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::transaction_payment_wrapper::ChargeTransactionPaymentWrapper::<
@@ -389,21 +401,35 @@ 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 = ()
-        (),                                   // 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 = ()
+        (),           // ChargeTransactionPaymentWrapper::Implicit = ()
+        (),           // SubtensorTransactionExtension::Implicit = ()
+        (),           // DrandPriority::Implicit = ()
+        None,         // CheckMetadataHash::Implicit = Option<[u8; 32]>
     );
 
     // 4) Build the exact signable payload from call + extra + implicit.
@@ -433,12 +459,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(())