fix conflict

Author: open-junius

node/src/mev_shield/proposer.rs

@@ -568,7 +568,7 @@ where
             timing.clone(),
         );
 
-        // Start last-portion-of-slot revealer (decrypt -> execute_revealed).
+        // Start last-portion-of-slot revealer (decrypt -> submit_one).
         proposer::spawn_revealer::<Block, _, _>(
             &task_manager.spawn_handle(),
             client.clone(),

node/src/service.rs

@@ -38,7 +38,7 @@ sp-consensus-aura.workspace = true
 [dev-dependencies]
 
 [features]
-default = []
+default = ["std"]
 
 std = [
 	"codec/std",

pallets/shield/Cargo.toml

@@ -5,8 +5,8 @@ use frame_support::{BoundedVec, pallet_prelude::ConstU32};
 use frame_system::{RawOrigin, pallet_prelude::BlockNumberFor};
 use sp_core::{crypto::KeyTypeId, sr25519};
 use sp_io::crypto::sr25519_generate;
-use sp_runtime::{AccountId32, MultiSignature, traits::Hash as HashT};
-use sp_std::{boxed::Box, vec, vec::Vec};
+use sp_runtime::{AccountId32, traits::Hash as HashT};
+use sp_std::vec;
 
 /// Helper to build bounded bytes (public key) of a given length.
 fn bounded_pk<const N: u32>(len: usize) -> BoundedVec<u8, ConstU32<N>> {
@@ -103,93 +103,6 @@ mod benches {
         assert_eq!(got.ciphertext.as_slice(), ciphertext.as_slice());
     }
 
-    /// Benchmark `execute_revealed`.
-    #[benchmark]
-    fn execute_revealed() {
-        use codec::Encode;
-        use frame_support::BoundedVec;
-        use sp_core::{crypto::KeyTypeId, sr25519};
-        use sp_io::crypto::{sr25519_generate, sr25519_sign};
-        use sp_runtime::traits::Zero;
-
-        // 1) Generate a dev sr25519 key in the host keystore and derive the account.
-        const KT: KeyTypeId = KeyTypeId(*b"benc");
-        let signer_pub: sr25519::Public = sr25519_generate(KT, Some("//Alice".as_bytes().to_vec()));
-        let signer: AccountId32 = signer_pub.into();
-
-        // 2) Inner call that will be executed as the signer (cheap & always available).
-        let inner_call: <T as pallet::Config>::RuntimeCall = frame_system::Call::<T>::remark {
-            remark: vec![1, 2, 3],
-        }
-        .into();
-
-        // 3) Simulate the MEV‑Shield key epoch at the current block.
-        //
-        // In the real system, KeyHashByBlock[submitted_in] is filled by on_initialize
-        // as hash(CurrentKey). For the benchmark we just use a dummy value and
-        // insert it directly.
-        let submitted_in: BlockNumberFor<T> = frame_system::Pallet::<T>::block_number();
-        let dummy_epoch_bytes: &[u8] = b"benchmark-epoch-key";
-        let key_hash: <T as frame_system::Config>::Hash =
-            <T as frame_system::Config>::Hashing::hash(dummy_epoch_bytes);
-        KeyHashByBlock::<T>::insert(submitted_in, key_hash);
-
-        // 4) Build payload and commitment exactly how the pallet expects:
-        //    payload = signer (32B) || key_hash (T::Hash bytes) || SCALE(call)
-        let mut payload_bytes = Vec::new();
-        payload_bytes.extend_from_slice(signer.as_ref());
-        payload_bytes.extend_from_slice(key_hash.as_ref());
-        payload_bytes.extend(inner_call.encode());
-
-        let commitment: <T as frame_system::Config>::Hash =
-            <T as frame_system::Config>::Hashing::hash(payload_bytes.as_slice());
-
-        // 5) Ciphertext is stored in the submission but not used by `execute_revealed`;
-        //    keep it small and arbitrary.
-        const CT_DEFAULT_LEN: usize = 64;
-        let ciphertext: BoundedVec<u8, ConstU32<8192>> =
-            BoundedVec::truncate_from(vec![0u8; CT_DEFAULT_LEN]);
-
-        // The submission `id` must match pallet's hashing scheme in submit_encrypted.
-        let id: <T as frame_system::Config>::Hash = <T as frame_system::Config>::Hashing::hash_of(
-            &(signer.clone(), commitment, &ciphertext),
-        );
-
-        // 6) Seed the Submissions map with the expected entry.
-        let sub = Submission::<T::AccountId, BlockNumberFor<T>, <T as frame_system::Config>::Hash> {
-            author: signer.clone(),
-            commitment,
-            ciphertext: ciphertext.clone(),
-            submitted_in,
-        };
-        Submissions::<T>::insert(id, sub);
-
-        // 7) Domain-separated signing as in pallet:
-        //    "mev-shield:v1" || genesis_hash || payload
-        let zero: BlockNumberFor<T> = Zero::zero();
-        let genesis = frame_system::Pallet::<T>::block_hash(zero);
-        let mut msg = b"mev-shield:v1".to_vec();
-        msg.extend_from_slice(genesis.as_ref());
-        msg.extend_from_slice(&payload_bytes);
-
-        let sig = sr25519_sign(KT, &signer_pub, &msg).expect("signing should succeed in benches");
-        let signature: MultiSignature = sig.into();
-
-        // 8) Measure: dispatch the unsigned extrinsic (RawOrigin::None) with a valid wrapper.
-        #[extrinsic_call]
-        execute_revealed(
-            RawOrigin::None,
-            id,
-            signer.clone(),
-            key_hash,
-            Box::new(inner_call.clone()),
-            signature.clone(),
-        );
-
-        // 9) Assert: submission consumed.
-        assert!(Submissions::<T>::get(id).is_none());
-    }
-
     /// Benchmark `mark_decryption_failed`.
     #[benchmark]
     fn mark_decryption_failed() {

pallets/shield/src/benchmarking.rs

@@ -28,8 +28,8 @@ pub mod pallet {
         InvalidTransaction, TransactionSource, ValidTransaction,
     };
     use sp_runtime::{
-        AccountId32, DispatchErrorWithPostInfo, MultiSignature, RuntimeDebug, Saturating,
-        traits::{BadOrigin, Dispatchable, Hash, Verify},
+        AccountId32, DispatchErrorWithPostInfo, RuntimeDebug, Saturating,
+        traits::{BadOrigin, Hash},
     };
     use sp_std::{marker::PhantomData, prelude::*};
     use subtensor_macros::freeze_struct;
@@ -330,91 +330,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// Executed by the block author after decrypting a batch of wrappers.
-        ///
-        /// The author passes in:
-        ///
-        ///   * `id`       – wrapper id (hash of (author, commitment, ciphertext))
-        ///   * `signer`   – account that should be treated as the origin of `call`
-        ///   * `key_hash` – 32‑byte hash the client embedded (and signed) in the payload
-        ///   * `call`     – inner RuntimeCall to execute on behalf of `signer`
-        ///   * `signature` – MultiSignature over the domain‑separated payload
-        ///
-        #[pallet::call_index(2)]
-        #[pallet::weight((
-            Weight::from_parts(77_280_000, 0)
-                .saturating_add(T::DbWeight::get().reads(4_u64))
-                .saturating_add(T::DbWeight::get().writes(1_u64)),
-            DispatchClass::Normal,
-            Pays::No
-        ))]
-        #[allow(clippy::useless_conversion)]
-        pub fn execute_revealed(
-            origin: OriginFor<T>,
-            id: T::Hash,
-            signer: T::AccountId,
-            key_hash: T::Hash,
-            call: Box<<T as Config>::RuntimeCall>,
-            signature: MultiSignature,
-        ) -> DispatchResultWithPostInfo {
-            // Unsigned: only the author node may inject this via ValidateUnsigned.
-            ensure_none(origin)?;
-
-            // 1) Load and consume the submission.
-            let Some(sub) = Submissions::<T>::take(id) else {
-                return Err(Error::<T>::MissingSubmission.into());
-            };
-
-            // 2) Bind to the MEV‑Shield key epoch at submit time.
-            let expected_key_hash =
-                KeyHashByBlock::<T>::get(sub.submitted_in).ok_or(Error::<T>::KeyExpired)?;
-
-            ensure!(key_hash == expected_key_hash, Error::<T>::KeyHashMismatch);
-
-            // 3) Rebuild the same payload bytes the client used for both
-            //    commitment and signature.
-            let payload_bytes = Self::build_raw_payload_bytes(&signer, &key_hash, call.as_ref());
-
-            // 4) Commitment check against on-chain stored commitment.
-            let recomputed: T::Hash = T::Hashing::hash(&payload_bytes);
-            ensure!(sub.commitment == recomputed, Error::<T>::CommitmentMismatch);
-
-            // 5) Signature check over the same payload, with domain separation
-            //    and genesis hash to make signatures chain‑bound.
-            let genesis = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
-            let mut msg = b"mev-shield:v1".to_vec();
-            msg.extend_from_slice(genesis.as_ref());
-            msg.extend_from_slice(&payload_bytes);
-
-            let sig_ok = signature.verify(msg.as_slice(), &signer);
-            ensure!(sig_ok, Error::<T>::SignatureInvalid);
-
-            // 6) Dispatch inner call from signer.
-            let info = call.get_dispatch_info();
-            let required = info.call_weight.saturating_add(info.extension_weight);
-
-            let origin_signed = frame_system::RawOrigin::Signed(signer.clone()).into();
-            let res = (*call).dispatch(origin_signed);
-
-            match res {
-                Ok(post) => {
-                    let actual = post.actual_weight.unwrap_or(required);
-                    Self::deposit_event(Event::DecryptedExecuted { id, signer });
-                    Ok(PostDispatchInfo {
-                        actual_weight: Some(actual),
-                        pays_fee: Pays::No,
-                    })
-                }
-                Err(e) => {
-                    Self::deposit_event(Event::DecryptedRejected { id, reason: e });
-                    Ok(PostDispatchInfo {
-                        actual_weight: Some(required),
-                        pays_fee: Pays::No,
-                    })
-                }
-            }
-        }
-
         /// Marks a submission as failed to decrypt and removes it from storage.
         ///
         /// Called by the block author when decryption fails at any stage (e.g., ML-KEM decapsulate
@@ -453,48 +368,12 @@ pub mod pallet {
         }
     }
 
