refactor: Streamline access shared utilities

[scarmuega]

The utils module includes general-purpose utilities that could potentially be used by more than a single stage. Up to this point, access to the utilities was ad-hoc and internal to the code of each stage. This approach is suboptimal in terms of memory (excessive cloning) and prevents from implementing utilities that share a state between stages.

This PR introduces a new struct Utils that serves as an entry point that follows a singelton pattern, all stages share the same instance via an Arc pointer.

This change affects the stage bootstrapping procedure, which resulted in a lot of changes throughout the codebase. Don't be alarmed, is mostly boilerplate.

[pavlix]

Won't this complicate the future standalone usage of the EventWriter?

This is what I'm currently doing:

let writer = EventWriter::new(output_tx, None, mapper);

Now it looks like I need to do this:

let writer = EventWriter::new(output_tx, Arc::new(Utils::new(ChainWellKnownInfo::mainnet())), mapper);

Not a huge deal but I'm still interested in getting a rather simple convertor object for simple purposes and more complex confiugration only when it's needed.

This works with the following patch:

diff --git a/src/mapper/prelude.rs b/src/mapper/prelude.rs
index b6bceb2..801017a 100644
--- a/src/mapper/prelude.rs
+++ b/src/mapper/prelude.rs
@@ -95,7 +95,7 @@ pub struct Config {
 }

 #[derive(Clone)]
-pub(crate) struct EventWriter {
+pub struct EventWriter {
     context: EventContext,
     output: StageSender,
     time_provider: Option<NaiveTime>,

Code sample:

https://github.com/txpipe/oura/tree/pavlix-cip15

I'm sorry if the name of the branch doesn't fit your workflow, but it's not even really a feature branch at the moment, rather a scratch branch to keep the examples public.

[rvcas]

I'll take a look as soon as I start my day tomorrow.

[scarmuega]

@pavlix thanks for the feedback. I wasn't taking into account that use-case, which I think makes a lot of sense. It could also be used for some blackbox testing of the mapper (putting a known block and expecting a known set of events).

To address your concern, I've added the following constructor to the EventMapper:

pub fn standalone(
        output: StageSender,
        well_known: Option<ChainWellKnownInfo>,
        config: Config,
    ) -> Self {
        let utils = Arc::new(Utils::new(well_known.unwrap_or_default()));

        Self::new(output, utils, config)
    }

In this way, we could create a new one by calling EventMapper::standalone(output, None, config). Does that make sense?

[rvcas]

awesome :)

[rvcas]

typo: designed

[rvcas]

This looks good to me. Other than the typo I don't see any problems. I didn't request changes because that typo doesn't affect the code. I didn't press approve because I assume we're waiting for @pavlix to reply to your latest changes :).

[mark-stopka]

Merged in now, thank you all contributors!