2023-07-20 04:45:54 -07:00
|
|
|
pub mod rpc_tester;
|
|
|
|
|
2023-01-09 22:40:43 -08:00
|
|
|
use std::time::Duration;
|
2022-11-12 05:32:01 -08:00
|
|
|
|
2023-07-20 04:45:54 -07:00
|
|
|
use anyhow::{bail, Context};
|
2022-11-30 07:56:41 -08:00
|
|
|
use clap::Parser;
|
2023-02-13 10:58:30 -08:00
|
|
|
use dotenv::dotenv;
|
2022-12-21 05:31:43 -08:00
|
|
|
use lite_rpc::{bridge::LiteBridge, cli::Args};
|
2023-07-20 04:45:54 -07:00
|
|
|
|
2023-02-08 13:18:09 -08:00
|
|
|
use solana_sdk::signature::Keypair;
|
2023-02-13 10:58:30 -08:00
|
|
|
use std::env;
|
2023-07-21 09:08:32 -07:00
|
|
|
use std::sync::Arc;
|
2023-07-26 14:33:49 -07:00
|
|
|
use clap::builder::TypedValueParser;
|
|
|
|
use solana_lite_rpc_services::tpu_utils::tpu_connection_path::TpuConnectionPath;
|
2023-02-13 10:58:30 -08:00
|
|
|
|
2023-07-20 04:45:54 -07:00
|
|
|
use crate::rpc_tester::RpcTester;
|
|
|
|
|
|
|
|
async fn get_identity_keypair(identity_from_cli: &str) -> Keypair {
|
2023-04-08 03:36:43 -07:00
|
|
|
if let Ok(identity_env_var) = env::var("IDENTITY") {
|
2023-02-13 10:58:30 -08:00
|
|
|
if let Ok(identity_bytes) = serde_json::from_str::<Vec<u8>>(identity_env_var.as_str()) {
|
|
|
|
Keypair::from_bytes(identity_bytes.as_slice()).unwrap()
|
|
|
|
} else {
|
|
|
|
// must be a file
|
|
|
|
let identity_file = tokio::fs::read_to_string(identity_env_var.as_str())
|
|
|
|
.await
|
|
|
|
.expect("Cannot find the identity file provided");
|
|
|
|
let identity_bytes: Vec<u8> = serde_json::from_str(&identity_file).unwrap();
|
|
|
|
Keypair::from_bytes(identity_bytes.as_slice()).unwrap()
|
|
|
|
}
|
|
|
|
} else if identity_from_cli.is_empty() {
|
|
|
|
Keypair::new()
|
|
|
|
} else {
|
2023-07-20 04:45:54 -07:00
|
|
|
let identity_file = tokio::fs::read_to_string(identity_from_cli)
|
2023-02-13 10:58:30 -08:00
|
|
|
.await
|
|
|
|
.expect("Cannot find the identity file provided");
|
|
|
|
let identity_bytes: Vec<u8> = serde_json::from_str(&identity_file).unwrap();
|
|
|
|
Keypair::from_bytes(identity_bytes.as_slice()).unwrap()
|
|
|
|
}
|
|
|
|
}
|
2022-12-16 18:35:49 -08:00
|
|
|
|
2023-07-20 04:45:54 -07:00
|
|
|
pub async fn start_lite_rpc(args: Args) -> anyhow::Result<()> {
|
2022-12-16 18:35:49 -08:00
|
|
|
let Args {
|
|
|
|
rpc_addr,
|
|
|
|
ws_addr,
|
2023-01-05 02:54:00 -08:00
|
|
|
lite_rpc_ws_addr,
|
|
|
|
lite_rpc_http_addr,
|
2023-01-10 07:45:30 -08:00
|
|
|
fanout_size,
|
2023-01-31 05:30:52 -08:00
|
|
|
enable_postgres,
|
2023-02-04 03:45:20 -08:00
|
|
|
prometheus_addr,
|
2023-02-08 13:18:09 -08:00
|
|
|
identity_keypair,
|
2023-04-18 05:22:51 -07:00
|
|
|
maximum_retries_per_tx,
|
|
|
|
transaction_retry_after_secs,
|
2023-07-26 14:33:49 -07:00
|
|
|
experimental_quic_proxy_addr,
|
2023-07-20 04:45:54 -07:00
|
|
|
} = args;
|
2023-05-09 07:52:51 -07:00
|
|
|
|
2023-07-21 09:08:32 -07:00
|
|
|
let validator_identity = Arc::new(get_identity_keypair(&identity_keypair).await);
|
2023-05-13 06:52:43 -07:00
|
|
|
|
2023-05-09 07:52:51 -07:00
|
|
|
let retry_after = Duration::from_secs(transaction_retry_after_secs);
|
2023-06-11 17:15:40 -07:00
|
|
|
|
2023-07-26 14:33:49 -07:00
|
|
|
let tpu_connection_path = configure_tpu_connection_path(experimental_quic_proxy_addr);
|
|
|
|
|
2023-07-20 04:45:54 -07:00
|
|
|
LiteBridge::new(
|
2023-04-18 05:22:51 -07:00
|
|
|
rpc_addr,
|
|
|
|
ws_addr,
|
|
|
|
fanout_size,
|
2023-07-21 09:08:32 -07:00
|
|
|
validator_identity,
|
2023-04-18 05:22:51 -07:00
|
|
|
retry_after,
|
|
|
|
maximum_retries_per_tx,
|
2023-07-26 14:33:49 -07:00
|
|
|
tpu_connection_path
|
2023-04-18 05:22:51 -07:00
|
|
|
)
|
2023-07-20 04:45:54 -07:00
|
|
|
.await
|
|
|
|
.context("Error building LiteBridge")?
|
2023-06-11 17:15:40 -07:00
|
|
|
.start_services(
|
|
|
|
lite_rpc_http_addr,
|
|
|
|
lite_rpc_ws_addr,
|
|
|
|
enable_postgres,
|
|
|
|
prometheus_addr,
|
2023-07-20 04:45:54 -07:00
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
2022-12-16 18:35:49 -08:00
|
|
|
|
2023-07-20 04:45:54 -07:00
|
|
|
fn get_args() -> Args {
|
|
|
|
let mut args = Args::parse();
|
|
|
|
|
|
|
|
dotenv().ok();
|
|
|
|
|
|
|
|
args.enable_postgres = args.enable_postgres
|
|
|
|
|| if let Ok(enable_postgres_env_var) = env::var("PG_ENABLED") {
|
|
|
|
enable_postgres_env_var != "false"
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
};
|
|
|
|
|
|
|
|
args
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::main(flavor = "multi_thread", worker_threads = 16)]
|
|
|
|
pub async fn main() -> anyhow::Result<()> {
|
|
|
|
tracing_subscriber::fmt::init();
|
|
|
|
|
|
|
|
let args = get_args();
|
2023-06-23 00:16:57 -07:00
|
|
|
|
2022-12-16 18:35:49 -08:00
|
|
|
let ctrl_c_signal = tokio::signal::ctrl_c();
|
2023-07-20 04:45:54 -07:00
|
|
|
let rpc_tester = RpcTester::from(&args).start();
|
|
|
|
|
|
|
|
let main = start_lite_rpc(args.clone());
|
2022-12-16 18:35:49 -08:00
|
|
|
|
|
|
|
tokio::select! {
|
2023-07-20 04:45:54 -07:00
|
|
|
err = rpc_tester => {
|
|
|
|
// This should never happen
|
|
|
|
unreachable!("{err:?}")
|
|
|
|
}
|
|
|
|
res = main => {
|
|
|
|
// This should never happen
|
|
|
|
log::error!("Services quit unexpectedly {res:?}");
|
|
|
|
bail!("")
|
|
|
|
}
|
2023-01-31 09:02:50 -08:00
|
|
|
_ = ctrl_c_signal => {
|
2023-07-20 04:45:54 -07:00
|
|
|
log::info!("Received ctrl+c signal");
|
2023-06-11 17:46:50 -07:00
|
|
|
|
|
|
|
Ok(())
|
2022-12-16 18:35:49 -08:00
|
|
|
}
|
2022-11-25 01:22:12 -08:00
|
|
|
}
|
2022-12-07 07:05:18 -08:00
|
|
|
}
|
2023-08-02 04:32:01 -07:00
|
|
|
|
|
|
|
fn configure_tpu_connection_path(experimental_quic_proxy_addr: Option<String>) -> TpuConnectionPath {
|
|
|
|
match experimental_quic_proxy_addr {
|
|
|
|
None => TpuConnectionPath::QuicDirectPath,
|
|
|
|
Some(prox_address) => TpuConnectionPath::QuicForwardProxyPath {
|
|
|
|
// e.g. "127.0.0.1:11111"
|
|
|
|
forward_proxy_address: prox_address.parse().unwrap()
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|