kora-rpc 1.0.3

RPC server for Kora gasless relayer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

mod method;
mod rpc;
mod server;
use clap::Parser;
use dotenv::dotenv;
use kora_lib::{
    args::RpcArgs,
    config::load_config,
    log::LoggingFormat,
    rpc::get_rpc_client,
    signer::{init::init_signer_type, KoraSigner},
    state::init_signer,
};
use rpc::KoraRpc;
use server::run_rpc_server;

#[tokio::main]
async fn main() {
    dotenv().ok();
    let args = RpcArgs::parse();
    setup_logging(&args.logging_format);

    let config = load_config(&args.common.config).unwrap_or_else(|e| {
        log::error!("Config load failed: {}", e);
        std::process::exit(1);
    });

    let rpc_client = get_rpc_client(&args.common.rpc_url);

    if let Err(e) = config.validate(rpc_client.as_ref()).await {
        log::error!("Config validation failed: {}", e);
        std::process::exit(1);
    }

    let signer = if !args.common.skip_signer {
        let signer = init_signer_type(&args.common).unwrap();

        // Launch async if privy for init() to populate PublicKey
        match signer {
            KoraSigner::Privy(mut privy_signer) => {
                privy_signer.init().await.unwrap_or_else(|e| {
                    log::error!("Privy signer init failed: {}", e);
                    std::process::exit(1);
                });
                Some(KoraSigner::Privy(privy_signer))
            }
            _ => Some(signer),
        }
    } else {
        None
    };

    if let Some(signer) = signer {
        init_signer(signer).unwrap_or_else(|e| {
            log::error!("Signer init failed: {}", e);
            std::process::exit(1);
        });
    }

    let rpc_server = KoraRpc::new(rpc_client, config.validation, config.kora);
    let server_handle =
        run_rpc_server(rpc_server, args.port.unwrap_or(8080)).await.unwrap_or_else(|e| {
            log::error!("Server start failed: {}", e);
            std::process::exit(1);
        });

    tokio::signal::ctrl_c().await.unwrap();
    server_handle.stop().unwrap();
}

fn setup_logging(format: &LoggingFormat) {
    let env_filter = std::env::var("RUST_LOG")
        .unwrap_or_else(|_| "info,sqlx=error,sea_orm_migration=error,jsonrpsee_server=warn".into());

    let subscriber = tracing_subscriber::fmt().with_env_filter(env_filter);
    match format {
        LoggingFormat::Standard => subscriber.init(),
        LoggingFormat::Json => subscriber.json().init(),
    }
}