if all the channels are the same size we should probably make this configurable and use a default channel size

Yeah we have this problem all over the codebase. Definitely something we should clean up. I think we should just have a concept of an unbounded_channel that we use in most places.

yeh I think we could clean up the thread messaging a bit by using some type of event passing structure that can handle easy iterations of the codebase.

I am going to play around with it over the weekend and see what I can come up with.

pub struct Engine<E, A> {
    /// The set of collectors that the engine will use to collect events.
    collectors: Vec<Box<dyn Collector<E>>>,

    /// The set of executors that the engine will use to execute actions.
    executors: Vec<Box<dyn Executor<A>>>,

    /// The capacity of the event channel.
    event_channel_capacity: usize,

    /// The capacity of the action channel.
    action_channel_capacity: usize,
}

Something like this then we can have a collector trait that listens for new block events and exectutors that can process the events and bundle the user ops.

will most likely take a while to get right but will let you know how I go