async fn node(config: ProverNodeConfig) -> Result<()> {

    let program = Pubkey::from_str(&config.bonsol_program)?;

    let signer = match config.signer_config.clone() {

        SignerConfig::KeypairFile { path } => {

            info!("Using Keypair File");

            read_keypair_file(&path).map_err(|_| CliError::InvalidSigner)?

    let signer_identity = signer.pubkey();

    let mut ingester: Box<dyn Ingester> = match config.ingester_config.clone() {

        IngesterConfig::RpcBlockSubscription { wss_rpc_url } => {

            info!("Using RPC Block Subscription");

            Box::new(RpcIngester::new(wss_rpc_url))

            grpc_url,

            token,

            connection_timeout_secs,

            timeout_secs,

        } => {

            info!("Using GRPC Subscription");

            Box::new(GrpcIngester::new(

                grpc_url,

                token,

                Some(connection_timeout_secs),

                Some(timeout_secs),

            ))

        _ => return Err(CliError::InvalidIngester.into()),

    let (mut transaction_sender, solana_rpc_client) = match config.transaction_sender_config.clone()

        TransactionSenderConfig::Rpc { rpc_url } => (

            RpcTransactionSender::new(rpc_url.clone(), program, signer),

            RpcClient::new(rpc_url),

        ),

        _ => return Err(CliError::InvalidRpcUrl.into()),

    transaction_sender.start();

    let input_resolver = DefaultInputResolver::new_with_opts(

        Arc::new(reqwest::Client::new()),

        Arc::new(solana_rpc_client),

        Some(config.max_input_size_mb),

        Some(Duration::from_secs(

            config.image_download_timeout_secs as u64,

        )),

    );

    let mut runner = Risc0Runner::new(

        config.clone(),

        signer_identity,

        Arc::new(transaction_sender),

        Arc::new(input_resolver),

    )

    .await?;

    let runner_chan = runner.start()?;

    let mut ingester_chan = ingester.start(program)?;

    let ingestor = tokio::spawn(async move {

        while let Some(bix) = ingester_chan.recv().await {

            for ix in bix {

                println!("Sending to runner");

                runner_chan.send(ix).unwrap();

            }

    });

    select! {

        e = ingestor => {

            info!("Runner exited: {:?}", e);

            ingester.stop()?;

            runner.stop()?;

    Ok(())

}

async fn main() -> Result<()> {

    // Set the stack size to unlimited

    match rlimit::setrlimit(Resource::STACK, u64::MAX, u64::MAX) {

        Ok(_) => {}

        Err(e) => error!("Error setting rlimit: {}", e),

    }

    tracing_subscriber::fmt()

        .json()

        .with_timer(tracing_subscriber::fmt::time::UtcTime::rfc_3339())

        .init();

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 || args[1] != "-f" {

        error!("Usage: bonsol-node -f <config_file>");

        return Ok(());

    }

    let config_file = &args[2];

    let config = config::load_config(config_file);

    if let MetricsConfig::Prometheus {} = config.metrics_config {

        let builder = PrometheusBuilder::new();

        builder

            .install()

            .expect("failed to install prometheus exporter");

        info!("Prometheus exporter installed");

    }

    emit_event!(MetricEvents::BonsolStartup, up => true);

    node(config).await?;

    select! {

        _ = signal::ctrl_c() => {

            info!("Received Ctrl-C");

            info!("Exited");

            exit(1);

        },

    }

}