[RPC] Sequencer management rpc

[frisitano]

Overview

We should introduce an rpc extension that allows us to enable/disable the Sequencer. We should leverage reths' native rpc extension capabilities.

[greged93]

linked to #235

[frisitano]

Context

We want to introduce an rpc extension such that we can perform administrative tasks on the rollup node manager. To achieve this, we will leverage the RollupManagerHandle. We observe a circular dependency; the RollupNodeManager requires an rpc handle and in turn the rpc extension requires a handle to the rollup node manager.

Solution

We introduce a rpc extension type of the form:

use tokio::sync::{oneshot, Mutex, OnceCell};

pub struct ScrollRpcExt {
    /// The rollup manager handle
    handle: tokio::sync::OnceCell<RollupManagerHandle<ScrollNetworkPrimitives>>,
    /// Oneshot channel for receiving the rollup manager handle
    rx: Mutex<Option<oneshot::Receiver<RollupManagerHandle<ScrollNetworkPrimitives>>>>,
}

impl ScrollRpcExt {
    pub fn new(rx: oneshot::Receiver<RollupManagerHandle<ScrollNetworkPrimitives>>) -> Self {
        Self { rx: Mutex::new(Some(rx)), handle: OnceCell::new() }
    }

    async fn rollup_manager_handle(
        &self,
    ) -> eyre::Result<&RollupManagerHandle<ScrollNetworkPrimitives>> {
        self.handle
            .get_or_try_init(|| async {
                let rx = {
                    let mut g = self.rx.lock().await;
                    g.take().ok_or_else(|| eyre::eyre!("receiver already consumed"))?
                };
                rx.await.map_err(|e| eyre::eyre!("failed to receive handle: {e}"))
            })
            .await
    }
}

The rpc methods should be implemented following the example here.

We should then integrate this into the node in ScrollRollupNodeAddons:

rollup-node/crates/node/src/add_ons/mod.rs

Lines 121 to 136 in 892a314

	async fn launch_add_ons(self, ctx: AddOnsContext<'_, N>) -> eyre::Result<Self::Handle> {
	let Self { mut rpc_add_ons, rollup_manager_addon: rollup_node_manager_addon } = self;
	rpc_add_ons.eth_api_builder.with_propagate_local_transactions(
	!ctx.config.txpool.no_local_transactions_propagation,
	);
	let rpc_handle = rpc_add_ons.launch_add_ons_with(ctx.clone(), |_| Ok(())).await?;
	let (rollup_manager_handle, l1_watcher_tx) =
	rollup_node_manager_addon.launch(ctx.clone(), rpc_handle.clone()).await?;
	Ok(ScrollAddOnsHandle {
	rollup_manager_handle,
	rpc_handle,
	#[cfg(feature = "test-utils")]
	l1_watcher_tx,
	})
	}
	}

This should become something like:

    async fn launch_add_ons(self, ctx: AddOnsContext<'_, N>) -> eyre::Result<Self::Handle> {
        let Self { mut rpc_add_ons, rollup_manager_addon: rollup_node_manager_addon } = self;
        rpc_add_ons.eth_api_builder.with_propagate_local_transactions(
            !ctx.config.txpool.no_local_transactions_propagation,
        );
        let (tx, rx) = tokio::sync::oneshot::channel();
        let scroll_rpc_ext = ScrollRpcExt::new(rx);
        rpc_add_ons.extend_rpc_modules(move |ctx| move {
            ctx.modules.merge_configured(ScrollRpcExtServer::into_rpc(scroll_rpc_ext));
        });
        let rpc_handle = rpc_add_ons.launch_add_ons_with(ctx.clone(), |_| Ok(())).await?;
        let (rollup_manager_handle, l1_watcher_tx) =
            rollup_node_manager_addon.launch(ctx.clone(), rpc_handle.clone()).await?;
        tx.send(rollup_manager_handle.clone());
        Ok(ScrollAddOnsHandle {
            rollup_manager_handle,
            rpc_handle,
            #[cfg(feature = "test-utils")]
            l1_watcher_tx,
        })
    }