Move url to env file (#3506)

* refactor: move RPC URLs and API keys from CLI args to environment variables

* centralize environment variable handling

* fmt

* organize .env.example by category

* simplify environment variable handling

* centralize environment configuration in new EnvConfig struct

* fix comments

* rename worker_base_url to pumpx_worker_url and reorder environment variable logging

* use EnvConfig for parentchain URL configuration instead of direct env var access

Author: 0xverin

tee-worker/omni-executor/.env.example

@@ -1,6 +1,26 @@
-# sendgrid config 
+# Sendgrid
 OE_SENDGRID_API_KEY=
 OE_SENDGRID_FROM_EMAIL=
 OE_SENDGRID_FROM_NAME=
-# pumpX config
-OE_PUMPX_API_BASE_URL=
+
+# Pumpx
+OE_PUMPX_API_BASE_URL=
+OE_PUMPX_SIGNER_URL=
+OE_PUMPX_WORKER_URL=
+
+# Binance
+OE_BINANCE_API_KEY=
+OE_BINANCE_API_SECRET=
+OE_BINANCE_API_BASE_URL=
+
+# Heima
+OE_PARENTCHAIN_URL=
+
+# Ethereum
+OE_ETHEREUM_URL=
+OE_BSC_URL=
+OE_BSC_TESTNET_URL=
+
+# Solana
+OE_SOLANA_URL=
+

tee-worker/omni-executor/binance-api/src/lib.rs

@@ -57,11 +57,8 @@ pub enum BinanceApiResponse<T> {
 }
 
 impl BinanceApiClient {
-	pub fn new(api_key: String, api_secret: String, base_url: Option<String>) -> BinanceApiClient {
-		let base_url = match base_url {
-			Some(url) => Url::parse(&url).expect("Invalid base URL"),
-			None => Url::parse("https://api.binance.com").unwrap(),
-		};
+	pub fn new(api_key: String, api_secret: String, base_url: String) -> BinanceApiClient {
+		let base_url = Url::parse(&base_url).expect("Invalid base URL");
 		let client = Client::new();
 		BinanceApiClient { client, base_url, api_key, api_secret }
 	}
@@ -246,7 +243,8 @@ mod tests {
 		let api_secret =
 			"NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j".to_string();
 		let query_string = "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559".to_string();
-		let binance_api = BinanceApiClient::new(api_key, api_secret, None);
+		let binance_api =
+			BinanceApiClient::new(api_key, api_secret, "https://api.binance.com".to_string());
 		let signature = binance_api.sign_request(&query_string);
 
 		assert_eq!(signature, "c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71");

tee-worker/omni-executor/executor-worker/src/cli.rs

@@ -16,13 +16,6 @@ pub enum Commands {
 
 #[derive(Args)]
 pub struct RunArgs {
-	pub parentchain_url: String,
-	pub ethereum_url: String,
-	pub solana_url: String,
-	pub pumpx_signer_url: String,
-	pub worker_url: String,
-	pub bsc_url: String,
-	pub bsc_testnet_url: Option<String>,
 	#[arg(long, short = 'b', default_value = "0", help = "Start block to sync from parentchain")]
 	pub start_block: u64,
 	#[arg(short, long, default_value = "local", value_name = "local directory path")]

tee-worker/omni-executor/executor-worker/src/env_config.rs

@@ -0,0 +1,154 @@
+// Copyright 2020-2024 Trust Computing GmbH.
+// This file is part of Litentry.
+//
+// Litentry is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Litentry is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Litentry.  If not, see <https://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use tracing::info;
+
+const DEFAULT_PUMPX_API_BASE_URL: &str = "https://api.pumpx.ai";
+const DEFAULT_BINANCE_API_BASE_URL: &str = "https://api.binance.com";
+
+/// Configuration struct for environment variables used by the executor worker
+pub struct EnvConfig {
+	pub parentchain_url: String,
+	pub ethereum_url: String,
+	pub solana_url: String,
+	pub bsc_url: String,
+	pub bsc_testnet_url: Option<String>,
+	pub pumpx_signer_url: String,
+	pub pumpx_api_base_url: String,
+	pub pumpx_worker_url: String,
+	pub binance_api_key: String,
+	pub binance_api_secret: String,
+	pub binance_api_base_url: String,
+}
+
+impl EnvConfig {
+	/// Creates a new EnvConfig by loading values from environment variables
+	pub fn from_env() -> Self {
+		let (env_map, sensitive_map) = Self::load_env_vars();
+
+		Self::log_env_vars(&env_map, &sensitive_map);
+
+		// Convert from HashMap to struct for better type safety and usage
+		Self::from_map(env_map)
+	}
+
+	/// Loads environment variables into a HashMap
+	fn load_env_vars() -> (HashMap<&'static str, Option<String>>, HashMap<&'static str, bool>) {
+		const SENSITIVE: bool = true;
+		const NOT_SENSITIVE: bool = false;
+
+		let vars = [
+			("OE_PARENTCHAIN_URL", "parentchain_url", NOT_SENSITIVE),
+			("OE_ETHERUM_URL", "ethereum_url", NOT_SENSITIVE),
+			("OE_SOLANA_URL", "solana_url", NOT_SENSITIVE),
+			("OE_BSC_URL", "bsc_url", NOT_SENSITIVE),
+			("OE_BSC_TESTNET_URL", "bsc_testnet_url", NOT_SENSITIVE),
+			("OE_ALCHEMY_KEY", "alchemy_key", SENSITIVE),
+			("OE_PUMPX_SIGNER_URL", "pumpx_signer_url", NOT_SENSITIVE),
+			("OE_PUMPX_API_BASE_URL", "pumpx_api_base_url", NOT_SENSITIVE),
+			("OE_PUMPX_WORKER_URL", "pumpx_worker_url", NOT_SENSITIVE),
+			("OE_BINANCE_API_KEY", "binance_api_key", SENSITIVE),
+			("OE_BINANCE_API_SECRET", "binance_api_secret", SENSITIVE),
+			("OE_BINANCE_API_BASE_URL", "binance_api_base_url", NOT_SENSITIVE),
+		];
+
+		let mut env_map = HashMap::new();
+		let mut sensitive_map = HashMap::new();
+
+		// Load environment variables
+		for (env_name, var_name, is_sensitive) in vars {
+			let value = Some(std::env::var(env_name).unwrap_or_default());
+			env_map.insert(var_name, value);
+			sensitive_map.insert(var_name, is_sensitive);
+		}
+
+		// Set default values for certain variables if they're empty
+		let defaults = [
+			("binance_api_base_url", DEFAULT_BINANCE_API_BASE_URL),
+			("pumpx_api_base_url", DEFAULT_PUMPX_API_BASE_URL),
+		];
+
+		for (key, default_value) in defaults {
+			if env_map.get(key).and_then(|v| v.as_ref()).is_none_or(|v| v.is_empty()) {
+				env_map.insert(key, Some(default_value.to_string()));
+			}
+		}
+
+		(env_map, sensitive_map)
+	}
+
+	/// Logs non-sensitive environment variables
+	fn log_env_vars(
+		env_map: &HashMap<&'static str, Option<String>>,
+		sensitive_map: &HashMap<&'static str, bool>,
+	) {
+		// Log command line arguments
+		let args_string = std::env::args().collect::<Vec<String>>().join(" ");
+
+		for (name, value) in env_map {
+			if let Some(is_sensitive) = sensitive_map.get(name) {
+				if !*is_sensitive {
+					if let Some(val) = value {
+						info!("Environment variable {}: {}", name, val);
+					}
+				}
+			}
+		}
+
+		info!("Executing: {}", args_string);
+	}
+
+	/// Converts a HashMap of environment variables to an EnvConfig struct
+	fn from_map(env_map: HashMap<&'static str, Option<String>>) -> Self {
+		let get_string = |key: &str| -> String {
+			env_map
+				.get(key)
+				.and_then(|v| v.as_ref())
+				.map_or_else(String::new, |v| v.clone())
+		};
+
+		let ethereum_url = get_string("ethereum_url");
+		let solana_url = get_string("solana_url");
+		let bsc_url = get_string("bsc_url");
+		let bsc_testnet_url =
+			env_map.get("bsc_testnet_url").and_then(|v| v.clone()).filter(|v| !v.is_empty());
+		let alchemy_key = get_string("alchemy_key");
+
+		// Append alchemy_key to URLs in the format: https://base-url/v2/{alchemy_key}
+		let append_key = |url: &str| -> String {
+			if !alchemy_key.is_empty() && url.contains("alchemy") {
+				format!("{}{}", url, alchemy_key)
+			} else {
+				url.to_string()
+			}
+		};
+
+		EnvConfig {
+			parentchain_url: get_string("parentchain_url"),
+			ethereum_url: append_key(&ethereum_url),
+			solana_url: append_key(&solana_url),
+			bsc_url: append_key(&bsc_url),
+			bsc_testnet_url: bsc_testnet_url.as_ref().map(|url| append_key(url)),
+			pumpx_signer_url: get_string("pumpx_signer_url"),
+			pumpx_api_base_url: get_string("pumpx_api_base_url"),
+			pumpx_worker_url: get_string("pumpx_worker_url"),
+			binance_api_key: get_string("binance_api_key"),
+			binance_api_secret: get_string("binance_api_secret"),
+			binance_api_base_url: get_string("binance_api_base_url"),
+		}
+	}
+}

tee-worker/omni-executor/executor-worker/src/main.rs

@@ -59,7 +59,6 @@ use rust_decimal::Decimal;
 use solana::SolanaRpcClient;
 use solana_intent_executor::SolanaIntentExecutor;
 use std::collections::HashMap;
-use std::env;
 use std::net::SocketAddr;
 use std::path::Path;
 use std::str::FromStr;
@@ -73,7 +72,8 @@ use tracing::info;
 use tracing::log::error;
 use tracing_subscriber::EnvFilter;
 use tracing_subscriber::FmtSubscriber;
-
+mod env_config;
+use env_config::EnvConfig;
 mod cli;
 
 #[tokio::main]
@@ -90,9 +90,7 @@ async fn main() -> Result<(), ()> {
 
 	match cli.cmd {
 		Commands::Run(args) => {
-			let args_string = std::env::args().collect::<Vec<String>>().join(" ");
-			info!("Executing: {}", args_string);
-
+			let env_config = EnvConfig::from_env();
 			let builder = PrometheusBuilder::new();
 
 			let address = SocketAddr::from_str(&format!("0.0.0.0:{}", args.metrics_port)).unwrap();
@@ -166,10 +164,12 @@ async fn main() -> Result<(), ()> {
 				.unwrap()
 			);
 
-			let storage_db =
-				init_storage(&args.parentchain_url).await.expect("Could not initialize storage");
+			let storage_db = init_storage(&env_config.parentchain_url)
+				.await
+				.expect("Could not initialize storage");
 
-			let client_factory = SubxtClientFactory::<CustomConfig>::new(&args.parentchain_url);
+			let client_factory =
+				SubxtClientFactory::<CustomConfig>::new(&env_config.parentchain_url);
 			let metadata_provider = Arc::new(SubxtMetadataProvider::new(client_factory.clone()));
 			let parentchain_rpc_client_factory = Arc::new(client_factory);
 
@@ -209,45 +209,43 @@ async fn main() -> Result<(), ()> {
 
 			let pumpx_signer_client: Arc<Box<dyn signer_client::SignerClient>> =
 				Arc::new(Box::new(pumpx::signer_client::PumpxSignerClient::new(
-					args.pumpx_signer_url.clone(),
+					env_config.pumpx_signer_url,
 					pumpx_signer_pair,
 				)));
 
-			let ethereum_intent_executor =
-				EthereumIntentExecutor::new(&args.ethereum_url, &args.delegation_contract_address)?;
-			let solana_intent_executor = SolanaIntentExecutor::new(&args.solana_url)?;
+			let ethereum_intent_executor = EthereumIntentExecutor::new(
+				&env_config.ethereum_url,
+				&args.delegation_contract_address,
+			)?;
+			let solana_intent_executor = SolanaIntentExecutor::new(&env_config.solana_url)?;
 
 			let mut rpc_endpoint_registry = RpcEndpointRegistry::new();
-			rpc_endpoint_registry.insert(Chain::Solana, args.solana_url.clone());
-			rpc_endpoint_registry.insert(Chain::Ethereum(56), args.bsc_url.clone());
+			rpc_endpoint_registry.insert(Chain::Solana, env_config.solana_url.to_string());
+			rpc_endpoint_registry.insert(Chain::Ethereum(56), env_config.bsc_url.to_string());
 
-			if let Some(ref bsc_testnet_url) = args.bsc_testnet_url {
+			if let Some(ref bsc_testnet_url) = env_config.bsc_testnet_url {
 				rpc_endpoint_registry.insert(Chain::Ethereum(97), bsc_testnet_url.to_owned());
 			}
 
-			let pumpx_api_base_url = std::env::var("OE_PUMPX_API_BASE_URL").ok();
 			let pumpx_api: Arc<Box<dyn PumpxApi>> =
-				Arc::new(Box::new(PumpxApiClient::new(pumpx_api_base_url)));
+				Arc::new(Box::new(PumpxApiClient::new(env_config.pumpx_api_base_url.to_string())));
 
-			let binance_api_key = env::var("OE_BINANCE_API_KEY").unwrap_or("".to_string());
-			let binance_api_secret = env::var("OE_BINANCE_API_SECRET").unwrap_or("".to_string());
-			let binance_api_base_url = env::var("OE_BINANCE_API_BASE_URL").ok();
 			let binance_api = Arc::new(BinanceApiClient::new(
-				binance_api_key,
-				binance_api_secret,
-				binance_api_base_url,
+				env_config.binance_api_key,
+				env_config.binance_api_secret,
+				env_config.binance_api_base_url,
 			));
 
 			let solana_client: Arc<SolanaRpcClient> =
-				Arc::new(SolanaRpcClient::new(&args.solana_url));
+				Arc::new(SolanaRpcClient::new(&env_config.solana_url));
 
 			let accounting_contract_signer =
 				PrivateKeySigner::from_slice(&evm_accounting_ecdsa_signer_key_pair.seed())
 					.expect("Could not create accounting contract signer");
 			let accounting_contract_wallet = EthereumWallet::from(accounting_contract_signer);
 
 			let bsc_rpc_provider = ethereum_rpc::AlloyRpcProvider::new_with_wallet(
-				&args.bsc_url,
+				&env_config.bsc_url,
 				accounting_contract_wallet,
 			);
 			let evm_accounting_contract_client = EthereumAccountingContractClient::new(
@@ -256,19 +254,19 @@ async fn main() -> Result<(), ()> {
 			);
 			let solana_accounting_contract_client = SolanaAccountingContractClient::new(
 				solana_accounting_ed25519_signer_key_pair,
-				args.solana_url.clone(),
+				env_config.solana_url.clone(),
 				args.solana_accounting_contract_address.parse().unwrap(),
 			);
 
 			let bsc_client: Arc<EthereumRpcClient> =
-				Arc::new(EthereumRpcClient::new(&args.bsc_url));
+				Arc::new(EthereumRpcClient::new(&env_config.bsc_url));
 
 			// wallet monitoring setup start
 			let bsc_wallet_balance_fetcher: Arc<Box<dyn WalletBalanceFetcher>> =
-				Arc::new(Box::new(ethereum_rpc::AlloyRpcProvider::new(&args.bsc_url)));
+				Arc::new(Box::new(ethereum_rpc::AlloyRpcProvider::new(&env_config.bsc_url)));
 
 			let solana_wallet_balance_fetcher: Arc<Box<dyn WalletBalanceFetcher>> =
-				Arc::new(Box::new(SolanaRpcClient::new(&args.solana_url)));
+				Arc::new(Box::new(SolanaRpcClient::new(&env_config.solana_url)));
 
 			let mut balance_fetchers: HashMap<
 				WalletNetworkType,
@@ -323,8 +321,8 @@ async fn main() -> Result<(), ()> {
 			let native_task_sender =
 				run_native_task_handler(MAX_CONCURRENT_TASKS, Arc::new(task_handler_context)).await;
 
-			info!("worker url: {:?}", args.worker_url);
-			let worker_url = url::Url::parse(&args.worker_url).expect("Invalid worker url");
+			let worker_url =
+				url::Url::parse(&env_config.pumpx_worker_url).expect("Invalid worker url");
 
 			let shielding_key_store = ShieldingKeyStore::new(
 				Path::new(&args.local_directory_path)
@@ -402,12 +400,13 @@ async fn listen_to_parentchain(
 	args: RunArgs,
 	storage_db: Arc<StorageDB>,
 ) -> Result<JoinHandle<()>, ()> {
+	let env_config = EnvConfig::from_env();
 	let (_sub_stop_sender, sub_stop_receiver) = oneshot::channel();
-
+	let parentchain_url = env_config.parentchain_url;
 	let mut parentchain_listener = parentchain_listener::create_listener(
 		"heima",
 		Handle::current(),
-		&args.parentchain_url,
+		&parentchain_url,
 		sub_stop_receiver,
 		storage_db,
 		&Path::new(&args.local_directory_path)