-    impl<T: Config> Pallet<T> {
-        /// Build the raw payload bytes used for both:
-        ///
-        ///   * `commitment = T::Hashing::hash(raw_payload)`
-        ///   * signature message (after domain separation)
-        ///
-        /// Layout:
-        ///
-        ///   signer (32B) || key_hash (T::Hash bytes) || SCALE(call)
-        fn build_raw_payload_bytes(
-            signer: &T::AccountId,
-            key_hash: &T::Hash,
-            call: &<T as Config>::RuntimeCall,
-        ) -> Vec<u8> {
-            let mut out = Vec::new();
-            out.extend_from_slice(signer.as_ref());
-            out.extend_from_slice(key_hash.as_ref());
-            out.extend(call.encode());
-            out
-        }
-    }
-
     #[pallet::validate_unsigned]
     impl<T: Config> ValidateUnsigned for Pallet<T> {
         type Call = Call<T>;
 
         fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity {
             match call {
-                Call::execute_revealed { id, .. } => {
-                    match source {
-                        // Only allow locally-submitted / already-in-block txs.
-                        TransactionSource::Local | TransactionSource::InBlock => {
-                            ValidTransaction::with_tag_prefix("mev-shield-exec")
-                                .priority(1u64)
-                                .longevity(64) // long because propagate(false)
-                                .and_provides(id) // dedupe by wrapper id
-                                .propagate(false) // CRITICAL: no gossip, stays on author node
-                                .build()
-                        }
-                        _ => InvalidTransaction::Call.into(),
-                    }
-                }
                 Call::mark_decryption_failed { id, .. } => {
                     match source {
                         TransactionSource::Local | TransactionSource::InBlock => {