MempoolLoadType::NonUniformLoad {
    /// Base transaction count
    base_count: usize,

    /// Base transaction size
    base_size: usize,

    /// How much the transaction count can vary
    count_variation: std::ops::Range<i32>,

    size_variation: std::ops::Range<i32>,

    /// Chance of generating a spike.
    /// e.g. 0.1 = 10% chance of spike
    spike_probability: f64,

    /// Multiplier for spike transactions
    /// e.g. 10 = 10x more transactions during spike
    spike_multiplier: usize,

    /// Range of intervals between generating load, in milliseconds
    sleep_interval: std::ops::Range<u64>,
}

tokio::spawn(move async {
// Determine if this iteration should generate a spike
let is_spike = rng.gen_bool(params.spike_probability);

// Vary transaction count and size
let count_variation = rng.gen_range(params.count_variation);
let size_variation = rng.gen_range(params.size_variation);

let count = if is_spike {
    (params.base_count + count_variation) * params.spike_multiplier
} else {
    params.base_count + count_variation
};

let size = params.base_size + size_variation;

// Create and send the message
let msg = HostMsg::GenerateTransactions {
    count: count.max(1), // Ensure count is at least 1
    size: size.max(1),   // Ensure size is at least 1
};

if myself.send(msg).is_err() {
    println!("Channel closed, stopping load generator");
    break;
}

// Random sleep between 100ms and 1s
let sleep_duration = Duration::from_millis(params.sleep_interval);
sleep(sleep_duration);