From 10c9d89ec80cf0bd55bc8ab3b824c58b947c50f3 Mon Sep 17 00:00:00 2001 From: Pravdyvy Date: Tue, 7 Jul 2026 15:14:49 +0300 Subject: [PATCH] feat(wallet): multi-sequencer client stub added --- lez/wallet/src/cli/chain.rs | 12 +++- lez/wallet/src/cli/config.rs | 15 +--- lez/wallet/src/cli/mod.rs | 9 +-- lez/wallet/src/config.rs | 38 ++++++----- lez/wallet/src/helperfunctions.rs | 9 +++ lez/wallet/src/lib.rs | 109 ++++++++++++++++++++---------- lez/wallet/src/main.rs | 19 ++---- lez/wallet/src/multi_client.rs | 59 ++++++++++++++++ 8 files changed, 182 insertions(+), 88 deletions(-) create mode 100644 lez/wallet/src/multi_client.rs diff --git a/lez/wallet/src/cli/chain.rs b/lez/wallet/src/cli/chain.rs index dfb22eba..38ec3d7a 100644 --- a/lez/wallet/src/cli/chain.rs +++ b/lez/wallet/src/cli/chain.rs @@ -33,17 +33,23 @@ impl WalletSubcommand for ChainSubcommand { ) -> Result { match self { Self::CurrentBlockId => { - let latest_block_id = wallet_core.sequencer_client.get_last_block_id().await?; + let latest_block_id = wallet_core + .optimal_sequencer_client() + .get_last_block_id() + .await?; println!("Last block id is {latest_block_id}"); } Self::Block { id } => { - let block = wallet_core.sequencer_client.get_block(id).await?; + let block = wallet_core.optimal_sequencer_client().get_block(id).await?; println!("Last block id is {block:#?}"); } Self::Transaction { hash } => { - let tx = wallet_core.sequencer_client.get_transaction(hash).await?; + let tx = wallet_core + .optimal_sequencer_client() + .get_transaction(hash) + .await?; println!("Transaction is {tx:#?}"); } diff --git a/lez/wallet/src/cli/config.rs b/lez/wallet/src/cli/config.rs index a78bd097..b6d0c523 100644 --- a/lez/wallet/src/cli/config.rs +++ b/lez/wallet/src/cli/config.rs @@ -37,7 +37,7 @@ impl ConfigSubcommand { } else if let Some(key) = key { match key.as_str() { "sequencer_addr" => { - println!("{}", config.sequencer_addr); + println!("{:?}", config.sequencers_conn_data); } "seq_poll_timeout" => { println!("{:?}", config.seq_poll_timeout); @@ -51,13 +51,6 @@ impl ConfigSubcommand { "seq_block_poll_max_amount" => { println!("{}", config.seq_block_poll_max_amount); } - "basic_auth" => { - if let Some(basic_auth) = &config.basic_auth { - println!("{basic_auth}"); - } else { - println!("Not set"); - } - } _ => { println!("Unknown field"); } @@ -76,9 +69,6 @@ impl ConfigSubcommand { ) -> Result { let mut config = wallet_core.config().clone(); match key.as_str() { - "sequencer_addr" => { - config.sequencer_addr = value.parse()?; - } "seq_poll_timeout" => { config.seq_poll_timeout = humantime::parse_duration(&value) .map_err(|e| anyhow::anyhow!("Invalid duration: {e}"))?; @@ -92,9 +82,6 @@ impl ConfigSubcommand { "seq_block_poll_max_amount" => { config.seq_block_poll_max_amount = value.parse()?; } - "basic_auth" => { - config.basic_auth = Some(value.parse()?); - } "initial_accounts" => { anyhow::bail!("Setting this field from wallet is not supported"); } diff --git a/lez/wallet/src/cli/mod.rs b/lez/wallet/src/cli/mod.rs index 43b6dc7a..4b460714 100644 --- a/lez/wallet/src/cli/mod.rs +++ b/lez/wallet/src/cli/mod.rs @@ -219,7 +219,7 @@ pub async fn execute_subcommand( } Command::CheckHealth => { let remote_program_ids = wallet_core - .sequencer_client + .optimal_sequencer_client() .get_program_ids() .await .expect("Error fetching program ids"); @@ -287,7 +287,7 @@ pub async fn execute_subcommand( let message = lee::program_deployment_transaction::Message::new(bytecode); let transaction = ProgramDeploymentTransaction::new(message); let _response = wallet_core - .sequencer_client + .optimal_sequencer_client() .send_transaction(LeeTransaction::ProgramDeployment(transaction)) .await .context("Transaction submission error")?; @@ -384,12 +384,13 @@ pub async fn execute_keys_restoration(wallet_core: &mut WalletCore, depth: u32) wallet_core.sync_to_latest_block().await?; + let optimal_sequencer_client = wallet_core.optimal_sequencer_client_owned(); + wallet_core .storage .key_chain_mut() .cleanup_trees_remove_uninit_layered(depth, |account_id| { - wallet_core - .sequencer_client + optimal_sequencer_client .get_account(account_id) .map_err(Into::into) }) diff --git a/lez/wallet/src/config.rs b/lez/wallet/src/config.rs index 77c2729f..68f65f52 100644 --- a/lez/wallet/src/config.rs +++ b/lez/wallet/src/config.rs @@ -7,6 +7,15 @@ use log::warn; use serde::{Deserialize, Serialize}; use url::Url; +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SequencerConnectionData { + /// Connection data of all known sequencers. + pub sequencer_addr: Url, + /// Basic authentication credentials + #[serde(skip_serializing_if = "Option::is_none")] + pub basic_auth: Option, +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct GasConfig { /// Gas spent per deploying one byte of data. @@ -28,8 +37,8 @@ pub struct GasConfig { #[optfield::optfield(pub WalletConfigOverrides, rewrap, attrs = (derive(Debug, Default, Clone)))] #[derive(Debug, Clone, Serialize, Deserialize)] pub struct WalletConfig { - /// Sequencer URL. - pub sequencer_addr: Url, + /// Connection data of all known sequencers. + pub sequencers_conn_data: Vec, /// Sequencer polling duration for new blocks. #[serde(with = "humantime_serde")] pub seq_poll_timeout: Duration, @@ -39,20 +48,19 @@ pub struct WalletConfig { pub seq_poll_max_retries: u64, /// Max amount of blocks to poll in one request. pub seq_block_poll_max_amount: u64, - /// Basic authentication credentials - #[serde(skip_serializing_if = "Option::is_none")] - pub basic_auth: Option, } impl Default for WalletConfig { fn default() -> Self { Self { - sequencer_addr: "http://127.0.0.1:3040".parse().unwrap(), + sequencers_conn_data: vec![SequencerConnectionData { + sequencer_addr: "http://127.0.0.1:3040".parse().unwrap(), + basic_auth: None, + }], seq_poll_timeout: Duration::from_secs(12), seq_tx_poll_max_blocks: 5, seq_poll_max_retries: 5, seq_block_poll_max_amount: 100, - basic_auth: None, } } } @@ -97,26 +105,24 @@ impl WalletConfig { pub fn apply_overrides(&mut self, overrides: WalletConfigOverrides) { let Self { - sequencer_addr, + sequencers_conn_data, seq_poll_timeout, seq_tx_poll_max_blocks, seq_poll_max_retries, seq_block_poll_max_amount, - basic_auth, } = self; let WalletConfigOverrides { - sequencer_addr: o_sequencer_addr, + sequencers_conn_data: o_sequencers_conn_data, seq_poll_timeout: o_seq_poll_timeout, seq_tx_poll_max_blocks: o_seq_tx_poll_max_blocks, seq_poll_max_retries: o_seq_poll_max_retries, seq_block_poll_max_amount: o_seq_block_poll_max_amount, - basic_auth: o_basic_auth, } = overrides; - if let Some(v) = o_sequencer_addr { - warn!("Overriding wallet config 'sequencer_addr' to {v}"); - *sequencer_addr = v; + if let Some(v) = o_sequencers_conn_data { + warn!("Overriding wallet config 'sequencers_conn_data' to {v:?}"); + *sequencers_conn_data = v; } if let Some(v) = o_seq_poll_timeout { warn!("Overriding wallet config 'seq_poll_timeout' to {v:?}"); @@ -134,9 +140,5 @@ impl WalletConfig { warn!("Overriding wallet config 'seq_block_poll_max_amount' to {v}"); *seq_block_poll_max_amount = v; } - if let Some(v) = o_basic_auth { - warn!("Overriding wallet config 'basic_auth' to {v:#?}"); - *basic_auth = v; - } } } diff --git a/lez/wallet/src/helperfunctions.rs b/lez/wallet/src/helperfunctions.rs index 6fe78681..3898d94c 100644 --- a/lez/wallet/src/helperfunctions.rs +++ b/lez/wallet/src/helperfunctions.rs @@ -66,6 +66,15 @@ pub fn fetch_persistent_storage_path() -> Result { Ok(accs_path) } +/// Fetch path to metrics storage from default home. +/// +/// File must be created through setup beforehand. +pub fn fetch_metrics_path() -> Result { + let home = get_home()?; + let metrics_path = home.join("metrics.json"); + Ok(metrics_path) +} + #[expect(dead_code, reason = "Maybe used later")] pub(crate) fn produce_random_nonces(size: usize) -> Vec { let mut result = vec![[0; 16]; size]; diff --git a/lez/wallet/src/lib.rs b/lez/wallet/src/lib.rs index 923f55ae..caaf34c2 100644 --- a/lez/wallet/src/lib.rs +++ b/lez/wallet/src/lib.rs @@ -26,13 +26,14 @@ use lee_core::{ account::Nonce, compute_digest_for_path, program::InstructionData, }; use log::info; -use sequencer_service_rpc::{RpcClient as _, SequencerClient, SequencerClientBuilder}; +use sequencer_service_rpc::{RpcClient as _, SequencerClient}; use storage::Storage; use tokio::io::AsyncWriteExt as _; use crate::{ account::{AccountIdWithPrivacy, Label}, config::WalletConfigOverrides, + multi_client::{Metrics, MultiSequencerClient}, poller::TxPoller, storage::key_chain::SharedAccountEntry, }; @@ -42,6 +43,7 @@ mod account_manager; pub mod cli; pub mod config; pub mod helperfunctions; +pub mod multi_client; pub mod poller; pub mod program_facades; pub mod signing; @@ -92,8 +94,9 @@ pub struct WalletCore { storage: Storage, storage_path: PathBuf, - poller: TxPoller, - pub sequencer_client: SequencerClient, + _metrics_path: PathBuf, + + pub multi_sequencer_client: MultiSequencerClient, } impl WalletCore { @@ -101,29 +104,44 @@ impl WalletCore { pub fn from_env() -> Result { let config_path = helperfunctions::fetch_config_path()?; let storage_path = helperfunctions::fetch_persistent_storage_path()?; + let metrics_path = helperfunctions::fetch_metrics_path()?; - Self::new_update_chain(config_path, storage_path, None) + Self::new_update_chain(config_path, storage_path, metrics_path, None) } pub fn new_update_chain( config_path: PathBuf, storage_path: PathBuf, + metrics_path: PathBuf, config_overrides: Option, ) -> Result { let storage = Storage::from_path(&storage_path) .with_context(|| format!("Failed to load storage from {}", storage_path.display()))?; - Self::new(config_path, storage_path, config_overrides, storage) + Self::new( + config_path, + storage_path, + metrics_path, + config_overrides, + storage, + ) } pub fn new_init_storage( config_path: PathBuf, storage_path: PathBuf, + metrics_path: PathBuf, config_overrides: Option, password: &str, ) -> Result<(Self, Mnemonic)> { let (storage, mnemonic) = Storage::new(password).context("Failed to create storage")?; - let wallet = Self::new(config_path, storage_path, config_overrides, storage)?; + let wallet = Self::new( + config_path, + storage_path, + metrics_path, + config_overrides, + storage, + )?; Ok((wallet, mnemonic)) } @@ -131,6 +149,7 @@ impl WalletCore { fn new( config_path: PathBuf, storage_path: PathBuf, + metrics_path: PathBuf, config_overrides: Option, storage: Storage, ) -> Result { @@ -145,25 +164,7 @@ impl WalletCore { config.apply_overrides(config_overrides); } - let sequencer_client = { - let mut builder = SequencerClientBuilder::default(); - if let Some(basic_auth) = &config.basic_auth { - builder = builder.set_headers( - std::iter::once(( - "Authorization".parse().expect("Header name is valid"), - format!("Basic {basic_auth}") - .parse() - .context("Invalid basic auth format")?, - )) - .collect(), - ); - } - builder - .build(config.sequencer_addr.clone()) - .context("Failed to create sequencer client")? - }; - - let tx_poller = TxPoller::new(&config, sequencer_client.clone()); + let multi_sequencer_client = MultiSequencerClient::new(&config.sequencers_conn_data)?; Ok(Self { config_path, @@ -171,8 +172,8 @@ impl WalletCore { config, storage_path, storage, - poller: tx_poller, - sequencer_client, + _metrics_path: metrics_path, + multi_sequencer_client, }) } @@ -186,6 +187,27 @@ impl WalletCore { self.config = config; } + pub fn optimal_poller(&self) -> TxPoller { + let metrics = self.get_metrics(); + + TxPoller::new( + self.config(), + self.multi_sequencer_client.optimal_client_clone(&metrics), + ) + } + + pub fn optimal_sequencer_client(&self) -> &SequencerClient { + let metrics = self.get_metrics(); + + self.multi_sequencer_client.optimal_client_ref(&metrics) + } + + pub fn optimal_sequencer_client_owned(&self) -> SequencerClient { + let metrics = self.get_metrics(); + + self.multi_sequencer_client.optimal_client_clone(&metrics) + } + /// Get storage. #[must_use] pub const fn storage(&self) -> &Storage { @@ -430,14 +452,24 @@ impl WalletCore { }) } + pub fn get_metrics(&self) -> Vec { + todo!(); + } + /// Get account balance. pub async fn get_account_balance(&self, acc: AccountId) -> Result { - Ok(self.sequencer_client.get_account_balance(acc).await?) + Ok(self + .optimal_sequencer_client() + .get_account_balance(acc) + .await?) } /// Get accounts nonces. pub async fn get_accounts_nonces(&self, accs: Vec) -> Result> { - Ok(self.sequencer_client.get_accounts_nonces(accs).await?) + Ok(self + .optimal_sequencer_client() + .get_accounts_nonces(accs) + .await?) } pub async fn get_account(&self, account_id: AccountIdWithPrivacy) -> Result { @@ -455,7 +487,10 @@ impl WalletCore { /// Get public account. pub async fn get_account_public(&self, account_id: AccountId) -> Result { - Ok(self.sequencer_client.get_account(account_id).await?) + Ok(self + .optimal_sequencer_client() + .get_account(account_id) + .await?) } #[must_use] @@ -492,7 +527,7 @@ impl WalletCore { /// Poll transactions. pub async fn poll_native_token_transfer(&self, hash: HashType) -> Result { - self.poller.poll_tx(hash).await + self.optimal_poller().poll_tx(hash).await } pub async fn check_private_account_initialized( @@ -500,7 +535,7 @@ impl WalletCore { account_id: AccountId, ) -> Result> { if let Some(acc_comm) = self.get_private_account_commitment(account_id) { - self.sequencer_client + self.optimal_sequencer_client() .get_proof_for_commitment(acc_comm) .await .map_err(Into::into) @@ -511,7 +546,7 @@ impl WalletCore { pub async fn get_commitment_root(&self) -> Result> { let proof = self - .sequencer_client + .optimal_sequencer_client() .get_proof_for_commitment(DUMMY_COMMITMENT) .await?; Ok(proof.map(|p| compute_digest_for_path(&DUMMY_COMMITMENT, &p))) @@ -643,7 +678,7 @@ impl WalletCore { .collect(); Ok(( - self.sequencer_client + self.optimal_sequencer_client() .send_transaction(LeeTransaction::PrivacyPreserving(tx)) .await?, shared_secrets, @@ -707,13 +742,13 @@ impl WalletCore { let tx = lee::public_transaction::PublicTransaction::new(message, witness_set); Ok(self - .sequencer_client + .optimal_sequencer_client() .send_transaction(LeeTransaction::Public(tx)) .await?) } pub async fn sync_to_latest_block(&mut self) -> Result { - let latest_block_id = self.sequencer_client.get_last_block_id().await?; + let latest_block_id = self.optimal_sequencer_client().get_last_block_id().await?; println!("Latest block is {latest_block_id}"); self.sync_to_block(latest_block_id).await?; Ok(latest_block_id) @@ -735,7 +770,7 @@ impl WalletCore { println!("Syncing to block {block_id}. Blocks to sync: {num_of_blocks}"); - let poller = self.poller.clone(); + let poller = self.optimal_poller().clone(); let mut blocks = std::pin::pin!(poller.poll_block_range(last_synced_block.saturating_add(1)..=block_id)); diff --git a/lez/wallet/src/main.rs b/lez/wallet/src/main.rs index 838ee856..d3c27427 100644 --- a/lez/wallet/src/main.rs +++ b/lez/wallet/src/main.rs @@ -8,8 +8,7 @@ use clap::{CommandFactory as _, Parser as _}; use wallet::{ WalletCore, cli::{Args, execute_continuous_run, execute_subcommand, read_password_from_stdin}, - config::WalletConfigOverrides, - helperfunctions::{fetch_config_path, fetch_persistent_storage_path}, + helperfunctions::{fetch_config_path, fetch_metrics_path, fetch_persistent_storage_path}, }; // TODO #169: We have sample configs for sequencer, but not for wallet @@ -21,7 +20,7 @@ use wallet::{ async fn main() -> Result<()> { let Args { continuous_run, - auth, + auth: _auth, command, } = Args::parse(); @@ -30,16 +29,11 @@ async fn main() -> Result<()> { let config_path = fetch_config_path().context("Could not fetch config path")?; let storage_path = fetch_persistent_storage_path().context("Could not fetch persistent storage path")?; - - // Override basic auth if provided via CLI - let config_overrides = WalletConfigOverrides { - basic_auth: auth.map(|auth| auth.parse()).transpose()?.map(Some), - ..Default::default() - }; + let metrics_path = fetch_metrics_path().context("Could not fetch metrics path")?; if let Some(command) = command { let mut wallet = if storage_path.exists() { - WalletCore::new_update_chain(config_path, storage_path, Some(config_overrides))? + WalletCore::new_update_chain(config_path, storage_path, metrics_path, None)? } else { // TODO: Maybe move to `WalletCore::from_env()` or similar? @@ -49,7 +43,8 @@ async fn main() -> Result<()> { let (wallet, mnemonic) = WalletCore::new_init_storage( config_path, storage_path, - Some(config_overrides), + metrics_path, + None, &password, )?; @@ -68,7 +63,7 @@ async fn main() -> Result<()> { Ok(()) } else if continuous_run { let mut wallet = - WalletCore::new_update_chain(config_path, storage_path, Some(config_overrides))?; + WalletCore::new_update_chain(config_path, storage_path, metrics_path, None)?; execute_continuous_run(&mut wallet).await } else { let help = Args::command().render_long_help(); diff --git a/lez/wallet/src/multi_client.rs b/lez/wallet/src/multi_client.rs new file mode 100644 index 00000000..01c3ab18 --- /dev/null +++ b/lez/wallet/src/multi_client.rs @@ -0,0 +1,59 @@ +use anyhow::{Context, Result}; +use sequencer_service_rpc::{SequencerClient, SequencerClientBuilder}; +use serde::{Deserialize, Serialize}; + +use crate::config::SequencerConnectionData; + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Metrics { + pub latency_avg: u64, + pub latency_var: u64, + pub last_block_id: u64, +} + +#[derive(Clone)] +pub struct MultiSequencerClient { + pub client_list: Vec, +} + +impl MultiSequencerClient { + pub fn new(conn_data: &[SequencerConnectionData]) -> Result { + let mut client_list = vec![]; + + for SequencerConnectionData { + sequencer_addr, + basic_auth, + } in conn_data + { + let sequencer_client = { + let mut builder = SequencerClientBuilder::default(); + if let Some(basic_auth) = &basic_auth { + builder = builder.set_headers( + std::iter::once(( + "Authorization".parse().expect("Header name is valid"), + format!("Basic {basic_auth}") + .parse() + .context("Invalid basic auth format")?, + )) + .collect(), + ); + } + builder + .build(sequencer_addr) + .context("Failed to create sequencer client")? + }; + + client_list.push(sequencer_client); + } + + Ok(Self { client_list }) + } + + pub fn optimal_client_ref(&self, _metrics: &[Metrics]) -> &SequencerClient { + todo!(); + } + + pub fn optimal_client_clone(&self, _metrics: &[Metrics]) -> SequencerClient { + todo!(); + } +}