Remove invalid bundles in the process of compiling bundles to extrinsics

crates/sp-domains/Cargo.toml

@@ -34,6 +34,9 @@ subspace-core-primitives = { version = "0.1.0", default-features = false, path =
 subspace-runtime-primitives = { version = "0.1.0", default-features = false, path = "../subspace-runtime-primitives" }
 thiserror = { version = "1.0.38", optional = true }
 
+[dev-dependencies]
+num-traits = "0.2.15"
+
 [features]
 default = ["std"]
 std = [

crates/sp-domains/src/lib.rs

@@ -20,6 +20,8 @@
 pub mod bundle_producer_election;
 pub mod fraud_proof;
 pub mod merkle_tree;
+#[cfg(test)]
+mod tests;
 pub mod transaction;
 
 use bundle_producer_election::{BundleProducerElectionParams, VrfProofError};
@@ -40,7 +42,7 @@ use sp_runtime_interface::{pass_by, runtime_interface};
 use sp_std::vec::Vec;
 use sp_weights::Weight;
 use subspace_core_primitives::crypto::blake2b_256_hash;
-use subspace_core_primitives::{Blake2b256Hash, Randomness, U256};
+use subspace_core_primitives::{bidirectional_distance, Blake2b256Hash, Randomness, U256};
 use subspace_runtime_primitives::{Balance, Moment};
 
 /// Key type for Operator.
@@ -569,6 +571,12 @@ pub struct DomainBlockLimit {
     pub max_block_weight: Weight,
 }
 
+/// Checks if the signer Id hash is within the tx range
+pub fn signer_in_tx_range(bundle_vrf_hash: &U256, signer_id_hash: &U256, tx_range: &U256) -> bool {
+    let distance_from_vrf_hash = bidirectional_distance(bundle_vrf_hash, signer_id_hash);
+    distance_from_vrf_hash <= (*tx_range / 2)
+}
+
 sp_api::decl_runtime_apis! {
     /// API necessary for domains pallet.
     pub trait DomainsApi<DomainNumber: Encode + Decode, DomainHash: Encode + Decode> {

crates/sp-domains/src/tests.rs

@@ -0,0 +1,209 @@
+use crate::signer_in_tx_range;
+use num_traits::ops::wrapping::{WrappingAdd, WrappingSub};
+use subspace_core_primitives::U256;
+
+#[test]
+fn test_tx_range() {
+    let tx_range = U256::MAX / 4;
+    let bundle_vrf_hash = U256::MAX / 2;
+
+    let signer_id_hash = bundle_vrf_hash + U256::from(10_u64);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::from(10_u64);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 8;
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 8;
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 8 + U256::from(1_u64);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 8 - U256::from(1_u64);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 4;
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 4;
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+}
+
+#[test]
+fn test_tx_range_wrap_under_flow() {
+    let tx_range = U256::MAX / 4;
+    let bundle_vrf_hash = U256::from(100_u64);
+
+    let signer_id_hash = bundle_vrf_hash + U256::from(1000_u64);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash.wrapping_sub(&U256::from(1000_u64));
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 8;
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 8;
+    let signer_id_hash = bundle_vrf_hash.wrapping_sub(&v);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 8 + U256::from(1_u64);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 8 + U256::from(1_u64);
+    let signer_id_hash = bundle_vrf_hash.wrapping_sub(&v);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash + U256::MAX / 4;
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 4;
+    let signer_id_hash = bundle_vrf_hash.wrapping_sub(&v);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+}
+
+#[test]
+fn test_tx_range_wrap_over_flow() {
+    let tx_range = U256::MAX / 4;
+    let v = U256::MAX;
+    let bundle_vrf_hash = v.wrapping_sub(&U256::from(100_u64));
+
+    let signer_id_hash = bundle_vrf_hash.wrapping_add(&U256::from(1000_u64));
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::from(1000_u64);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 8;
+    let signer_id_hash = bundle_vrf_hash.wrapping_add(&v);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 8;
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 8 + U256::from(1_u64);
+    let signer_id_hash = bundle_vrf_hash.wrapping_add(&v);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 8 - U256::from(1_u64);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let v = U256::MAX / 4;
+    let signer_id_hash = bundle_vrf_hash.wrapping_add(&v);
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+
+    let signer_id_hash = bundle_vrf_hash - U256::MAX / 4;
+    assert!(!signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+}
+
+#[test]
+fn test_tx_range_max() {
+    let tx_range = U256::MAX;
+    let bundle_vrf_hash = U256::MAX / 2;
+
+    let signer_id_hash = bundle_vrf_hash + U256::from(10_u64);
+    assert!(signer_in_tx_range(
+        &bundle_vrf_hash,
+        &signer_id_hash,
+        &tx_range
+    ));
+}