Pallet advanced limit orders

Cargo.toml

@@ -57,6 +57,7 @@ useless_conversion = "allow"     # until polkadot is patched
 pallet-alpha-assets = { path = "pallets/alpha-assets", default-features = false }
 node-subtensor-runtime = { path = "runtime", default-features = false }
 pallet-admin-utils = { path = "pallets/admin-utils", default-features = false }
+pallet-limit-orders = { path = "pallets/limit-orders", default-features = false }
 pallet-commitments = { path = "pallets/commitments", default-features = false }
 pallet-registry = { path = "pallets/registry", default-features = false }
 pallet-crowdloan = { path = "pallets/crowdloan", default-features = false }
@@ -72,7 +73,7 @@ subtensor-custom-rpc = { default-features = false, path = "pallets/subtensor/rpc
 subtensor-custom-rpc-runtime-api = { default-features = false, path = "pallets/subtensor/runtime-api" }
 subtensor-precompiles = { default-features = false, path = "precompiles" }
 subtensor-runtime-common = { default-features = false, path = "common" }
-subtensor-swap-interface = { default-features = false, path = "pallets/swap-interface" }
+subtensor-swap-interface = { default-features = false, path = "primitives/swap-interface" }
 subtensor-transaction-fee = { default-features = false, path = "pallets/transaction-fee" }
 subtensor-chain-extensions = { default-features = false, path = "chain-extensions" }
 stp-shield = { git = "https://github.com/opentensor/polkadot-sdk.git", rev = "7cc54bf2d50ae3921d718736dfeb0de9468539c7", default-features = false }

chain-extensions/Cargo.toml

@@ -84,5 +84,6 @@ runtime-benchmarks = [
 	"pallet-subtensor-proxy/runtime-benchmarks",
 	"pallet-subtensor-utility/runtime-benchmarks",
 	"pallet-timestamp/runtime-benchmarks",
-	"subtensor-runtime-common/runtime-benchmarks"
+	"subtensor-runtime-common/runtime-benchmarks",
+	"subtensor-swap-interface/runtime-benchmarks"
 ]

eco-tests/Cargo.toml

@@ -38,7 +38,7 @@ pallet-subtensor-proxy = { path = "../pallets/proxy", default-features = false,
 pallet-subtensor-utility = { path = "../pallets/utility", default-features = false, features = ["std"] }
 pallet-shield = { path = "../pallets/shield", default-features = false, features = ["std"] }
 subtensor-runtime-common = { path = "../common", default-features = false, features = ["std"] }
-subtensor-swap-interface = { path = "../pallets/swap-interface", default-features = false, features = ["std"] }
+subtensor-swap-interface = { path = "../primitives/swap-interface", default-features = false, features = ["std"] }
 share-pool = { path = "../primitives/share-pool", default-features = false, features = ["std"] }
 safe-math = { path = "../primitives/safe-math", default-features = false, features = ["std"] }
 log = { version = "0.4.21", default-features = false, features = ["std"] }

node/src/dev_keystore.rs

@@ -0,0 +1,56 @@
+use stc_shield::MemoryShieldKeystore;
+use stp_shield::{Result as TraitResult, ShieldKeystore};
+
+/// A fixed (non-rotating) shield keystore for single-validator dev/manual-seal nodes.
+///
+/// Uses the same ML-KEM-768 keypair for both `next_enc_key()` and `current_dec_key()`,
+/// bypassing the multi-validator key-rotation timing assumption. In a real multi-validator
+/// AURA chain, each validator builds every Kth block (K≥3), so the keystore rolls at the
+/// same cadence as the on-chain PendingKey pipeline (2-block delay). In single-validator
+/// manual-seal mode the keystore would roll on every block, drifting 2 pairs ahead of
+/// PendingKey. This keystore avoids that by keeping both keys from the same generated pair.
+///
+/// Construction: capture `next_enc_key()` from a fresh `MemoryShieldKeystore`, roll once
+/// so that key becomes current, then freeze. `current_dec_key()` delegates to the inner
+/// store (which now holds the matching pair), and `roll_for_next_slot()` is a no-op.
+pub struct DevShieldKeystore {
+    enc_key_bytes: Vec<u8>,
+    inner: MemoryShieldKeystore,
+}
+
+impl DevShieldKeystore {
+    #[allow(clippy::expect_used)]
+    pub fn new() -> Self {
+        let inner = MemoryShieldKeystore::new();
+        let enc_key_bytes = inner
+            .next_enc_key()
+            .expect("MemoryShieldKeystore always has a next key");
+        inner
+            .roll_for_next_slot()
+            .expect("initial roll should not fail");
+        Self {
+            enc_key_bytes,
+            inner,
+        }
+    }
+}
+
+impl Default for DevShieldKeystore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ShieldKeystore for DevShieldKeystore {
+    fn roll_for_next_slot(&self) -> TraitResult<()> {
+        Ok(())
+    }
+
+    fn next_enc_key(&self) -> TraitResult<Vec<u8>> {
+        Ok(self.enc_key_bytes.clone())
+    }
+
+    fn current_dec_key(&self) -> TraitResult<Vec<u8>> {
+        self.inner.current_dec_key()
+    }
+}

node/src/lib.rs

@@ -4,6 +4,7 @@ pub mod client;
 pub mod clone_spec;
 pub mod conditional_evm_block_import;
 pub mod consensus;
+pub mod dev_keystore;
 pub mod ethereum;
 pub mod rpc;
 pub mod service;

node/src/main.rs

@@ -10,6 +10,7 @@ mod clone_spec;
 mod command;
 mod conditional_evm_block_import;
 mod consensus;
+mod dev_keystore;
 mod ethereum;
 mod rpc;
 mod service;

node/src/service.rs

@@ -544,10 +544,14 @@ where
     .await;
 
     if role.is_authority() {
-        let shield_keystore = Arc::new(MemoryShieldKeystore::new());
-
-        // manual-seal authorship
+        // manual-seal authorship — use a fixed keystore so the single-validator dev
+        // node doesn't drift: MemoryShieldKeystore rolls on every own-block import
+        // (every block in single-validator mode), advancing current_dec_key() 2 pairs
+        // ahead of PendingKey on-chain. DevShieldKeystore avoids this by keeping the
+        // same keypair for both next_enc_key() and current_dec_key().
         if let Some(sealing) = sealing {
+            let dev_shield_keystore: stp_shield::ShieldKeystorePtr =
+                Arc::new(crate::dev_keystore::DevShieldKeystore::new());
             run_manual_seal_authorship(
                 sealing,
                 client,
@@ -558,12 +562,14 @@ where
                 prometheus_registry.as_ref(),
                 telemetry.as_ref(),
                 commands_stream,
-                shield_keystore.clone(),
+                dev_shield_keystore,
             )?;
             log::info!("Manual Seal Ready");
             return Ok(task_manager);
         }
 
+        let shield_keystore = Arc::new(MemoryShieldKeystore::new());
+
         stc_shield::spawn_key_rotation_on_own_import(
             &task_manager.spawn_handle(),
             client.clone(),
@@ -749,7 +755,7 @@ fn run_manual_seal_authorship(
         transaction_pool.clone(),
         prometheus_registry,
         telemetry.as_ref().map(|x| x.handle()),
-        shield_keystore,
+        shield_keystore.clone(),
     );
 
     thread_local!(static TIMESTAMP: RefCell<u64> = const { RefCell::new(0) });
@@ -781,8 +787,15 @@ fn run_manual_seal_authorship(
         }
     }
 
-    let create_inherent_data_providers =
-        move |_, ()| async move { Ok(MockTimestampInherentDataProvider) };
+    let create_inherent_data_providers = move |_, ()| {
+        let keystore = shield_keystore.clone();
+        async move {
+            Ok((
+                MockTimestampInherentDataProvider,
+                stc_shield::InherentDataProvider::new(keystore),
+            ))
+        }
+    };
 
     let aura_data_provider =
         sc_consensus_manual_seal::consensus::aura::AuraConsensusDataProvider::new(client.clone());

pallets/admin-utils/Cargo.toml

@@ -92,6 +92,7 @@ runtime-benchmarks = [
 	"pallet-subtensor-swap/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"subtensor-runtime-common/runtime-benchmarks",
+	"subtensor-swap-interface/runtime-benchmarks",
 ]
 try-runtime = [
 	"frame-support/try-runtime",

pallets/limit-orders/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "pallet-limit-orders"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+codec = { workspace = true, features = ["derive"] }
+frame-benchmarking = { workspace = true, optional = true }
+sp-io = { workspace = true, optional = true }
+sp-keyring = { workspace = true, optional = true }
+frame-support.workspace = true
+frame-system.workspace = true
+scale-info.workspace = true
+sp-core.workspace = true
+sp-runtime.workspace = true
+sp-std.workspace = true
+log.workspace = true
+substrate-fixed.workspace = true
+subtensor-runtime-common.workspace = true
+subtensor-macros.workspace = true
+subtensor-swap-interface.workspace = true
+
+[dev-dependencies]
+sp-io.workspace = true
+sp-keyring.workspace = true
+sp-keystore.workspace = true
+
+[lints]
+workspace = true
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "frame-benchmarking?/std",
+    "frame-support/std",
+    "frame-system/std",
+    "scale-info/std",
+    "sp-core/std",
+    "sp-io?/std",
+    "sp-keyring?/std",
+    "sp-keystore/std",
+    "sp-runtime/std",
+    "sp-std/std",
+    "log/std",
+    "substrate-fixed/std",
+    "subtensor-runtime-common/std",
+    "subtensor-swap-interface/std",
+]
+
+runtime-benchmarks = [
+    "frame-benchmarking/runtime-benchmarks",
+    "frame-support/runtime-benchmarks",
+    "frame-system/runtime-benchmarks",
+    "sp-runtime/runtime-benchmarks",
+    "sp-io",
+    "subtensor-runtime-common/runtime-benchmarks",
+    "subtensor-swap-interface/runtime-benchmarks",
+]