diff --git a/CHANGELOG.md b/CHANGELOG.md index e2bc8f0b3d..67e18a81ad 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,11 @@ - [BREAKING] Changed `SyncChainMmr` endpoint: the upper end of the block range we're syncing is now the chain tip with the requested finality level. Validator signature is also returned ([#2075](https://github.com/0xMiden/node/pull/2075)). - [BREAKING] Renamed `SubmitProvenTransaction` RPC endpoint to `SubmitProvenTx` ([#2094](https://github.com/0xMiden/node/pull/2094)). - [BREAKING] Renamed `SubmitProvenBatch` RPC endpoint to `SubmitProvenTxBatch` ([#2094](https://github.com/0xMiden/node/pull/2094)). +## v0.14.11 (TBD) + +- Replaced blocking-in-async operations in the validator, remote prover, and ntx-builder with `spawn_blocking` to avoid starving the Tokio runtime ([#2041](https://github.com/0xMiden/node/pull/2041)). +- Implement persistent RocksDB backend for `AccountStateForest`, improving startup time ([#2020](https://github.com/0xMiden/node/pull/2020)). +- Fixed network transaction builder permanently dropping notes after transient infrastructure failures. These now retry with exponential backoff at the actor level instead of consuming per-note retry budget ([#2052](https://github.com/0xMiden/node/issues/2052)). ## v0.14.10 (2026-05-29) @@ -38,6 +43,7 @@ - Added `accept`, `origin`, `user-agent`, `forwarded`, `x-forwarded-for` and `x-real-ip` headers to telemetry for gRPC requests ([#1982](https://github.com/0xMiden/node/pull/1982)). - Trace additional RPC request properties e.g. `account.id` in `GetAccount` ([#1983](https://github.com/0xMiden/node/pull/1983)). - Fixed occasional mempool panic during transaction submission, causing the lock to be held for longer than expected ([#1984](https://github.com/0xMiden/node/pull/1984)). +- Optimize `GetAccount` implementation: `all_entries` requests now mostly use state from `AccountStateForest` ([#2012](https://github.com/0xMiden/node/pull/2012)). ## v0.14.9 (2026-04-21) diff --git a/Cargo.lock b/Cargo.lock index 34eab17397..e980114ea4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -688,6 +688,17 @@ dependencies = [ "tracing", ] +[[package]] +name = "backon" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef" +dependencies = [ + "fastrand", + "gloo-timers", + "tokio", +] + [[package]] name = "backtrace" version = "0.3.76" @@ -1963,6 +1974,18 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + [[package]] name = "governor" version = "0.10.4" @@ -2304,7 +2327,7 @@ dependencies = [ "libc", "percent-encoding", "pin-project-lite", - "socket2 0.5.10", + "socket2 0.6.3", "system-configuration", "tokio", "tower-service", @@ -3495,6 +3518,7 @@ name = "miden-ntx-builder" version = "0.15.0" dependencies = [ "anyhow", + "backon", "build-rs", "clap", "diesel", @@ -4973,7 +4997,7 @@ dependencies = [ "quinn-udp", "rustc-hash", "rustls 0.23.37", - "socket2 0.5.10", + "socket2 0.6.3", "thiserror 2.0.18", "tokio", "tracing", @@ -5011,7 +5035,7 @@ dependencies = [ "cfg_aliases", "libc", "once_cell", - "socket2 0.5.10", + "socket2 0.6.3", "tracing", "windows-sys 0.60.2", ] diff --git a/Cargo.toml b/Cargo.toml index 4e90f07a16..6ae414d7bb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,6 +76,7 @@ miden-crypto = { version = "0.23" } anyhow = { version = "1.0" } assert_matches = { version = "1.5" } async-trait = { version = "0.1" } +backon = { version = "1.6" } build-rs = { version = "0.3" } clap = { features = ["derive"], version = "4.5" } codegen = { version = "0.3" } diff --git a/bin/ntx-builder/Cargo.toml b/bin/ntx-builder/Cargo.toml index 67106ffc19..dec37c2035 100644 --- a/bin/ntx-builder/Cargo.toml +++ b/bin/ntx-builder/Cargo.toml @@ -19,6 +19,7 @@ doctest = false [dependencies] anyhow = { workspace = true } +backon = { workspace = true } clap = { features = ["env", "string"], workspace = true } diesel = { features = ["numeric", "sqlite"], workspace = true } futures = { workspace = true } diff --git a/bin/ntx-builder/src/actor/execute.rs b/bin/ntx-builder/src/actor/execute.rs index c2152dab89..69bc220137 100644 --- a/bin/ntx-builder/src/actor/execute.rs +++ b/bin/ntx-builder/src/actor/execute.rs @@ -1,6 +1,8 @@ use std::collections::{BTreeSet, HashMap}; use std::sync::{Arc, Mutex}; +use std::time::Duration; +use backon::{ExponentialBuilder, Retryable}; use miden_node_utils::ErrorReport; use miden_node_utils::lru_cache::LruCache; use miden_node_utils::spawn::spawn_blocking_in_current_span; @@ -53,7 +55,7 @@ use tracing::{Instrument, instrument}; use crate::COMPONENT; use crate::actor::candidate::TransactionCandidate; -use crate::clients::{BlockProducerClient, StoreClient, ValidatorClient}; +use crate::clients::{BlockProducerClient, StoreClient, StoreError, ValidatorClient}; use crate::db::Db; #[derive(Debug, thiserror::Error)] @@ -74,6 +76,53 @@ pub enum NtxError { type NtxResult = Result; +/// Returns `true` for gRPC status codes that indicate a transient transport- or server-side problem +/// worth retrying. Content-rejection codes (`InvalidArgument`, `FailedPrecondition`, ...) reflect +/// the batch itself and are not retried. +fn is_transient_status(status: &tonic::Status) -> bool { + matches!( + status.code(), + tonic::Code::Unavailable + | tonic::Code::DeadlineExceeded + | tonic::Code::Cancelled + | tonic::Code::Aborted + | tonic::Code::Unknown + | tonic::Code::Internal + | tonic::Code::ResourceExhausted, + ) +} + +/// Returns `true` for `StoreError`s that originate from a transient gRPC condition. All other store +/// errors (deserialization, missing fields) are content errors and are not retried. +fn is_transient_store_error(err: &StoreError) -> bool { + matches!(err, StoreError::GrpcClientError(status) if is_transient_status(status)) +} + +/// Maximum number of retries applied to a single transient request before the error is propagated +/// to the actor-level retry. +const MAX_REQUEST_RETRIES: usize = 20; + +/// Builds the [`ExponentialBuilder`] used to back off retries on transient request failures. +fn request_backoff(initial: Duration, max: Duration) -> ExponentialBuilder { + ExponentialBuilder::default() + .with_min_delay(initial) + .with_max_delay(max) + .with_factor(2.0) + .with_max_times(MAX_REQUEST_RETRIES) + .with_jitter() +} + +/// Emits a structured warning for a transient NTX request failure that is about to be retried. +fn log_transient_retry(operation: &'static str, err: &E, sleep: Duration) { + tracing::warn!( + target: COMPONENT, + operation, + err = %err.as_report(), + sleep_ms = sleep.as_millis() as u64, + "ntx transient request failure; retrying after backoff", + ); +} + /// The result of a successful transaction execution. /// /// Contains the transaction ID, any notes that failed during filtering, and note scripts fetched @@ -109,10 +158,14 @@ pub struct NtxContext { /// Maximum number of VM execution cycles for network transactions. max_cycles: u32, + + /// [`ExponentialBuilder`] used to back off retries on transient request failures. + request_backoff: ExponentialBuilder, } impl NtxContext { /// Creates a new [`NtxContext`] instance. + #[expect(clippy::too_many_arguments)] pub fn new( block_producer: BlockProducerClient, validator: ValidatorClient, @@ -121,7 +174,10 @@ impl NtxContext { script_cache: LruCache, db: Db, max_cycles: u32, + request_backoff_initial: Duration, + request_backoff_max: Duration, ) -> Self { + let request_backoff = request_backoff(request_backoff_initial, request_backoff_max); Self { block_producer, validator, @@ -130,9 +186,15 @@ impl NtxContext { script_cache, db, max_cycles, + request_backoff, } } + /// Returns the [`ExponentialBuilder`] used for per-request retry backoff. + fn request_backoff(&self) -> ExponentialBuilder { + self.request_backoff + } + /// Creates a [`TransactionExecutor`] configured with the network transaction cycle limit. fn create_executor<'a, 'b>( &self, @@ -214,6 +276,7 @@ impl NtxContext { ctx.store.clone(), ctx.script_cache.clone(), ctx.db.clone(), + ctx.request_backoff, ); handle.block_on( async { @@ -332,10 +395,20 @@ impl NtxContext { /// Delegates the transaction proof to the remote prover if configured, otherwise performs the /// proof locally. + /// + /// Transient transport failures against the remote prover are retried in-place; intrinsic + /// proving errors (witness rejected, malformed inputs) escape on the first attempt. #[instrument(target = COMPONENT, name = "ntx.execute_transaction.prove", skip_all, err)] async fn prove(&self, tx_inputs: &TransactionInputs) -> NtxResult { if let Some(remote) = &self.prover { - remote.prove(tx_inputs).await + (|| async { remote.prove(tx_inputs).await }) + .retry(self.request_backoff()) + .when(|err| matches!(err, TransactionProverError::Other { .. })) + .notify(|err, dur| { + log_transient_retry("remote_prover.prove", err, dur); + }) + .await + .map_err(NtxError::Proving) } else { // Only perform tx inputs clone for local proving. let tx_inputs = tx_inputs.clone(); @@ -350,28 +423,41 @@ impl NtxContext { }) .await .unwrap_or_else(|e| std::panic::resume_unwind(e.into_panic())) + .map_err(NtxError::Proving) } - .map_err(NtxError::Proving) } /// Submits the transaction to the block producer. + /// + /// Transient gRPC failures (`Unavailable`, `DeadlineExceeded`, ...) are retried in-place; + /// content-rejection codes escape on the first attempt so the actor can mark the batch failed. #[instrument(target = COMPONENT, name = "ntx.execute_transaction.submit", skip_all, err)] async fn submit(&self, proven_tx: &ProvenTransaction) -> NtxResult<()> { - self.block_producer - .submit_proven_tx(proven_tx) + (|| async { self.block_producer.submit_proven_tx(proven_tx).await }) + .retry(self.request_backoff()) + .when(is_transient_status) + .notify(|status, dur| { + log_transient_retry("block_producer.submit_proven_tx", status, dur); + }) .await .map_err(NtxError::Submission) } /// Validates the transaction against the Validator. + /// + /// Transient gRPC failures are retried in-place; content-rejection codes escape immediately. #[instrument(target = COMPONENT, name = "ntx.execute_transaction.validate", skip_all, err)] async fn validate( &self, proven_tx: &ProvenTransaction, tx_inputs: &TransactionInputs, ) -> NtxResult<()> { - self.validator - .submit_proven_transaction(proven_tx, tx_inputs) + (|| async { self.validator.submit_proven_transaction(proven_tx, tx_inputs).await }) + .retry(self.request_backoff()) + .when(is_transient_status) + .notify(|status, dur| { + log_transient_retry("validator.submit_proven_transaction", status, dur); + }) .await .map_err(NtxError::Submission) } @@ -424,6 +510,8 @@ struct NtxDataStore { /// to the store could be "wrong", but given that two identical maps have identical witnesses /// this does not cause issues in practice. storage_slots: Arc>>, + /// Per-request retry backoff for transient store failures. + request_backoff: ExponentialBuilder, } impl NtxDataStore { @@ -435,6 +523,7 @@ impl NtxDataStore { store: StoreClient, script_cache: LruCache, db: Db, + request_backoff: ExponentialBuilder, ) -> Self { let mast_store = TransactionMastStore::new(); mast_store.load_account_code(account.code()); @@ -449,9 +538,15 @@ impl NtxDataStore { db, fetched_scripts: Arc::new(Mutex::new(Vec::new())), storage_slots: Arc::new(Mutex::new(HashMap::default())), + request_backoff, } } + /// Returns the [`ExponentialBuilder`] used for per-request retry backoff against the store. + fn store_backoff(&self) -> ExponentialBuilder { + self.request_backoff + } + /// Returns the list of note scripts fetched from the remote store during execution. fn take_fetched_scripts(&self) -> Vec<(Word, NoteScript)> { self.fetched_scripts @@ -513,11 +608,18 @@ impl DataStore for NtxDataStore { async move { debug_assert_eq!(ref_block, self.reference_block.block_num()); - // Get foreign account inputs from store. + // Get foreign account inputs from store, retrying on transient gRPC failures. let account_inputs = - self.store.get_account_inputs(foreign_account_id, ref_block).await.map_err( - |err| DataStoreError::other_with_source("failed to get account inputs", err), - )?; + (|| async { self.store.get_account_inputs(foreign_account_id, ref_block).await }) + .retry(self.store_backoff()) + .when(is_transient_store_error) + .notify(|err, dur| { + log_transient_retry("store.get_account_inputs", err, dur); + }) + .await + .map_err(|err| { + DataStoreError::other_with_source("failed to get account inputs", err) + })?; // Ensure foreign account procedures are available to the executor via the mast store. // This assumes the code was not loaded from before @@ -539,14 +641,24 @@ impl DataStore for NtxDataStore { async move { let ref_block = self.reference_block.block_num(); - // Get vault asset witnesses from the store. - let witnesses = self - .store - .get_vault_asset_witnesses(account_id, vault_keys, Some(ref_block)) - .await - .map_err(|err| { - DataStoreError::other_with_source("failed to get vault asset witnesses", err) - })?; + // Get vault asset witnesses from the store, retrying on transient gRPC failures. + let witnesses = (|| { + let vault_keys = vault_keys.clone(); + async move { + self.store + .get_vault_asset_witnesses(account_id, vault_keys, Some(ref_block)) + .await + } + }) + .retry(self.store_backoff()) + .when(is_transient_store_error) + .notify(|err, dur| { + log_transient_retry("store.get_vault_asset_witnesses", err, dur); + }) + .await + .map_err(|err| { + DataStoreError::other_with_source("failed to get vault asset witnesses", err) + })?; Ok(witnesses) } @@ -573,14 +685,24 @@ impl DataStore for NtxDataStore { let ref_block = self.reference_block.block_num(); - // Get storage map witness from the store. - let witness = self - .store - .get_storage_map_witness(account_id, slot_name, map_key, Some(ref_block)) - .await - .map_err(|err| { - DataStoreError::other_with_source("failed to get storage map witness", err) - })?; + // Get storage map witness from the store, retrying on transient gRPC failures. + let witness = (|| { + let slot_name = slot_name.clone(); + async move { + self.store + .get_storage_map_witness(account_id, slot_name, map_key, Some(ref_block)) + .await + } + }) + .retry(self.store_backoff()) + .when(is_transient_store_error) + .notify(|err, dur| { + log_transient_retry("store.get_storage_map_witness", err, dur); + }) + .await + .map_err(|err| { + DataStoreError::other_with_source("failed to get storage map witness", err) + })?; Ok(witness) } @@ -611,9 +733,15 @@ impl DataStore for NtxDataStore { return Ok(Some(script)); } - // 3. Remote store. - let maybe_script = - self.store.get_note_script_by_root(script_root).await.map_err(|err| { + // 3. Remote store, retrying on transient gRPC failures. + let maybe_script = (|| async { self.store.get_note_script_by_root(script_root).await }) + .retry(self.store_backoff()) + .when(is_transient_store_error) + .notify(|err, dur| { + log_transient_retry("store.get_note_script_by_root", err, dur); + }) + .await + .map_err(|err| { DataStoreError::other_with_source( "failed to retrieve note script from store", err, @@ -643,3 +771,62 @@ impl MastForestStore for NtxDataStore { self.mast_store.get(procedure_hash) } } + +#[cfg(test)] +mod tests { + use miden_tx::TransactionProverError; + + use super::{StoreError, is_transient_status, is_transient_store_error}; + + #[test] + fn transient_status_classifies_transport_codes() { + let transient = [ + tonic::Status::unavailable("u"), + tonic::Status::deadline_exceeded("d"), + tonic::Status::cancelled("c"), + tonic::Status::aborted("a"), + tonic::Status::unknown("u"), + tonic::Status::internal("i"), + tonic::Status::resource_exhausted("r"), + ]; + for s in &transient { + assert!(is_transient_status(s), "{:?} should be transient", s.code()); + } + + let terminal = [ + tonic::Status::invalid_argument("ia"), + tonic::Status::failed_precondition("fp"), + tonic::Status::out_of_range("oor"), + tonic::Status::not_found("nf"), + tonic::Status::already_exists("ae"), + tonic::Status::unauthenticated("ua"), + tonic::Status::permission_denied("pd"), + tonic::Status::unimplemented("ui"), + tonic::Status::data_loss("dl"), + ]; + for s in &terminal { + assert!(!is_transient_status(s), "{:?} should be terminal", s.code()); + } + } + + #[test] + fn transient_store_error_only_for_transient_grpc() { + let transient = StoreError::GrpcClientError(tonic::Status::unavailable("down")); + assert!(is_transient_store_error(&transient)); + + let terminal_grpc = + StoreError::GrpcClientError(tonic::Status::invalid_argument("bad input")); + assert!(!is_transient_store_error(&terminal_grpc)); + + let malformed = StoreError::MalformedResponse("bad".into()); + assert!(!is_transient_store_error(&malformed)); + } + + /// Smoke-test that the predicates used by the request-level retry wrappers compile and select + /// the expected variants. Prover transport failures live behind `Other` only. + #[test] + fn prover_other_is_the_retried_variant() { + let err = TransactionProverError::other("remote prover unreachable"); + assert!(matches!(err, TransactionProverError::Other { .. })); + } +} diff --git a/bin/ntx-builder/src/actor/mod.rs b/bin/ntx-builder/src/actor/mod.rs index f53815f484..cefb9bdb65 100644 --- a/bin/ntx-builder/src/actor/mod.rs +++ b/bin/ntx-builder/src/actor/mod.rs @@ -81,6 +81,12 @@ pub struct ActorConfig { pub idle_timeout: Duration, /// Maximum number of VM execution cycles for network transactions. pub max_cycles: u32, + /// Initial sleep applied between per-request retries on transient infrastructure failures + /// (prover unreachable, validator/block-producer transport error, store gRPC hiccup). Doubles + /// each retry up to [`Self::request_backoff_max`]. + pub request_backoff_initial: Duration, + /// Upper bound on the per-request retry backoff sleep. + pub request_backoff_max: Duration, } // ACCOUNT ACTOR CONTEXT @@ -133,6 +139,8 @@ impl AccountActorContext { max_note_attempts: 1, idle_timeout: Duration::from_secs(60), max_cycles: 1 << 18, + request_backoff_initial: Duration::from_millis(1), + request_backoff_max: Duration::from_millis(10), }, request_tx, } @@ -401,6 +409,11 @@ impl AccountActor { /// Execute a transaction candidate and mark notes as failed as required. /// /// Returns the new actor mode based on the execution result. + /// + /// Transient infrastructure failures (prover unreachable, validator/block-producer transport + /// hiccup, store gRPC error) are retried inside [`execute::NtxContext::execute_transaction`]. + /// Any error reaching this method is therefore terminal for the candidate: the batch's notes + /// are marked failed and the actor moves on. #[tracing::instrument(name = "ntx.actor.execute_transactions", skip(self, tx_candidate))] async fn execute_transactions( &self, @@ -418,6 +431,8 @@ impl AccountActor { self.state.script_cache.clone(), self.state.db.clone(), self.config.max_cycles, + self.config.request_backoff_initial, + self.config.request_backoff_max, ); let notes = tx_candidate.notes.clone(); diff --git a/bin/ntx-builder/src/clients/mod.rs b/bin/ntx-builder/src/clients/mod.rs index 19814602bb..6c7a616c92 100644 --- a/bin/ntx-builder/src/clients/mod.rs +++ b/bin/ntx-builder/src/clients/mod.rs @@ -3,5 +3,5 @@ mod store; mod validator; pub use block_producer::BlockProducerClient; -pub use store::StoreClient; +pub use store::{StoreClient, StoreError}; pub use validator::ValidatorClient; diff --git a/bin/ntx-builder/src/lib.rs b/bin/ntx-builder/src/lib.rs index ec6cb147c9..c280a5e4a1 100644 --- a/bin/ntx-builder/src/lib.rs +++ b/bin/ntx-builder/src/lib.rs @@ -66,6 +66,14 @@ const DEFAULT_IDLE_TIMEOUT: Duration = Duration::from_secs(5 * 60); /// Default maximum number of crashes an account actor is allowed before being deactivated. const DEFAULT_MAX_ACCOUNT_CRASHES: usize = 10; +/// Default initial sleep applied between per-request retries on transient infrastructure failures +/// (downed prover, transport error, validator/block-producer crash, store gRPC hiccup). Doubles on +/// each retry up to [`DEFAULT_REQUEST_BACKOFF_MAX`]. +const DEFAULT_REQUEST_BACKOFF_INITIAL: Duration = Duration::from_millis(100); + +/// Default upper bound on the per-request retry backoff sleep. +const DEFAULT_REQUEST_BACKOFF_MAX: Duration = Duration::from_secs(30); + /// Default maximum number of VM execution cycles allowed for a network transaction. /// /// This limits the computational cost of network transactions. The protocol maximum is @@ -130,6 +138,15 @@ pub struct NtxBuilderConfig { /// Defaults to 2^18 cycles. pub max_cycles: u32, + /// Initial sleep applied between per-request retries on transient infrastructure failures (e.g. + /// prover unreachable, validator/block-producer crash, transport error, store gRPC hiccup). + /// Doubles on each retry up to [`Self::request_backoff_max`]. Per-note `attempt_count` is *not* + /// advanced while retries are in progress. + pub request_backoff_initial: Duration, + + /// Upper bound on the per-request retry backoff sleep. + pub request_backoff_max: Duration, + /// Path to the SQLite database file used for persistent state. pub database_filepath: PathBuf, @@ -158,6 +175,8 @@ impl NtxBuilderConfig { idle_timeout: DEFAULT_IDLE_TIMEOUT, max_account_crashes: DEFAULT_MAX_ACCOUNT_CRASHES, max_cycles: DEFAULT_MAX_TX_CYCLES, + request_backoff_initial: DEFAULT_REQUEST_BACKOFF_INITIAL, + request_backoff_max: DEFAULT_REQUEST_BACKOFF_MAX, database_filepath, sqlite_connection_pool_size: miden_node_db::default_connection_pool_size(), } @@ -247,6 +266,15 @@ impl NtxBuilderConfig { self } + /// Sets the per-request retry backoff bounds (initial sleep and cap) used when retrying + /// transient infrastructure failures inside a single transaction attempt. + #[must_use] + pub fn with_request_backoff(mut self, initial: Duration, max: Duration) -> Self { + self.request_backoff_initial = initial; + self.request_backoff_max = max; + self + } + /// Sets the SQLite connection pool size. #[must_use] pub fn with_sqlite_connection_pool_size(mut self, size: NonZeroUsize) -> Self { @@ -325,6 +353,8 @@ impl NtxBuilderConfig { max_note_attempts: self.max_note_attempts, idle_timeout: self.idle_timeout, max_cycles: self.max_cycles, + request_backoff_initial: self.request_backoff_initial, + request_backoff_max: self.request_backoff_max, }, request_tx, }; diff --git a/crates/block-producer/src/mempool/graph/batch.rs b/crates/block-producer/src/mempool/graph/batch.rs index 03a3c276f3..c42257c8ca 100644 --- a/crates/block-producer/src/mempool/graph/batch.rs +++ b/crates/block-producer/src/mempool/graph/batch.rs @@ -98,7 +98,7 @@ impl BatchGraph { /// /// Batches are returned in reverse-chronological order. pub fn revert_expired(&mut self, chain_tip: BlockNumber) -> Vec { - // We only revert transactions which are _not_ included in batches. + // We only revert batches which are _not_ included in blocks. let mut to_revert = self.inner.expired(chain_tip); to_revert.retain(|batch| !self.inner.is_selected(batch)); diff --git a/crates/block-producer/src/mempool/graph/transaction.rs b/crates/block-producer/src/mempool/graph/transaction.rs index fe2a5570d3..d9583b03c5 100644 --- a/crates/block-producer/src/mempool/graph/transaction.rs +++ b/crates/block-producer/src/mempool/graph/transaction.rs @@ -77,12 +77,8 @@ pub struct TransactionGraph { /// used to identify potentially buggy transactions that should be evicted. failures: HashMap, - /// Defines the transactions that belong to a user batch. - user_batch_txs: HashMap>, - /// A mapping of transactions to their user batch (if any). - /// - /// Inverse map of `user_batch_txs`. - txs_user_batch: HashMap, + /// Bijective mapping of user batches and their transactions. + user_batches: BatchTxMap, } impl TransactionGraph { @@ -93,6 +89,9 @@ impl TransactionGraph { self.inner.append(tx) } + /// Appends the transactions into the graph as an atomic unit. + /// + /// These transactions can only be selected as a batch, and are reverted and pruned together. pub fn append_user_batch( &mut self, batch: &[Arc], @@ -115,67 +114,66 @@ impl TransactionGraph { } let txs = batch.iter().map(GraphNode::id).collect::>(); - for tx in &txs { - self.txs_user_batch.insert(*tx, batch_id); - } - self.user_batch_txs.insert(batch_id, txs); + self.user_batches.insert(batch_id, txs); Ok(()) } pub fn select_batch(&mut self, budget: BatchBudget) -> Option { - self.select_user_batch().or_else(|| self.select_conventional_batch(budget)) + self.select_user_batch().or_else(|| self.select_internal_batch(budget)) } fn select_user_batch(&mut self) -> Option { - // Comb through all user batch candidates. - let candidate_batches = self - .inner - .selection_candidates() - .values() - .filter_map(|tx| self.txs_user_batch.get(&tx.id())) - .copied() - .collect::>(); - - 'outer: for candidate in candidate_batches { - let mut selected = SelectedBatch::builder(); - - let txs = self - .user_batch_txs - .get(&candidate) - .cloned() - .expect("bi-directional mapping should be coherent"); - - for tx in txs { - let Some(tx) = self.inner.selection_candidates().get(&tx).copied() else { - // Rollback this batch selection since it cannot complete. - for tx in selected.txs.into_iter().rev() { - self.inner.deselect(tx.id()); - } - - continue 'outer; - }; - let tx = Arc::clone(tx); - - self.inner.select_candidate(tx.id()); - selected.push(tx); + let candidate_batches = self.user_batches.batches().copied().collect::>(); + for candidate in candidate_batches { + if let Some(batch) = self.try_select_user_batch_candidate(candidate) { + return Some(batch); } - - assert!(!selected.is_empty(), "User batch should not be empty"); - return Some(selected.build()); } None } - fn select_conventional_batch(&mut self, mut budget: BatchBudget) -> Option { + /// Attempts to select all transactions from the candidate user batch. + /// + /// This action succeeds if all transactions in the batch can be sequentially selected. + /// If any transaction cannot be selected, then all previous selections are rolled back, + /// and `None` is returned. This makes this function atomic. + /// + /// Transactions can fail selection if they depend on any external transactions that have + /// not yet been selected. + fn try_select_user_batch_candidate(&mut self, candidate: BatchId) -> Option { + let mut selected = SelectedBatch::builder(); + + let txs = self.user_batches.get_txs_contained_in_batch(&candidate)?; + + for tx in txs { + let Some(tx) = self.inner.selection_candidates().get(&tx).copied() else { + // Rollback this batch selection since it cannot complete. + for tx in selected.txs.into_iter().rev() { + self.inner.deselect(tx.id()); + } + + return None; + }; + let tx = Arc::clone(tx); + + self.inner.select_candidate(tx.id()); + selected.push(tx); + } + + assert!(!selected.is_empty(), "User batch should not be empty"); + Some(selected.build()) + } + + fn select_internal_batch(&mut self, mut budget: BatchBudget) -> Option { let mut selected = SelectedBatch::builder(); loop { // Select arbitrary candidate which is _not_ part of a user batch. let candidates = self.inner.selection_candidates(); let Some(candidate) = - candidates.values().find(|tx| !self.txs_user_batch.contains_key(&tx.id())) + candidates.values().find(|tx| !self.user_batches.contains_tx(&tx.id())) else { break; }; @@ -213,7 +211,6 @@ impl TransactionGraph { /// _before_ calling this function. i.e. first revert expired batches and deselect their /// transactions, then call this. pub fn revert_expired(&mut self, chain_tip: BlockNumber) -> HashSet { - // We only revert transactions which are _not_ included in batches. let mut to_revert = self.inner.expired(chain_tip); to_revert.retain(|tx| !self.inner.is_selected(tx)); @@ -256,10 +253,10 @@ impl TransactionGraph { // transactions in, which will result in at least the current transaction being // duplicated in `to_revert`. This isn't a concern though since we skip already // processed transactions at the top of the loop. - if let Some(batch) = self.txs_user_batch.remove(&tx.id()) { - if let Some(batch) = self.user_batch_txs.remove(&batch) { - to_revert.extend(batch); - } + if let Some(batch_id) = self.user_batches.get_batch_containing_tx(&tx.id()).copied() + { + let batch_txs = self.user_batches.remove(&batch_id); + to_revert.extend_from_slice(&batch_txs); } } @@ -322,9 +319,8 @@ impl TransactionGraph { for tx in batch.transactions() { self.inner.prune(tx.id()); self.failures.remove(&tx.id()); - self.txs_user_batch.remove(&tx.id()); } - self.user_batch_txs.remove(&batch.id()); + self.user_batches.remove(&batch.id()); } /// Number of transactions which have not been selected for inclusion in a batch. @@ -349,3 +345,47 @@ impl TransactionGraph { self.inner.output_note_count() } } + +// BIJECTIVE MAP +// ================================================================================================ + +/// A bijective mapping of batches and their transactions. +#[derive(Clone, Debug, PartialEq, Default)] +struct BatchTxMap { + by_batch: HashMap>, + by_tx: HashMap, +} + +impl BatchTxMap { + fn insert(&mut self, batch: BatchId, txs: Vec) { + for tx in &txs { + assert!(self.by_tx.insert(*tx, batch).is_none()); + } + assert!(self.by_batch.insert(batch, txs).is_none()); + } + + fn remove(&mut self, batch: &BatchId) -> Vec { + let txs = self.by_batch.remove(batch).unwrap_or_default(); + for tx in &txs { + self.by_tx.remove(tx); + } + txs + } + + fn batches(&self) -> impl Iterator { + self.by_batch.keys() + } + + /// Returns the [`BatchId`] mapped to this transaction, if any. + fn get_batch_containing_tx(&self, tx: &TransactionId) -> Option<&BatchId> { + self.by_tx.get(tx) + } + + fn get_txs_contained_in_batch(&self, batch: &BatchId) -> Option<&[TransactionId]> { + self.by_batch.get(batch).map(Vec::as_slice) + } + + fn contains_tx(&self, tx: &TransactionId) -> bool { + self.by_tx.contains_key(tx) + } +} diff --git a/crates/utils/src/tracing/grpc.rs b/crates/utils/src/tracing/grpc.rs index 1a7b0ff1fc..30d0f9501e 100644 --- a/crates/utils/src/tracing/grpc.rs +++ b/crates/utils/src/tracing/grpc.rs @@ -1,4 +1,5 @@ use http::header::HeaderName; +use tower_governor::key_extractor::{KeyExtractor, SmartIpKeyExtractor}; use tracing::field; use crate::tracing::OpenTelemetrySpanExt; @@ -20,20 +21,12 @@ pub fn grpc_trace_fn(request: &http::Request) -> tracing::Span { // Create a span with a generic, static name. Fields to be recorded after needs to be // initialized as empty since otherwise the assignment will have no effect. - let span = match method { - "SyncState" | "SyncNullifiers" => tracing::debug_span!( - "rpc", - otel.name = field::Empty, - rpc.service = service, - rpc.method = method - ), - _ => tracing::info_span!( - "rpc", - otel.name = field::Empty, - rpc.service = service, - rpc.method = method - ), - }; + let span = tracing::info_span!( + "rpc", + otel.name = field::Empty, + rpc.service = service, + rpc.method = method + ); // Set the span name via otel.name let otel_name = format!("{service}/{method}"); @@ -63,9 +56,17 @@ pub fn grpc_trace_fn(request: &http::Request) -> tracing::Span { .extensions() .get::() .and_then(tonic::transport::server::TcpConnectInfo::remote_addr); - if let Some(addr) = remote_addr { + + // client.address should be the resolved IP address of the client, if available. In the case of + // a reverse proxy, this may not be the same as the remote address. + if let Ok(ip) = SmartIpKeyExtractor.extract(request) { + span.set_attribute("client.address", ip); + } else if let Some(addr) = remote_addr { span.set_attribute("client.address", addr.ip()); span.set_attribute("client.port", addr.port()); + } + + if let Some(addr) = remote_addr { span.set_attribute("network.peer.address", addr.ip()); span.set_attribute("network.peer.port", addr.port()); span.set_attribute("network.transport", "tcp"); diff --git a/docs/external/src/img/node_architecture.svg b/docs/external/src/img/node_architecture.svg deleted file mode 100644 index ba697edf6b..0000000000 --- a/docs/external/src/img/node_architecture.svg +++ /dev/null @@ -1,4 +0,0 @@ - - -eyJ2ZXJzaW9uIjoiMSIsImVuY29kaW5nIjoiYnN0cmluZyIsImNvbXByZXNzZWQiOnRydWUsImVuY29kZWQiOiJ4nO19WXfiyJb1+/1cdTAwMTVe1Y9foY556Dc8z/P8VS8vwFx1MDAxOGMzmcHG7nX/e58jXHUwMDBmXGIpJCRQkmQvXFy36mZcdTAwMWFcdTAwMTBcdTAwMTFS7HP2mf/nXysrf/XfO9W//mvlr+qwUmrU77ult7/+xt+/Vru9ertcdTAwMDUvMf/vvfagW/Hf+djvd3r/9Z//Wep0vNGnvEq7+fnJaqParLb6PXjv/4e/r6z8j/9feKV+j5/fIOv7tWHlcv9071rrouaN0+O6/1H/Td9cdTAwMGLqViv9UqvWqI5eXHUwMDFhwu8ptcojllx1MDAxM6aY1YLzn1ff4VUpqPC0ZZpcdTAwMTmrLGH259W3+n3/XHUwMDExP6+ZJy3X8ueVx2q99tiHl6z1tIBcdTAwMGZxXHUwMDAxL1x1MDAxM0JGl/5cXMd/rZCf3/T63fZzda3daHdxsf9Bq/jPaKnlUuW51m1cdTAwMGZa9z/v6XdLrV6n1IV7M3rfQ73ROOu/+1eHe1xm9/Kv0HdcXH0vPPT7uE/Bl9ZcdTAwMWVb1V5v7DPtTqlS7+MtomS0XHUwMDBiXFxhZ+fef1T/PVpTt9Ss7uCzalxyXHUwMDFhjZ9f11v3VXxcdTAwMDJ/lcXB2Ne17r++buztvWpcdTAwMTUvQVxyXHUwMDEzVnK4rz+vjI5cdTAwMTY8TFx1MDAxM/71YbvlnzNcdTAwMDNPiWrJ2GhcdTAwMDG9dThbff+yXHUwMDBmpUavOrrbuIiNwLlcdTAwMWJtZtC5L31+XHUwMDA0L8ZcdTAwMTWnTFx1MDAxODl6+o166zm89Ea78jz6XHUwMDE2/7f//tt1lE376GC3d7Y7eLo1xb3zi/c9ubqX/ihr7jFtpbBcdTAwMWHuXHUwMDBmh+M8fpa1klx1MDAxZTH4XHUwMDAyp8QwXHUwMDE1OctGWVx1MDAwZs669lx1MDAwZmz0PHNDPFx1MDAxYvjR8z7PlW671ys8lvqVxz/gVJtt96n+fuajXHUwMDA3yr9+8+/IYVdGwYGnMnKq4UVBZNxZZ9pwIanI+ahzq6Tg+Vx1MDAxY/X1gjxcdTAwMTPi7uqj3W1cdTAwMWPQ2+5up2BthqNOPUlcdTAwMDSVllx1MDAxMus46iCuPa6kskpYw11H3dDoXHUwMDAxXHUwMDE3jHtcdTAwMWGkvVVcdTAwMDZcdTAwMDQ3/IjlXHRPPOG7s59wRqRcdTAwMTJcdTAwMDLOueOEc6ZjTzilijEltcn5jEuhVFx1MDAwMDgznfGBum2R182zrdftTqV0/PJsb2t3qc94XHUwMDAxZLlcdTAwMDesQUlcdTAwMDBcdTAwMWUhSpNcdTAwMTA3oUJ4Qlx1MDAxM2qMMtIlz5nRcIHRj+PIXHUwMDAzRDyqlYZcdTAwMWJJmVxccpT4s34481mHO8xcZlx1MDAwN+7iOOpSxlxuc9DVVILO1lMxl5/ljVx1MDAxNlx1MDAxYTh6/epw9GBcdTAwMDInl9dcdTAwMGXLjV6ldNlsXHUwMDE3Lq/ahf7HqX7+6+d9//7bfdnPXHUwMDBmV9hdbevoqdFcdTAwMTfnW6u73cfuXHUwMDAzK6yOf8v395e63fZb4Lpff4rFp1x1MDAwMUmvXGbNSVx1MDAwN7l3XHUwMDE5wefYTfqEJlXC41x1MDAwNiRcdTAwMTe1VFxuYFZhZNpkZErtacWt1kRcdTAwMTJcdTAwMWZ5XHUwMDBltiWXUIyB4lFcdTAwMTZzwVrJZJBcdTAwMDJcdTAwMDRAR2ks6JRCaahcdTAwMDJPNlx1MDAwZv0yxflcdTAwMWRcdTAwMWRHPIaw/9PjtcBcdTAwMDNst/pn9Vx1MDAwZl8lmrHfbpaa9YZ/XHUwMDFhx65QbNRrLVx1MDAxZqWw2Gr3r+BccujXwfr+eUO/3Vx1MDAxOb1agSuW6q1qdyeNZmt367V6q9Q4dy25NOi3T6u9z0X3u4Nq8GZUt7/PP/WYTMBuspBcdFx0mHHwXG6tXHUwMDEy9aqiXGbVplCMMu5cIo9wnjyGMlnB85Q6wM5/0Es8XHUwMDAzp4sqMLU4MfDoRydtieZxNFx1MDAxZqdVrCyWRFx1MDAwMmlcdTAwMTNoiDtBLmJBLlxymMOKk1xc7SSpLaWaaFx1MDAxYTzWaTHeadfDenv0p5XRkfH/8vPn//7b+e7YY4o/hehcdFx1MDAxZF0vooZcdTAwMWKlXn+t3WzW+7DRY1xcZETe9kvd/io81nqrXHUwMDE2fq3aulx1MDAxZr1cdTAwMTJ4rl+evU+RcvXQ2nqrV2/uqjeMdl/3zyv7RydcdTAwMDHWXHUwMDAwQq0ywFtcdTAwMDMrJ1x1MDAwMF240WBcdTAwMDRcdTAwMTB47pRpXHUwMDExeF+t1IF3Wdg6XHUwMDExRlxiRlx1MDAwNFx1MDAwMzUtoodcdTAwMDdXXFxE+fBYLUVcdTAwMGUorDn4XHUwMDFhXHUwMDAwrlx1MDAxZeLo1Ua5/ZaKZ9TPzl5qW1fdXHUwMDE3XbiSz2+Vl6tXvZ2KZ1xiIcHOjVx1MDAxN1XSXHUwMDE4eD1BVFHuIP1sXHUwMDA02qUwXHUwMDFhXHUwMDE3RidcdTAwMTmoXHUwMDA1UVZKbqMuR19FRFj+t9RcdTAwMTEodpRcIvkyXHUwMDBisIZcdTAwMDHNbCZm0Vx1MDAxYpRcdTAwMDHhK51u+7XaWulcdTAwMGadNIOqsd/+SpoxtvYwp4hfbD5cdTAwMDSjt/5eulx1MDAxMN33gXku1fZ443BrvZrFeGfUU9pcblx1MDAwZarJhVxcZpinwHCINVx1MDAxMahcdTAwMWE5P36QS+koXHUwMDAysYTuOHRP00PXXHUwMDAw+lxic2BcdTAwMTTtLsvCv/1xOoHeIUDg2VROp1x1MDAxZlxylc1cdTAwMTLnj6u2VnzrvOyWrpvDQ3N4/vKQ1lx1MDAxMj842NrfPTvrbeuLer32PJD86kDkZIlzn1fk5Clz7zKNhlx1MDAwNFx1MDAwM8+zQnNt4MGAJpQhnHHGPJqIM8I9yUGRXHUwMDFhpalxxT3EUl3GYe4sPeZcdTAwMThRXHUwMDAyfbZO0Fx0XHUwMDEyb4ljuEpcdTAwMWJcdTAwMWF4XG65WOLZz29EX5ZLvXplpVt9XHUwMDE5VHv9f1qw8PpcdTAwMDPotj7uaVx1MDAxZaqzWb+/XHUwMDBmKp6QkT5Bg4VcdTAwMTXq2G5W3JvJR7UmU/3JqpVcdTAwMDJitTbA/52qVVxu41FhjVZ0qVpzgfl5XHUwMDE2h1x1MDAxYkVggUXi0q0qPmRJMVx1MDAwM4OxqWzx6VTrdUOdic29w4+W7OqD5tXjaaN8O1x1MDAwNyd34nVf+Eapd25qW++6M3xb2zh7fumc5KKyv1x1MDAxY1x1MDAxM8pcdTAwMDYxO73Kdt+9dCrbYJqBgbVQXHUwMDAxf6EshF+rPZWIX1xub8D4rLJcdTAwMDJEOFx1MDAwYiB3aeNORvNFXHUwMDA2NHNhXGI8XHUwMDA36sq24SY22Vx1MDAwNlx1MDAxZVx1MDAxYyOcSp6rkfvtWiNcdTAwMTlOcERp+4rtXHUwMDFkXGZGNFx1MDAxZNtcdTAwMGaLoKgn6MOwoo7dQT7auf5Rurvr7WxVTlx1MDAwN7W702L/YLXddXBxt2fdeFx1MDAxY4lcdTAwMWXjnCpcdTAwMWHIn/jk4pp4VjOGOXHMXHUwMDEwM7qdP8i2wjOGK1xuXHUwMDA0XHLlgFx1MDAxOF1hpKg9XHUwMDA1XFzfgCFmkLBrtlxmlMUh/XJ21zrwdcpcdTAwMDHOzqA1jzWVlVx1MDAwNKhcbv0rnFxcnLDguf4trvX4c4o/hehcdTAwMTFcdTAwMWRdMKKlM/vW4zzoonV43uze7N/r3tCuX7/0d9bNR4xcdTAwMDddoXyWVEhcclx1MDAxYqCCXHUwMDA13vXpP8ctcFx1MDAwMoJfXHUwMDFhIVBcdTAwMTObyFx1MDAxMVx1MDAxOXPrR1x1MDAxNzxcdTAwMTfXunq+XFynR7esUlx1MDAxYlxcXHUwMDEy9fq0unN9V0znWvdcdTAwMWRcdTAwMDNcdTAwMWNzfi3nJpRAxoX2RKKosnCH8EfAXHUwMDE5kHArRyd9yUEmS6ar9Fx1MDAxY8RcdTAwMWFcdTAwMGJcdTAwMDREOyP4YMbHUlx1MDAxMK2U5EBgck74zcHPXHUwMDBlXHUwMDE2dvd9XHUwMDA1QNKvzoV+TOtid64zXHUwMDFmktF6a2xcdTAwMWW/1596u6/2tLt2fX/aOjqM4lx1MDAxNi9cdTAwMTnJijOJ0XskXHUwMDE5idF7qTwmXHUwMDE0cefsj1x1MDAwZctCI/a+jcpivpC9nplMSCWkYNqZXHUwMDAwx3S8212j61ZO51x1MDAxYUhwXHUwMDAwckKkncqWyJVLOM4j/rDR52anXGbx4fjp9fbYa512473mP8hJXHUwMDFhe1dcdTAwMWTcq4ve5VGRyf3nl4Pi4ep5K4r8uMRvZTysb2BcdTAwMWM0gogmflNhQPCAaKAmpsbBSE9IRaT4SvKOyoBAQHehhcBvUNs3MyfBgvkuiKFOc0LFxsxcdTAwMTlcdTAwMTVKwdOmOebAzlx1MDAxY1wi+zvpuvL65fytf77fOdxcdTAwMWFcdTAwMGVcbsMtfVYukVx1MDAxY67Lnnduj99cdTAwMWUvmlx1MDAxZNXZ5Y3VrUvNXHUwMDFm0l03XCJGot5cdTAwMTVGXHLLYl0l4Hxt7eisNdx+6eyc6sfO5eZd4eRcIn38nDGEKVx1MDAwMJlY46pl4tp6XHUwMDE2Y35aXHUwMDBiZ4FcdTAwMDfGXHUwMDA1YzJr0X1cdTAwMThMi59/0vtcdTAwMWZW5lHK4DCkzEpBpXG5/42JredQhFqpxTzd/82WXHUwMDFlKFNsXZ2b7YP76+vtfbW+k92dbvKBi3s1XHUwMDExuERcclmmMJecKcYtKEUlQz43oelcdTAwMDSgXHUwMDEw6dGlITstNspZsIHpQNKdMObwsP2kqTLGjJKL50qvt1x1MDAxZVx1MDAxYXhC5mjKlsHw+SpcZvffXHUwMDEw8qRPUDphXHUwMDAzN25cdTAwMDP52LjJ1Fwi2ZFux5PHQvUlXFxcdTAwMTJPcUPQxKVERJ1TXHUwMDE4XCJcdTAwMGaWdVx1MDAwNVTcSFxySu5cdFxm1FrB4Ep/XG7r/Vx1MDAxZKZvJVx1MDAwM8ilJlxmZKlwKkBcdTAwMTVxYv0wXFyrXHUwMDE0k4xMleUynVx1MDAwMmRbr6dk/fH1eGv3vXk5rNrti+bg1/LFgL2YpzeegVxu5GD0mXCnhVx1MDAxYz5eiOBk0vXiwTfpepE7nltsIDlcdTAwMTdoZVx1MDAxNFx1MDAxYiCeYCBUODVEYXxgVFwitfJcdTAwMWRcdTAwMWHgwY/Vh6OFjd1UjzBrXHUwMDA1XHUwMDAxpadcdTAwMTVcdTAwMTHajj1cdTAwMTJPasrQoDNcbsu3mY3cg5gwQ9z+kr1cbmP7I4RcdTAwMTE0QeHrleSEXHUwMDA3XHUwMDFmz9dcdTAwMGVlmlx1MDAxZGJcdTAwMWRcdTAwMDJcdTAwMTYvK4yQ+50ghFx1MDAxY9+ksMC7rLTUcKXBklFcdLvML2Qypq/81Z9Va5Ns4S9Zx8bEhL+m0K4nwSWItzGEfO5cIvPVXHUwMDEy4DK6jS5h5S9+p3fWqVbqpUZEXHUwMDAwwVpcIi8m6HK3rExBz1x1MDAwYkLBaZdcdTAwMTTsWFx0XHUwMDFh28ApXHUwMDE41+WUKo9cdTAwMWFBgZ+rMZY3lqBq4Fx1MDAxNkmj4bTBvVhcdTAwMDSC/oeZsPfpNbjCRjFRRY2Cz4Z/+Vx1MDAxM2zCXHUwMDEwqcBypJxJOrGa6ZmCTZ1ue1iv3q/4wZxFyHaZQIvDXHUwMDFjPWb9+VD0pjk+vtg5Llx1MDAxZD1V7jf1y0dnIMub6Z1UIJo0XHUwMDA1ocQ1hpEjTipBmKcl6Fx1MDAxOVx1MDAxYdOFhHLlMVRcdTAwMWTM7amSy1x1MDAwNiTJsK66YZ2lXHUwMDAxXHRBmiac+S1KxkeXjYGHLuV0gJ+Or7+V1MFT326/7D/3P7b3RXmjrlx1MDAwYnPIK0287l3fljW/+nj62Hx87N2+2KLV5Vx1MDAxY677x/i53U8lXHUwMDA1M2BaeNxqgsRcdTAwMTBsP1x1MDAxNnbcUZssPDBcdTAwMDVcdFx1MDAwM1hGaFx1MDAwMVx1MDAxYlrWeWZcdTAwMTFcdTAwMWNcdTAwMGbp+Vx1MDAwMHZcdTAwMWFcdTAwMTLAv9xcdTAwMTJcItZrRy1cdTAwMDPLhoJ1kDMlyOx1jlCCr1x1MDAwNNL5ee0mMIJcdFo4Jv/1l/jsksVkss+OjlelhHg+QNlDOCumseekI6OMWeIxg8lm9tNcdTAwMTRyeOLh2p6likgmli0lk1x1MDAwMF7LXHUwMDAwcLib8HhcdTAwMTRzueyA18dcIlx1MDAxYzszXHUwMDExrqcrXHUwMDA3naSeplwi/fm61YT0qFx1MDAxMET4XHLxZGa3WuLHXHUwMDBi4ZM86XLx6JhwuVxiXHUwMDFkyM2plqllhYDTXCI1oVx1MDAxYZtvSlx1MDAxNmjG8Z1xXHUwMDFi/OCUbjWMvjLBpMKYXHUwMDExMTO71ZIl80rQraZcdTAwMDFcZtYwoTnaM46OXHUwMDFjwlx1MDAwM3PHKKGsIdhMUqTZL945XHUwMDBl2+WYsSNcdTAwMTjVmLUzvme4KFx1MDAxN1x1MDAxNlBcdTAwMDP/4M5cdTAwMTP2PCcnW/QsXHUwMDA1XU3h71xmv5agnbrPrfvas3yUR1x1MDAxN53D62OlOut7XHUwMDBlL1RsToVAlyScXHUwMDFmd39YuIlcdTAwMWXTmGlcdTAwMTdcdTAwMTcqXHUwMDA2XGLC4Vx1MDAxZPnqXHUwMDFjXG7KXHUwMDFhz1x1MDAxMKVcdTAwMDRRvut7mVsxQU89ZdBT2mpquCQuPUVJNKdq5J2iWCvH+Fx1MDAxYztcYlx1MDAwZfY/9tlcdTAwMDHdqDZ69avNYnW/vX5K0lx1MDAxYX9qfWetsS8363q7evSmjlYrhYPi+LcsRlx1MDAxMaR7l2mMP1BXoFx1MDAxY6lSlFx1MDAxOatlXHUwMDE4i5IrjFx1MDAwMIO2IMqZx0glXHUwMDAwXHLzNqRcdTAwMTJWgPZbpm1kgd1zXHUwMDE22GklLXNXNCN3jIVcdTAwMWRBfYRcXP9cdTAwMTdYgDllbviPtFTBKv/eXCKYglx1MDAxMzRcXGxcdTAwMDKHe1x1MDAxZvnYhLXbx5vtrep+dWPI1i7oS/O2XFxbz6R1XHUwMDE1XGJtaoQzk1FaQLo0XHUwMDAwZFx1MDAxNq91gS9yLKhlYqzv+lx1MDAwZtKN8L5f/fxZat1E+DczwF+BeCaGOJtcdTAwMGJSXHUwMDFhkLGRXHUwMDE2osKgbJ5nTqOs3fItWl1cdTAwMTdXu4+XXHUwMDFiV5dXldfzrbRa97DxsVs/erzevGj3d043mD5ZPXtKp3WTtXnR2lVxev642322XHUwMDA3O6JHO7t5pEJfPVx1MDAxZu2X1m9cdTAwMWaGXHUwMDFkUahcdTAwMTT35MExpyldz/NlXHTup5KGJYCS15xJXG7iXHUwMDFlLDtcdTAwMTJoXHUwMDEy/dmplFx1MDAxOWBcdFx1MDAwMqtcdTAwMTRjZFx1MDAwN2NcdTAwMWXni1x1MDAxNjv+Y1hCK4OYkFozIOjOUVxylIpYco5WK1CM6SpcdTAwMWLmQ1x1MDAxMsoo1qtcdTAwMGLBXHUwMDBmJujiWH5cdTAwMTDZQj7UYOPu7GHjo655QVx1MDAxZL5LVryi+qCcmlx1MDAxYWDzfY1TheBcYrDo6CHBPWxRxaWMMVx1MDAwMZajh2aHeDs9xFx1MDAxOVx1MDAwMzHrMLP9lcR3XHUwMDE5plx1MDAwNFx1MDAwYshcdTAwMTmnc+xcdTAwMWFYXHUwMDE2J6+NPblz0bw11ePBUat5uMbmYH3/XHUwMDE2frG5vbX3tLM/OD9fXHUwMDFkXlx1MDAxY91cdTAwMWM/XHUwMDE1XG67ezlcXPfooPZ8ctjudDbX7rffTyq11+t+PVx1MDAxN37BXHUwMDE1s1xcWZZcdTAwMTO/cD/tXHUwMDE0/EJcdTAwMTHpXHUwMDE5XHUwMDBl+lx1MDAwN+SPRVM1JIFcZveMYFqgZlx1MDAwYlx1MDAwZTlcdTAwMTilpmGSozRWcoPVO8tGTJlkTydcdTAwMDO9MCDMQZDEOCFsbKKKP9Mu6G3PqVx1MDAwYoKkUsyWmOar5JXyoN64XHUwMDBmMoLfxy0mKPNov0Tn+vMhXHUwMDE2yTI4KVx1MDAwZS2o9Fx1MDAxNFHKXHUwMDFhd4W05Fg7XCK4wVxu+GBcdTAwMTbMyLPIsPdLXGaz4Mqzflo7U1SZQMrz0tPgxPhL2lxmtfhcdTAwMTZMVGmmlHampJr4IXCKYT3flN7H6WhH7UVV2PXg/aW/9rRZWj9cdTAwMWVcdTAwMGXfVzNWlCzG6Fx1MDAwNFx1MDAxN1x1MDAwNvCnXHUwMDEwOf6jK0U2l1ucOdkpujJW3GAt2JqSXHUwMDEyqlx1MDAxNbGUXHUwMDA1guTfYebIOUtcdTAwMTVcdE5cdTAwMTaOY2vgXHUwMDA0TVx1MDAxNlxuVJlgYMJEQ8HUk5FVzK9nlPuUpqBLQlx1MDAxOTCrXGb69IxcdTAwMTCWh7wxwjKct6GJUERcdTAwMDBcdTAwMWaKSFahPOHPYYOjbrSxrpjN/JtN/2FcdTAwMDK1m540aVx1MDAwMmY1iEBX80pcdTAwMTYrN6mxyp9cdTAwMWTyK1x1MDAxMvdm88j0YFx1MDAxNZX+P63y+MP6fZRpXHUwMDAyTYnMbHCvP1x1MDAxZsqUbF4mUSaplMdGflx1MDAxOFx1MDAxNjKDpMBcYlxyt/BcbsGkzihjgjfo7zR+d09cdTAwMTlFPWpcdNFcdTAwMWH+XHUwMDAzxEzQZWZ/Msx7s/MmkMVcbrOtXFy0ScdcdTAwMTbiXHUwMDAyWFxy09O2rp2ON1x1MDAxZDSKx7Xb3fPC7eb1+8nTQVx1MDAwMbRt/0/kTYVYKOBPXHUwMDE0XHUwMDA082BPqZlLgXhUXHUwMDFiI5VcdTAwMDFcdTAwMWJcdOs6XHUwMDAzLcd+qFx1MDAwYndQl1RcdTAwMDQq2XM9RqAox+JYXHUwMDA1VrvEXHUwMDAxV9yVSydcYv+MXGL/TiblPrepmJT2XGYjmJjE4G6rXHUwMDEwk5JSg6xXaKZcbqNcdTAwMWNMSlx1MDAxMmBaXG6MXCI8/pa5QuJLXCI1QcL201x1MDAxMykwg5RkTt9TPI+SnCGMXHUwMDE2kEZ9zoxaIFx1MDAxYTWBujhKXCJd68+HRq1cdTAwMWW9r1Xl6fXZ+lx1MDAxZaB0+L5uXHUwMDBmSjx9SEsrXHUwMDBme1x1MDAwZTFtpLXhkJbUXHUwMDFhzGpcdTAwMDXS38ZcdTAwMTREYpFcdTAwMDSjwk8wjWJcdTAwMWH9zVxm/c2RYvGlb3llXHUwMDFj3YP06MboM87Xsc7IXHUwMDE2tVx0VEn7M1x1MDAxONhcdTAwMWOp0snFdvFjtzhcdTAwMTSvT1x1MDAxZi12frv9RIZHvztcdTAwMTPlVzX72+ypXHUwMDEz8np8IXeKO7un1cstcqZzmqStOPIwldMkbfdTSUFcdTAwMDRcdTAwMTQl/iRsqimRkptQXHUwMDExpKLAXHUwMDEzOFx1MDAwN8gzlPqOXCJI6Vx1MDAxMVx1MDAwM3xSYj2u26OyXGZAxVxuiddcZsFvwlxmXHUwMDA2v51FUuhcdTAwMTCNXHUwMDEzXHUwMDEy2LLDWJ17XHUwMDFibsXggc9cdTAwMTaAwtdcdTAwMTcpXHUwMDAwNUH1Rlx1MDAwMlDu9edcdTAwMTSASlx1MDAxNJXJXHUwMDAxKONcdIaDlf2uXGLh4dpcdTAwMWNcdTAwMTBNXHUwMDAw78AptbSuxHbuXHUwMDAxcfiu8lxutt5cdTAwMWZxe89QTiynmFx1MDAxOcODV1lSfVx1MDAxN87f3DjPNGJbg6gmVLuzX0j8JCBswm9cdTAwMTmdI0Xo3Z+0brc3NrXobl9stY9fXHUwMDFl3+GWpVaNi+NNiYdcdTAwMDL+XHUwMDE0XCIoXHUwMDE4XS+yxdy8KVx1MDAxOdxcdTAwMThEWCZcdTAwMThY8JJwZlx1MDAwNdGBd307U5iSX4Vi8CN15Pilcq0ky82VlfE6TGUlcFZcdTAwMWPaYpjmNFx1MDAxYSFcdTAwMTPYj0nqr4R6XHUwMDAy5Fwiioq5uVjchzlcdTAwMDWzXHUwMDEy2ENSXHUwMDAyq5doisnArK6v1GHpXHTCXHUwMDE0XHUwMDBlWmMqmFlcdTAwMWNcdTAwMThwgm1cdTAwMGaY1Vx1MDAxYZ6eXHIo/mXbqa+VTVx1MDAxNLzDTFx1MDAwNFx1MDAwYngwc5ZcdTAwMTmw+OxhwpDFL+Cctc9Yz4pPUlx1MDAxNoFcXE0gNO5QVXj5+XCrZHMxiVtpXHUwMDAx9o4yijKGJbxhbqW0xzF2KaWWNJCROlx1MDAxYZxoPb+lXHUwMDE4yDauXHUwMDE5NY5IlcB+dGBTwVx1MDAxYpTgwcT1JcRdXHUwMDEwf09cdTAwMGZxUNF4Z6O2XHUwMDEyLkUkRKR9N4s0cywk0ofXj297pXelzsRdYa9/yZh4zN5jaVx1MDAwMZpYxFx1MDAxZflcdTAwMWM+XoiAZVx1MDAxZVx1MDAxNCw13SGeNvBcZog0XHUwMDEyo5rGkVxylKrTKfVcYlxcRGvCkFx1MDAxOFx1MDAxOWHM2D30jFx1MDAxNZRiXHUwMDFjRlx1MDAxYTDrVLSh7a9q5lrARrJcdTAwMWNLb4BcdTAwMDZcdTAwMWJgmERGdzg261x1MDAwMZ5lqi3jrVNcdTAwMTKjgcBcdTAwMTdxVN5Y01x0uCGSjtrIarFcdTAwMDCdXX9Z01x0tyhIwUCNwlxcMIpcdTAwMDRcdTAwMDXUXHUwMDExIaFEVEWFXHUwMDA3v5aCXHUwMDEzt7bCwtiFm/L7h2mnj/TaiVxuPMmYM+VioLHlLZoojvXxOVx1MDAxM9DZXHUwMDFin1Z8Wbs4XHUwMDA0dFx1MDAwMutcdTAwMGJcdTAwMTNQ9/LzIaDJlbNJXHUwMDA0lDNcdTAwMTC5ilx1MDAxOa2pXHUwMDA1uUjDOZDKSJx9amlcXDW7JFx1MDAxZahcdTAwMTDKXHUwMDE5ldjMh4/M0lx1MDAxMahcdTAwMDV+XHUwMDA39f1cdTAwMWGMXHUwMDFiZuY+lO/PXHUwMDAyuV3LkFx1MDAxMqko5Sqml4WJn6bJXHUwMDE4zoqdazL5Pjk9lefv21x1MDAxZqWnzcOL5tvwovdQyO7G+/3jXHTG3i2Fp7myRP+EsSd9vFx1MDAxMFx1MDAwYplfcb0o+CZej1x1MDAxOc9cdTAwMWEmceKmYHg9lvaCv44jp3ZT+l38hZLUUKqwY4NcZpjVKyOXoMLeZnC7hCVUqGD3tlx1MDAwNFx1MDAwZSlcdFx1MDAwNymIQ1xcgMPwMe8tUkgrXHRVXHUwMDFh3lwipNKRu5KRNL9sssPK7i19eSrbfdtrKn17vurcMShcdTAwMDeGjYUs/Fx1MDAwZj2A2jH9Oc3+/N5swO+IMNQy0FxiXHUwMDA0zt+4ZYCjpTG9XHUwMDBiwKixU9Hvp8k5XGZAXHUwMDE4w3NcIlx1MDAwMtNcZkBIhuOky4/E4d/JXHUwMDFi4yk2NttSZt5pgqSY56hcdTAwMDe33klh7zCKjXpwXHUwMDE4/Fd5yEj1+NxcYiDnoYBkQKLAao1QI/Q1UFx1MDAxOahcdTAwMGZZ2juZqdB6eirEuDWaWWd+OI81d3BkPDZcdTAwMDPKe9DD7Fx1MDAwZfdmtdlpt1x1MDAxYivVV//rXHUwMDE2wOKZYGaELZ64XHLkY/M8KLZXb2zfXHUwMDE0xH67VHrvPlx1MDAxNldbNpXNU1x1MDAxMNpi4jpgWlxuiikwoSwlo5RcdTAwMDfmKsNcXG2weUa4/enszC2wXGYrqGLaXHUwMDFheNYuq8dcdTAwMDOSYKxcdTAwMTDcwonQNJD1vIS6XHUwMDBi6lx1MDAxYrMnNVhO0aPpLFx1MDAxMFx1MDAwM1JcdTAwMTMrXHUwMDAzXGJRVFk1XeNnt56eZFxyPTytkYuPzunu02nr7eVW3eyy4nGGfD9cdTAwMDNbXHUwMDE1PJBcdTAwMWb3u6yheCz4r0ZQXHUwMDEwoYy/wFpcdTAwMTCtw/Nm92b/XveGdv36pb+zXHUwMDFl8JytXHUwMDA0PeqYq0gwvEY4pjZETVx1MDAwNe5cdTAwMDHV/8zZSCby009enymhwH2QUtCbXHUwMDAyXHUwMDE4XHUwMDBiXHUwMDFlZ9pcYssk+lxuwrmaXG7oIahHXHUwMDAy3IW7p91cYlx1MDAwZjuRWfpVIbTkN5mF3mZ6fmONXHUwMDAxmFx07WpIXHUwMDE2n1BArSVA0YPjQPPJ12RYsDRVTtU3wVx1MDAxOfSq3ZXqsFpcdTAwMTnAhVf6w0WgOFx1MDAxM1hFmOLEbyFcdTAwMWaSY9vPp2+n7HA4uDvaur3cOKm/bFbTkVx1MDAxY1BcdTAwMTHYZlx1MDAxNHVcdTAwMWLhQHNCRbCWKo9p4idcdTAwMDRcdTAwMDFfXHUwMDFknZ8gx7HCWm2MXHUwMDAxI8ZKh/lcdTAwMDLiXHUwMDEzpCeYR9QwkO6SL/uUJsN9a2aOg0FKJaXgLjHAZXxtXHUwMDA3qDfLcVbm/DjOXHUwMDBiOd5cdTAwMTNFQldPau3u7qGp1Ml750/kOIV4MPifj8AgT5JcdTAwMTNmXHUwMDBludJcdTAwMWatmcRG8oJcbi1cdTAwMDNJ/SuB1lx1MDAxZUxKzS2hSuC5U9GTOTeu4z5QabiOsdL7KWIjXFyGsic1IVx1MDAxM7hcdTAwMGXF1F2QmvxrYMmS62RcdTAwMTZ+21x1MDAxOWLXUihOjXW3+ohv0Yx9alxmyTV5Mj+q81nmuSBEZ1x1MDAwMrNwXHUwMDEyXHUwMDFkx1x1MDAwNvKhOclcdTAwMDJrUo1qQXFMXG7iSnJcdTAwMTBTRIXyUj5cclSC4SzmxrZ0oFmrZSe0ZDjvpOUysbM6XHUwMDE5kZgq5M6f1LFzXHUwMDE4ONUgr9VcdTAwMWOHn5jahpLF8vr1zvmA2+7Nx/BtmHpSZ/2jdHfX29mqnFx1MDAwZWp3p8X+wWq7m3LyZeJ1k02V6a+bLFx1MDAxOVx1MDAxMq87idCBKGWcZspcIk2QXHUwMDFh7qeShlxySGM8RanCyUdcdTAwMDQrXHUwMDBmxyWGXCJcIlliKL8xmNVcZsRccohcdTAwMWPlmvXLl/IjWX7spqdcdTAwMDNcXIBcdTAwMGXGyLpLUND4VDacXHUwMDAxyPIuVGXwjdMlQn+zgYteTH1qwIU2XHUwMDBmXHUwMDBlMEHthjnA+LJzmsWyWlx1MDAxNne3zZ1er0yvLt4uaFE/rKbW/IZgw3XK1Ocsllx1MDAxMIyNVVx1MDAxZWb70ljFr1x1MDAxY+Xlcknjk3G7l1x1MDAxZbdovoM0dfdY5/GTljSO8J7nKO6z5/JcdTAwMDPhO4X+xmrj/WntomaGXHUwMDFivbRcbrPcXHUwMDFm3Dduerec765cdTAwMWWsXXZON+/aV/koTMO0XHUwMDE1wZD2TFxu073LXHUwMDE0XG7TMMBcdTAwMTlFy9nCmqxcdTAwMGVZz5bQXHRAY8qDo2CA7IEgx0rMKO6W/Z0m4G4/g77Ep6CCXHUwMDEzXG6CsIuNXHUwMDE1KIFFJXK6sYJcdGdYXHUwMDFhxVx1MDAwM32Np9CY8NxA0620XHUwMDA3/ZV667VcdTAwMDT3/p9Wq91fkFx1MDAxOSbJOiysRqN7WVx0bSVcdTAwMWbVWjpcdTAwMWbcmqP7J73KhX69Kcjn26u79KqVXHUwMDEyzy+RssIxy1x1MDAwNISSX1BjMS3KOctkqVqngPhBlupcdTAwMGUlUFx1MDAxY7vKi4WMzftcdTAwMTZYMGW4nqPxvHU8OCtcbvWx+sL22D15XudXO/VMOjCz/EhAhXs1aXQgx9HEoPtgOYLIQH3TJ1wiMJkyXHUwMDExXHUwMDExTHpcdTAwMDazXHUwMDAwudJKS22WOjA7QFx1MDAwZdNcdTAwMDNEUCz0I85weWBcXHd0XGK8YYIwm2+bw1xclOBXnHmlP/ynXHUwMDA1Kqg3aNZbtbDu+H1qcIK+XHSrwdFuVmI3k49cInzcXb99eC2dlfUr2yfnsvl42krvXTaU4aBzq6lcIpFcdTAwMGWIYNtcdTAwMTCgvpRbq+JsTIGDgeXPNE9Ha9OlXpxcdTAwMDD7o/SwZ1JcdTAwMTIzltBcdTAwMTCAvbbh346qXHUwMDFlmWLETpdcdTAwMDY8nV48aF1ebFfPXHUwMDA2V1x1MDAwN+U1tcPq5nG3maGtXHUwMDExiFx1MDAxNCVh2SaIien1ons1afSi5lx1MDAxZVx1MDAwN8NPgrCVQlx1MDAxMFx1MDAxM1x1MDAwMlxilclcdTAwMDBcdTAwMTHUw8ZhmojvXCKEKECWodVcdFx1MDAwMDnOQFx1MDAxYzFJXHUwMDFlQOIsXHUwMDBiVibeJ0ONXHUwMDExU1x1MDAwMiTPM1x1MDAxY1GLflRyXHUwMDExXHUwMDE04Fx1MDAwND3j7PqbeyS1s/PRIZfH/cvd7YvHzqmtdlonmYw+zGQh8Fx1MDAxZoeuk8RTiihcbvbD0p+aXHUwMDFidk8yYFcyIZVcZiZzXHUwMDA2rL6ozvtx7FhJuFx1MDAwMVx1MDAwMjM/7dbcYaXLgVwi3UtSPy2Wr4q28faS1qN617dlza8+nj42XHUwMDFmXHUwMDFme7cvtmj1Qk6Cdu8yjdZUXHUwMDE2XHUwMDFiP2lBLVx1MDAwZlx1MDAxNlx1MDAxZn1cdTAwMDJNyWSgYSs4wzlcdTAwMTdcXGIzXHUwMDE4u1x1MDAxMFOg/zDYnWaAnWWUoP5zOVuCbZzCRfZEalxuZy33Zlx1MDAxYTl0c1x1MDAxYpSb9f5cImjNXHRcdTAwMWEr0scttPB81GZysfUktcms8qQhXHUwMDE4XHUwMDFlwTBkZESjXHUwMDA1I1x1MDAxMSeqXG5DYiY/L1x1MDAxNedcdTAwMTRcYr7I4i1lQnClnFxittFcdTAwMWWNPzMvsLDX8HkmTW/SfpuUdu8qb+/tq4PiycFDU+7MIVx1MDAxNJl43eTKz8Trzlchu+9eXG6FXGbY9dBcbiWUUeBXQTP0q15CTsAwpogrpdBcdTAwMTPsW7JLpZxcdTAwMWTSl+khja1+XHUwMDE15c5cdTAwMDCIVbG9XHUwMDE3rSVKUEZyde/mopJLlVxufF9/ha78v8Vx6k5QjGHtnLCHfFx1MDAxNPXZ9muhODh4eVZnXHUwMDFiXHUwMDA3Q1HunFx1MDAxNJo0k6KGf6mk2NbBoajBwoV/lYRcdTAwMTeXYc3cUH2VXHUwMDFl1UxJXHUwMDEwnjGotrHOKVx1MDAxMNmg3eU83bdb189cdTAwMDel9WGp/L6nL2yz09zv8bNFSFx1MDAxOeIgjqTNK1xc6txlKn2qMWzCiFGaXGJtTVifgo2bXGY1ITwsWzUgXuNybJf6dFx1MDAwMvKus/iWJOGWulx1MDAwYlx1MDAwYikxsVx1MDAxMVOhtVx1MDAwNtKUt2c4+zGO1ahskTTqXHUwMDA0XHJcdTAwMTanUVx1MDAxZHvIR6Ou9Xb6rXq7rkivsflinkmr1nUgPFajXCLMOeCYY2ldWKMqQpjfQ0nGT4hbatTsuL5Jj2tlLHyjcFx1MDAwZoMjNDZcIkqJVJzMNVNo93qobzd7pz1e/7hUw429yvYh/22qz72aNKpPc09KTVxm9jjWNqi5vkKielx1MDAwMia4XHUwMDA3XHUwMDE0XHUwMDE1PshcZmGaXHUwMDBiZ1PVJUSSIXKbwZTUfmayc1RcdTAwMDelTMdBXHUwMDA0aFx0k2pcdTAwMTE1n+d5i6DrJuiWsK5cdTAwMWJbdT7arVFcdTAwMWXI1uC4Vlh7oCcv18dmq3Kosmk3opVcdTAwMTaaO1x1MDAxY7uKSO7B81eaxzt2PY5eXG5DXfx1qecmgLiUXHUwMDAxxIQzXHUwMDEyk++H0ex4+ipwXmpgXHUwMDE25S/Xc1x1MDAxZmc3/dezvVe7dta7uTgpq+7N5f1v03Pu1aQy8YynNONWXHUwMDE4g5HMQPORrzCmmYBcdTAwMGXBPcYpZsVSjVxyQpdqLjNCyulcdTAwMTFCgdJcdTAwMTmKSstcdTAwMDVcdTAwMTFcdTAwMTbfI5NcdTAwMGIpKDDIfFtI5WnhXHUwMDFkLpKFN0HnxFl4jj3ko1x1MDAwMzfs0cv63klzs7Tf6Xb37vpcdTAwMDfre6lcdTAwMDZ+SEk8XCJcdTAwMTkgXFxKbHRcdTAwMWJqIcVcdTAwMTn1/J5CXHUwMDE2XHUwMDEwXHUwMDBlUjQ6clx1MDAwZVx1MDAwNLJcdTAwMDdcdTAwMTT3p0FcdTAwMWN1zJybf5104jhfXHUwMDE2+v3vxHYlXHUwMDBitlx1MDAwNSgxRrizYUpS+1slpZ+7mSe2/XiIXHUwMDEygVx1MDAxMNhcdTAwMTTYXvXH4Xa67ftBZU710v12J1x1MDAwZdVjK1x1MDAwZkM4bqn54Ld3X9l4e1x1MDAxZr5+sIvtI37XfHt/rT+nwS/D+XFcdTAwMDJcdTAwMDde+qI2XFzExbnyXGbjWklcdTAwMTDwNpD5+aOfifaAOVkhQZVjXHUwMDBiTIeCXsI3XHUwMDE2vvdcdTAwMTngK1x1MDAxOZb5ups7XHUwMDA2Z/ZFOlx1MDAxY/iet+nyXHUwMDEz8lxmyUfQ+9X8eaFhXHUwMDFiWWNO9Sbn99X+2c3Ny8bOVks/vfWbj1x1MDAwNzpccl6FtZ7ERFx1MDAxNUNcdTAwMDTBZIRcdTAwMTBgteFcdTAwMWVcdTAwMTFcdTAwMTI9ekC3XHUwMDAz87d+9K1iaK9cdTAwMWFcdTAwMWMhapR2Tdha4jVcdTAwMTav1VxmeMXOXCKU8Gi6PO7JxqpbpUBRg0DOu7hMKNDgU03G+cbrYbX/1u4+r5xfRyfQLyB0k5abXHUwMDBmioetnfvto423XHUwMDEzXnm7erXbd+9n8jy154hSQz2plWCfrqNcdTAwMTCSXHUwMDA1155cdTAwMDWyZkA146TFqOrVzIvpM1xiQkJcdTAwMGIw4rj4XHUwMDFjIz66dC6A/o9cdTAwMDf/Z1x1MDAxYTAvkl38mFx1MDAxZcxcdTAwMDBkwi3c7Jj2Qlx0WVx1MDAwN0IpXHUwMDFjZThccpq/XsjqOtI35WG1UD06kf3revG19rCvu2mzXHUwMDBlNre39p529lx1MDAwN+fnq8OLo5vjp0Jhd2/8W6bKXHUwMDBlPDqoPZ9cdTAwMWO2O53Ntfvt95NK7fW6X0933a8/xbdbwrpJI/NydTnvXlxuzUxcdTAwMTlcdTAwMTVcdTAwMWUx1irs9MqYXG7BWWtPY1x1MDAxNVx1MDAxYmNcdTAwMTJcdTAwMDd4O5m0VMpPUbFcdTAwMDJUgCPoOX9X11x1MDAxZlx1MDAwM+Z6XHUwMDA2zYzRTtDAMb3CopUzP2BcdTAwMTbWXHUwMDAwlrXMOVnfwOlVs1x1MDAxNX6X0Vx1MDAxOfnZfbO7XHUwMDEwXHUwMDFlrlx0ujGsrGPWn4+eTlx1MDAxNmrJw9e1h2PXQZVSy4hcZoNaXHUwMDE59H5RTZGPO3S0YMZcdTAwMDOR4MNcdTAwMTmLu12ZXGbYXHUwMDFhmvtcdTAwMWTKMMmJXHUwMDA0e14t/dkuqD+5oZ6lQzrcb2Rezlx1MDAxNEJcdTAwMWXbXHUwMDE5xVx1MDAwMlx1MDAxYuNApOdcdTAwMThcdTAwMDfaPWxcdTAwMGXPqttXRTE8Lt9sV47qp7dP2ZQj/D+Zyk7PtT96PFx1MDAxMvyPRzAwul5ki7nNgNm4O3vY+KhrXlCH75JcdTAwMTWvqD5cYpYsjFxyXHUwMDFkp0ZRgLi1XHUwMDEyXGZnXHUwMDFkmFxy/jMv0khiYO1WYcd0XHUwMDFlPXypXHUwMDFhsyfLzcCaiMeBTkhQSZpcIjtVVEXWJD0hgLpcdTAwMWFcdTAwMGXLwZHlJrKm+TVmd5/kXHUwMDE0xMpcdTAwMTLh4aBOhekuWpHQiD0hjSfAXHUwMDE2XHUwMDEyWCupXcSKSo/iXGZcdTAwMWGgYJ9pootArP4wmfucnl5JrjRYrM5cdTAwMDLkeNlcblx1MDAxZlCCS0Hz9XsoTjC8PFx1MDAxM7fqwSoqOLylPP60flx1MDAxZrmaQGhcIlx1MDAwNZExXHUwMDFiyIddJZt2SexcblST8pjRjFq/bsqGxkuB3vJAgXGOXHUwMDAzarSJOjNBXHUwMDFl/4ze8lvnRJFNPSGlhmvj/CpBXHUwMDAyKn9cdHRcdTAwMTfQXHUwMDFiM5Mrylxmtlx1MDAwMHU0kfSXXHUwMDE431uSXHUwMDFhbiiYx3SOJVx1MDAxYXf7XHUwMDFksdqR7faT2a7cX5dcdTAwMGaOb2+LmflVpu6rv4ZfXHUwMDE1YrGAP1x1MDAxMVx1MDAxNMyDXqWmMlx1MDAwNVx1MDAxY5JrXHUwMDA19lx1MDAxNFx1MDAxMUJYJKxRfiU9PFdcdTAwMDSTXuFw8Z/B0lx1MDAxOflVas5cdTAwMDf8SmDuraCYNMapiNIr7llQc9hcco5cIkGBw/BcdTAwMWL5lfskp+FX2NFFW6mtUMyokIkrXHTcXGKwl7Sxylx1MDAwNtvwjPxWQN41Wsdawy1wRpSW9GqC1G1mcEVjoo00zlx1MDAxOcbxUWAlXGbT0tKcR/xxwpRgM7Grr4kxXHUwMDBiw60m0Fx1MDAxOWeLpsjy82FWu7RQPL9vbFx1MDAxZeyU7sXJeW/4SEw7S3yJYO4kI58zV0PxJVBcdTAwMDcodS3HXHUwMDA2hU6H9DK+9PnbaUHdTlx1MDAwZmpq0XlcdTAwMDBmrDO5g0XB/o1rIzEzh003unM6ynR02/l42i3IQuNwWGW95+bH3odKXHUwMDFiXHUwMDA3MqdcdTAwMTXePn4rs93+XHUwMDAzU7W3u4vt/Z3xb5kqvrTZUyfk9fhC7lx1MDAxNHd2T6uXW+RMr6a7blxuipdjfMl991KoaThcdTAwMDV+Q22BKexcdTAwMDJLh8bxrKj0OFx1MDAwMf6kQVx1MDAwNVx1MDAxM4cv2nJP+LM8NXbstmwh3CB/XGaYO+nBbLRcdTAwMDJcdTAwMDOIOFx1MDAwN9NRZmM7yVhBgNra6UaMJ0aXXHUwMDA0XHUwMDFjjll0dPk7efE1Judjzjp6gmKMXHUwMDA0l5zLz0dHJ1x1MDAwYrTk2Fx1MDAxMpg9nGmmOVx1MDAxOJDChom3VVx1MDAxZXZvN5ZcdTAwMGLCRbQ0QnD53TbYoaKJR6wwXHUwMDA056pcdTAwMWKFXHItlsPqJiD8xY3wLJ5cdTAwMGaD9ivRzr6p8IhjnZ9cdTAwMTJccidGpmPn02nxRvtU3DQvjs+23ktv6mnz8XTQXHUwMDFi/omOXHUwMDBmXHUwMDE3XGb8XHUwMDBmRlx1MDAwMTC6VGR3c1x1MDAxOLmbLLRWgp5cdTAwMDdcdTAwMTTaQuK0XYrFozzwpu9gk5LcYo9cdTAwMWFCudNcdTAwMTkyP8eD+ySlYDSWcHhy2EuWc39wUEhcdTAwMDBcdTAwMWFcdTAwMTCAUimLXkGtXZ5cdTAwMDcgRGC5XHUwMDEw6VdAL7tCTyH0ulx1MDAxOWxcdTAwMTRcdTAwMDI2n5FUOz1cdTAwMGbxgVx1MDAxZMaYwqFQuVx1MDAwN3bUtPInXHUwMDFh2ME3Llx1MDAwMrGZwCbiXHUwMDAzO+NcdTAwMWLIKW0m0aZKXHUwMDBl7CjrXHRCtFx1MDAwNuZieDhkqzj3cNRcdTAwMDX6XHUwMDFktFx1MDAxMa64jvFwnrI0XHUwMDE0xJuydHS6XHUwMDAyXHUwMDA0R2BcdTAwMDFcdTAwMTEzXHUwMDAwfVx1MDAwNWaRXU7TnID13uxcdTAwMDSHgCFcZprJ3Skk2OUgLFx1MDAwNLCXmiHBNpq/PnXm9npDrO6VnteKa5tcdTAwMDdd+UhcdTAwMWVPXHUwMDBm/kSGU4iHg/+yXHUwMDAzXHR5Mp2Z+VxmLJBij1TJXHSIXHUwMDAyyShcdMSmvlxiXHIlXHUwMDFlyFx0XHUwMDAxnFx1MDAwNvZcdTAwMDGszZGqkopkrVx1MDAxZb2vVeXp9dn6nlB6+L5uXHUwMDBmStxNsiiFxehPiiVcdTAwMDOFiKM1/UZS5T68qUiV8KglOGdcbvQuXHL3VFOMe36GsZExXt9lOGd2SdvPwKo48HxcdTAwMTZjM1x1MDAwNpyOkVi5JiBcdTAwMDfIdIVcdTAwMDVJrFxuLixmYlWLXHUwMDE20JlAY+ZcdTAwMTnQab9cdTAwMWWUr3dVcevuuFk7a1fW75ut3Siq41x1MDAwMjqMKE/h2Fs4MCDpw1x1MDAwM1x1MDAxNznFXHUwMDEwOdiLXHUwMDE0az6jyP5t8Zz/Q27gQVx1MDAwNmRjS8vxjLZcdTAwMDBZUjK+4Fx1MDAxZdVcdTAwMWZcdTAwMDd1mHMzXHKmXHUwMDE5KLssJYBcdEe5efI8eN46v14/ON3ePn6929pcdTAwMWM8pu9cdEhBwXjAWVxmnGNcdTAwMTGNTeKkRG4tZtJyI1x1MDAxN+ko/1x1MDAxZlx0Tb5mMftcdTAwMTWRUlpnX3zgTrGtzyizklx1MDAxOPjgXHUwMDFjvZpX6mP1st6o1Nmbbm731OF6/z71kG72UWhU1NUjf9XsoXp3SU+u1m/Hv2Wq2OR24/TkpHN8crz6cjpcdTAwMTT9ZrlweHuf7rpcdTAwMTH2/ksx7b57KUgnaCbpSVxycDOCYsJUyOC3VnhMXHUwMDBiXHUwMDEwiELqQKeRUZcn6WnDuSDYRohcdTAwMDTbRC1jk5PR/JZcdTAwMWXNflx1MDAxN0N4XHUwMDEyzlxihZKxpW8gqjHxjuTax9B3c2NcdTAwMWLLWehmXHUwMDFk2SHwN5xcdTAwMTK6QPVvXHUwMDEz9GOYdSbuXCJcdTAwMWbymdxQPMmdJ/RnXHUwMDA1hmCWcNDW4/NcdTAwMWKlZdTTliuwp0HzXHUwMDA2Tc5vfHOgpqCNucbotjHUXHUwMDAxb4Nmqd9kk1x1MDAxMMqXWdrJiH+f3ZWnsFx1MDAxYr5cci4m6MrT8f58eEhcdTAwMDbs1TnOu3nev3lcdTAwMWWer69f1zpPdVBLW1x1MDAxN7dbtczzY/RUzS9y9eTF4lx1MDAwMH9cbiFcYowuXHUwMDE22V9uPrzk2Vx1MDAxZCvjPjzfMVx1MDAwN1Ymx1xuuEAvkZVcdTAwMWaHXHUwMDE59aTvNrXUgFx1MDAxOFx1MDAwMFx1MDAxNlx1MDAxZTl9qZx4tdWyuLtt7vR6ZXp18XZBi/rBuSriYatCarTvu6CBovuVQI42XHUwMDEzWLMpXHUwMDE5zoyQXHUwMDBlQMzNqec+xyn4lVA4zVx1MDAwZr3v1lx1MDAwMLtcbjSPQYFcIqRUXHUwMDFlXHUwMDE38Fwi+vS4y6nHjCd48jTA5WD5XHQy9yM9y6JcdTAwMDa4rsGqJYdwVbF9Zlxyt0Jxa3ImWTNIv/FI6UqlXHUwMDA00MWL/9P6akm5XGJUa1x1MDAwMrFxXHUwMDA3TVx1MDAxM/eSXHUwMDBm4Uq2J5NcYpfVylx1MDAwM7BcdTAwMGKce2yjdXFcdTAwMTbEXHUwMDAxXHUwMDE2tFJiXHUwMDE54N1BuNBTmJBcdTAwMTZBPcNB18A/wlx1MDAwMumXbPRcdTAwMDVL7DuwXyQz8y1cdTAwMGVcdTAwMTjEXHUwMDA28i62peNnkVGjQIyAVTxHJ8rBzdt1o7axcXve2ehdrN/sbdTeWDanhNbB+Wq/i25RMEwsgEBcdTAwMTlJwNTkcoxvXHUwMDAxeim8aoVmglNMXHUwMDE1m3Q9J6o+L1x1MDAxNcZTnuQte6pZsvE5RqCUIFx1MDAxNmd4oNPFKlx1MDAxYU01o8QjiktrQCgpzqXUv5FBuY9mXG5cdTAwMDZFXHRnSL0plVx1MDAxODqjJFwiUuGocOzDXHUwMDA2P0ZFXHUwMDFinVrpMSsxXHUwMDFkV+JhcrUpXoZFJ0hRmp5BaVwipFHKTaDiXHUwMDFiNMFcdTAwMDNcdTAwMDKSr/KdpoxcdTAwMDJNjLWLmoJBVYfVylx1MDAwMFO1+sNF4ExcdTAwMTO4SZgzOVefXHUwMDBmS0r2jidnmVx1MDAxOeExTKBX1Fx1MDAxMlx1MDAxM8Tk53BcdTAwMDGm4KtcdTAwMTXwaVx0XHUwMDE2XCKlLppkPMqxr1xikHVcdTAwMTOXZ2YtxbRcdTAwMTRmQY8oXHUwMDEzaHG+RLlcdTAwMGLlbGauRDFrXHUwMDEw77TbS01ifVNY58jh9TlmmdHd58KLeC5cdTAwMTbKhWr7qNKs18v1LFlmIFtAzFx1MDAwNYo/fluWmbZcdTAwMDAmXHUwMDAy2pFbdCYwOvZxXHUwMDBm+Fx1MDAxMzBYQzSxQHBcdTAwMTibeL14cPkvXHUwMDEzj1x1MDAxMsPAyGFcZuCJTVro6JKzk6aZqVx1MDAxMabVXHRcdTAwMTD6XHUwMDE05FxuXHUwMDBlKNDEXHUwMDA0ON9cdTAwMTc50khcdTAwMWGAXHUwMDExXG5JOKHafDvtYlx1MDAxY17RXHUwMDA1z4U1uc9oKtYkgDVRjk9cdTAwMTFcZlx1MDAxOCnDXHUwMDEyloKEXHUwMDA1XHUwMDFiXHUwMDE1IKeVoNFEXi08IExcdTAwMTbuzuf0lpHMWbKmr5VNlKc8PWui2MJcdTAwMDH9XHUwMDA2rli9im9Si9mZIFdzXHUwMDFlUsa0XHUwMDE0era2ll/JWIvBmSYwlZhEsvxcdTAwMTnTXd+WNb/6ePrYfHzs3b7YotXlVIzJWO6hXHUwMDFimaDrKNxxWlFcIj1g3IqCpOeuoYPaMLB/SdyoXW1cYvr/rdYoXHUwMDEwzDKIN1x1MDAwMdhcIktcdTAwMTJcdTAwMGVcYlgrtHD2XHUwMDA3MPE1xThVx1xiMV03+elcdTAwMTjR2/mFvji1+9fH18PT5vVqsUjPK9midYxcdTAwMWHGg9j4LYxo7N3YRVBbJVx1MDAwMFx1MDAwM5qCiOVcdTAwMTO9RVx1MDAwNSdcXPK+VkEp4WlBhLXSXHUwMDAwZbaTiZlcdTAwMTLSw1x1MDAxMKON1EwmXezXUTLR2fnokMvj/uXu9sVj59RWO61cdTAwMTO3t1xuVs1cYqaiMDDosL5z5Fx1MDAwYvjhZEGW9lBcdTAwMWaO1jb2bD3YI5A6abFzplx1MDAxMFKFXHUwMDFjelEymjGI2TTHx1x1MDAxNzvHpaOnyv2mfvnoXGZkeTOOaFx1MDAwMs9cdTAwMDTarbmUsDNqXHUwMDFknTzTbFxurlx1MDAwNJZcdTAwMTPGjonExp9ajTUqxV1rojSIaKPQQ1x1MDAwYiw/YZf58dMxTeev/qxamyBlvuUkXHUwMDFikzD+mkK7XHUwMDBlXHUwMDAxNVx1MDAxMV5joPjcReRq8VibdOmRjPs7eVM8xaamX8ZMO0xcdTAwMTBcdTAwMDFjO4yIXHUwMDAzf1x1MDAxNzu9s061Ui81XCKSXHUwMDE51lx1MDAxMXkxgeO4lUhcbpNcdTAwMDUsXHUwMDBliZOoXHUwMDE4/CtBM46Hylx1MDAxNaPYXG5cdTAwMGZsWIWnP5qJXGJcdTAwMWbH7nJcdTAwMWNtPuOeRrc0WCbwXHUwMDFhmcHNq+FcdTAwMDBcblx1MDAxZS1cdTAwMWPE+1x1MDAxY2+vWIYjXHUwMDEyzHSDxydcdTAwMDXKZyspXHUwMDFllEEhLojBMsFQiFx1MDAwNMaja8/HYPk4q2y3X3dZca9zLtbt25VYf0g1U0NcdTAwMTHrgUaUfuU52KehxEOqNYDZXHUwMDEwzVx1MDAxOXGlXHUwMDE1a5CSlFrsf66VdNosy1lXsTBW6WFcZs9GS2x77oAxj5+rXGZoXHUwMDAz5mNFvrPpsHJcdTAwMDauamdcbtec9dvdqlx1MDAxM8OLMt4qtMKc5sCuXW/fko1cdTAwMTfKhsPbu/tr0tpsfKRBKtiYnlx1MDAwNIBir1x1MDAwZVx1MDAwMKpcblx1MDAxNfRcdTAwMThhPU5cco66XHUwMDAy8lx1MDAxOUWq0Z5k2nJcdTAwMDNv0ZpcdTAwMGJHftpcdTAwMTKpsUjV6ZFKKTZbXHUwMDAx3udyJIBWjYMqqFuGg2BzXHUwMDBlrH6O/abBs5q5N9lcdTAwMWYwiu5cdTAwMTfNn7t837s7rnWvblx1MDAwN1x1MDAxZGWqQ3vFyEk/XHJauaBY5O3HyoxcdTAwMTI81HnHSO2BXGLVXFwzJ1pB7WKfaWVcYjxFdy7EXHUwMDEyrbFoNenRKsDIo4Q53fk6mks20qtcdTAwMWEnXFyR3PXq7NPYwUrsL7ZeXHKtMFx1MDAxZqTuPJVKZ63y+/rNxs7rzunRll5vpi/8LjCmPSzq9qOkmElcdTAwMThWr/C60cZq6rZql6XfOeDWZtKyTCrscORcdTAwMDAuXHL21FxiIVx1MDAxNz6F2YjTlcwmXHUwMDAwl1I4XCJZXGbbhLPcfNpYt3eX4vistHdkuH69Jzp95XeBoe6x2JqEcWCL0bMsiWeN5SzGqFvWfs94jovpz7G06Ei27qxlxWOzljU8PMmlmGPUqa4/upXV6nWxe18u1T+OzjdvOvUseTi5YsS9mlx1MDAxNMxcZkS99ODYK/RqOOFhXHT2TjNcdTAwMWNcdTAwMWWLs8uH8Pv3mMXohvjHgGI1g3C3QIsxiOLMTtMsvnJSgIqmiuSdZ4HOas5mclt2q812v7poJdTJiiZM3Fx1MDAxMvaQUz3P887t8dvjRbOjOru8sbp1qflDXHUwMDE01K5cdTAwMDJqwzxuKZXuMaJM4jeDXU5ccubERUFt0M+pOcHAXHUwMDA1g9PnKunBYVx1MDAwZlxue8ZqgdMtzTL7XCJcdTAwMTnxa1x1MDAxOaJcdTAwMTQ4XHUwMDFjRzHpXHUwMDA0vDGxw1x1MDAxOSg8bspMcDz4r9eDb5dPr1ulV1O/I8WSoFvPN0+N7NlcdTAwMTe/v3hnPPtcInK6J328XHUwMDEwi5lJ14vcofw6JqqDe3XRuzwqMrn//HJQPFxcPW+5XHUwMDEzXHUwMDFkXHUwMDE4VuZcdTAwMTOt/YaJctRcInUlY5ZcdTAwMDNH/oZ1PcKgO0eP3Vx1MDAwNI9IMFSIIFx1MDAwNshcdTAwMWPcXHUwMDBlXHUwMDFluVx0vyrnXHUwMDAxOIwm1HBOXHUwMDA1lVpoSyNcdTAwMWJknvCxg0Fuf3Zpmlxy01BcdTAwMDLE2H4xO42BgWzVZ2vapFx1MDAxNI85JT9ET1EwSFx1MDAxZf7O8GtJXHUwMDA01ClcdTAwMDZSXHUwMDEwUCG4R6iKU1VcdTAwMDJr/Kmlwko4lcJRU6GN5+Key/LyXHT6aD1cdTAwMGJcdTAwMDM1XHUwMDAwmpj6iID7J+LDXHUwMDA3i1tJlatX8FthzFReXvmWrv+04lx1MDAxZITzrpBKZnth9lx1MDAxOb+FzOTzX1/K569Sp3PmX+tb4v71Wq++rcZ7Jv71JVx1MDAwZVx1MDAxMFxiVb/o5t//+vf/XHUwMDAyk+RsRyJ9RPCsubmit proven txbasic requestverificationverify tx proofquery stateinflight stateproxied queryverify stateinflight transactionsinflight batchesbatch builderselectbatchprovenbatchblock builderselect blockcommit blockmempool eventsuser executed txuser proven txUserfilter out invalidnotesexecute txconsuming notesprovesubmitaccount 1 + notesaccount 2 + notes...account N + notesBlock producermempoolNetwork TX builderbatch proversselected batchproven batchblock proverselected blockproven batchinternal tx proversselect candidateaccountexecuted txproven txsubmit txStorebuilderstateremote tx proverscommittedstate \ No newline at end of file diff --git a/docs/external/src/img/operator_architecture.svg b/docs/external/src/img/operator_architecture.svg index 961c58faa3..3450bc7674 100644 --- a/docs/external/src/img/operator_architecture.svg +++ b/docs/external/src/img/operator_architecture.svg @@ -1,4 +1,5 @@ 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External servicesLoadbalancerRPCBlockProducerRPCrpc.testnet.miden.ioStorePublicInternalFaucetfaucet.testnet.miden.ioexplorer.testnet.miden.ioexplorerHorizontally scaledRPC providers...Example infrastructureTransactionproverBatchproverBlockprovertx-prover.testnet.miden.ioNetwork TxBuildermempool updatesnetwork txscommittedstate \ No newline at end of file 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External servicesLoadbalancerRPCBlockProducerRPCrpc.testnet.miden.ioStorePublicInternalFaucetfaucet.testnet.miden.ioexplorer.testnet.miden.ioexplorerHorizontally scaledRPC providers...Example infrastructureTransactionproverBatchproverBlockprovertx-prover.testnet.miden.ioNetwork TxBuildermempool updatesnetwork txscommitted stateValidatorproposed blocksigned blocknotetransporttransport.testnet.miden.ioblockproof \ No newline at end of file diff --git a/docs/external/src/img/workspace_tree.svg b/docs/external/src/img/workspace_tree.svg deleted file mode 100644 index 016e69a633..0000000000 --- a/docs/external/src/img/workspace_tree.svg +++ /dev/null @@ -1,4 +0,0 @@ - - -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FaucetNodeBlockProducerStoreRPCUtilsprotoComponentsWorkspace dependency treeNetworkTransactionBuilder \ No newline at end of file diff --git a/docs/external/src/operator/architecture.md b/docs/external/src/operator/architecture.md index aeb371ceab..de7b3690a3 100644 --- a/docs/external/src/operator/architecture.md +++ b/docs/external/src/operator/architecture.md @@ -3,18 +3,20 @@ title: "Architecture" sidebar_position: 2 --- -# Node architecture +# Network architecture -The node itself consists of four distributed components: store, block-producer, network transaction builder, and RPC. +The network itself consists of five distributed components: store, block-producer, network transaction builder, validator, and RPC. The components can be run on separate instances when optimised for performance, but can also be run as a single process -for convenience. The exception to this is the network transaction builder which can currently only be run as part of -the single process. At the moment both of Miden's public networks (testnet and devnet) are operating in single process +for convenience. At the moment both of Miden's public networks (testnet and devnet) are operating in single process mode. -The inter-component communication is done using a gRPC API which is assumed trusted. In other words this _must not_ be +Inter-component communication is done using a gRPC API which is assumed trusted. In other words this _must not_ be public. External communication is handled by the RPC component with a separate external-only gRPC API. +The image below shows a rough example of what a network architecture may look like. Only the more important data +flows are pictured to improve clarity. + [![node architecture](../img/operator_architecture.svg)](../img/operator_architecture.svg) ## RPC @@ -33,6 +35,10 @@ It can be trivially scaled horizontally e.g. with a load-balancer in front as sh The store is responsible for persisting the chain state. It is effectively a database which holds the current state of the chain, wrapped in a gRPC interface which allows querying this state and submitting new blocks. +It receives new blocks from the block-producer, which it then submits to the validator for signing before it is committed +on chain. It then submits the block to the prover whereafter the block is marked as proven. Blocks therefore undergo +two levels of finalization, `committed` and then `proven`. + It expects that this gRPC interface is _only_ accessible internally i.e. there is an implicit assumption of trust. ## Block-producer @@ -40,7 +46,9 @@ It expects that this gRPC interface is _only_ accessible internally i.e. there i The block-producer is responsible for aggregating received transactions into blocks and submitting them to the store. Transactions are placed in a mempool and are periodically sampled to form batches of transactions. These batches are -proved, and then periodically aggregated into a block. This block is then proved and committed to the store. +proved, and then periodically aggregated into a block. This constructed block is sent to the validator, which verifies the +contents of the block before signing the block's commitment and returning the signature to the block-producer. This signed +block is then submitted to the store where it is proven and committed. Proof generation in production is typically outsourced to a remote machine with appropriate resources. For convenience, it is also possible to perform proving in-process. This is useful when running a local node for test purposes. @@ -66,3 +74,19 @@ number of failures, preventing resource exhaustion. The threshold can be set wit The builder also exposes an internal gRPC server that the RPC component uses to proxy debugging endpoints such as `GetNetworkNoteStatus`. In bundled mode this is wired automatically; in distributed mode operators must set `--ntx-builder.url` (or `MIDEN_NODE_NTX_BUILDER_URL`) on the RPC component. + +## Validator + +The validator is responsible for verifying the integrity of the blockchain by signing new blocks before they can be committed. + +At the moment this is implemented by having all transactions sent here to be re-executed to double-check their integrity. This +also guards against bugs in the proving or execution systems, by backing up the transactions and their private inputs. This +forms part of our training wheels while Miden is maturing. + +The validator signs a new block if: + +- all transactions were previously verified +- block proof is valid +- block delta matches the aggregated transaction deltas +- block header is valid and matches the data +- block builds on the current chain tip diff --git a/docs/external/src/operator/installation.md b/docs/external/src/operator/installation.md index b8288edeb4..d7f87fb609 100644 --- a/docs/external/src/operator/installation.md +++ b/docs/external/src/operator/installation.md @@ -29,7 +29,7 @@ can be used so long as the checksum file and the package file are in the same fo ## Install using `cargo` -Install Rust version **1.89** or greater using the official Rust installation +Install Rust using the official Rust installation [instructions](https://www.rust-lang.org/tools/install). Depending on the platform, you may need to install additional libraries. For example, on Ubuntu 22.04 the following diff --git a/docs/external/src/operator/versioning.md b/docs/external/src/operator/versioning.md index d678d69b64..d3d6bad943 100644 --- a/docs/external/src/operator/versioning.md +++ b/docs/external/src/operator/versioning.md @@ -10,7 +10,6 @@ The following is considered the node's public API, and will therefore be conside - RPC gRPC specification (note that this _excludes_ internal inter-component gRPC schemas). - Node configuration options. -- Database schema changes which cannot be reverted. - Large protocol and behavioral changes. We intend to include our OpenTelemetry trace specification in this once it stabilizes. diff --git a/docs/internal/src/SUMMARY.md b/docs/internal/src/SUMMARY.md index a8bf4eb82e..6f78b0e127 100644 --- a/docs/internal/src/SUMMARY.md +++ b/docs/internal/src/SUMMARY.md @@ -11,4 +11,5 @@ - [Store](./store.md) - [Block producer](./block-producer.md) - [Network transaction builder](./ntx-builder.md) + - [Validator](./validator.md) - [Common issues other oddities](./oddities.md) diff --git a/docs/internal/src/assets/node_architecture.svg b/docs/internal/src/assets/node_architecture.svg index ba697edf6b..19f9de1310 100644 --- a/docs/internal/src/assets/node_architecture.svg +++ b/docs/internal/src/assets/node_architecture.svg @@ -1,4 +1,4 @@ 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 proven txbasic requestverificationverify tx proofquery stateinflight stateproxied queryverify stateinflight transactionsinflight batchesbatch builderselectbatchprovenbatchblock builderselect blockcommit blockmempool eventsuser executed txuser proven txUserfilter out invalidnotesexecute txconsuming notesprovesubmitaccount 1 + notesaccount 2 + notes...account N + notesBlock producermempoolNetwork TX builderbatch proversselected batchproven batchblock proverselected blockproven batchinternal tx proversselect candidateaccountexecuted txproven txsubmit txStorebuilderstateremote tx proverscommittedstate \ No newline at end of file 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RPCsubmit proven txbasic requestverificationverify tx proofquery stateStoreinflight stateproxied queryverify stateinflight transactionsinflight batchesbatch builderselectbatchprovenbatchblock builderselect blockmempool eventsuser executed txuser proven txUserBlock producermempoolNetwork TX builderbatch proversselected batchproven batchblock proverinternal tx proverssubmit txremote tx proverscommittedstateValidatorsign blockverify and signre-execute and verifyverify signatureand commitmark block asprovensigned blockcommitted blockproven blocksubmit proven batchverify txs andproofsnetwork account N actornotes available?execute txconsuming notesprovesubmitcoordinatorexecuted txproven txnotes & updates foraccount 1notes & updates foraccount 2notes & updates foraccount N \ No newline at end of file diff --git a/docs/internal/src/assets/operator_architecture.svg b/docs/internal/src/assets/operator_architecture.svg deleted file mode 100644 index 961c58faa3..0000000000 --- a/docs/internal/src/assets/operator_architecture.svg +++ /dev/null @@ -1,4 +0,0 @@ - - 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External servicesLoadbalancerRPCBlockProducerRPCrpc.testnet.miden.ioStorePublicInternalFaucetfaucet.testnet.miden.ioexplorer.testnet.miden.ioexplorerHorizontally scaledRPC providers...Example infrastructureTransactionproverBatchproverBlockprovertx-prover.testnet.miden.ioNetwork TxBuildermempool updatesnetwork txscommittedstate \ No newline at end of file diff --git a/docs/internal/src/assets/workspace_tree.svg b/docs/internal/src/assets/workspace_tree.svg deleted file mode 100644 index 016e69a633..0000000000 --- a/docs/internal/src/assets/workspace_tree.svg +++ /dev/null @@ -1,4 +0,0 @@ - - -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FaucetNodeBlockProducerStoreRPCUtilsprotoComponentsWorkspace dependency treeNetworkTransactionBuilder \ No newline at end of file diff --git a/docs/internal/src/block-producer.md b/docs/internal/src/block-producer.md index 26f82e9043..fc7e01b0ce 100644 --- a/docs/internal/src/block-producer.md +++ b/docs/internal/src/block-producer.md @@ -1,11 +1,9 @@ # Block Producer Component The block-producer is responsible for ordering transactions into batches, and batches into blocks, and creating the -proofs for these. Proving is usually outsourced to a remote prover but can be done locally if throughput isn't +proofs for batches. Proving is usually outsourced to a remote prover but can be done locally if throughput isn't essential, e.g. for test purposes on a local node. -It hosts a single gRPC endpoint to which the RPC component can forward new transactions. - The core of the block-producer revolves around the mempool which forms a DAG of all in-flight transactions and batches. It also ensures all invariants of the transactions are upheld e.g. account's current state matches the transaction's initial state, that all input notes are valid and unconsumed and that the transaction hasn't expired. @@ -17,8 +15,22 @@ the mempool where it can be included in a block. ## Block production -Proven batches are selected from the mempool periodically to form the next block. The block is then proven and committed -to the store. At this point all transactions and batches in the block are removed from the mempool as committed. +Proven batches are selected from the mempool periodically to form the next block. The block is then built and sent to the +validator for verification and signing. +This signed block is then submitted to the store where it gets proven and committed. Proof +generation in production is typically +outsourced to a remote machine with appropriate resources. For convenience, +it is also possible to perform proving in-process. This is useful when running a local node for test purposes. + +Once the block is committed, all transactions and batches in the block are marked in the mempool as committed. + +## Mempool data pruning + +The mempool keeps the `N` most recent blocks locally, to allow incoming transactions a grace period so we can verify their +state against the store, and the local state deltas in the mempool. Without this overlap, we would constantly be racing +transaction check against the store with newly committed blocks. + +After each now block, the `N+1`th oldest block and its batches and transactionsa are pruned from the mempool state. ## Transaction lifecycle @@ -42,5 +54,5 @@ above lifecycle (which effectively shows the happy path). This can occur if: - The transaction expires before being included in a block. - Any parent transaction is dropped (which will revert the state, invalidating child transactions). -- It causes proving or any part of block/batch creation to fail. This is a fail-safe against unforeseen bugs, removing +- It causes proving or any part of block/batch creation to fail repeatedly. This is a fail-safe against unforeseen bugs, removing problematic (but potentially valid) transactions from the mempool to prevent outages. diff --git a/docs/internal/src/codebase.md b/docs/internal/src/codebase.md index 1a31c87f0d..09ae97fba9 100644 --- a/docs/internal/src/codebase.md +++ b/docs/internal/src/codebase.md @@ -3,26 +3,13 @@ The code is organised using a Rust workspace with separate crates for the node and remote prover binaries, a crate for each node component, a couple of gRPC-related codegen crates, and a catch-all utilities crate. -The primary artifacts are the node and remote prover binaries. The library crates are not intended for external usage, but +The primary execution artifacts are the node and remote prover binaries. The library crates are not intended for external usage, but instead simply serve to enforce code organisation and decoupling. -| Crate | Description | -| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `node` | The node executable. Configure and run the node and its components. | -| `remote-prover` | Remote prover executables. Includes workers and proxies. | -| `remote-prover-client` | Remote prover client implementation. | -| `block-producer` | Block-producer component implementation. | -| `store` | Store component implementation. | -| `ntx-builder` | Network transaction builder component implementation. | -| `rpc` | RPC component implementation. | -| `proto` | Contains and exports all protobuf definitions. | -| `rpc-proto` | Contains the RPC protobuf definitions. Currently this is an awkward clone of `proto` because we re-use the definitions from the internal protobuf types. | -| `utils` | Variety of utility functionality. | -| `test-macro` | Provides a procedural macro to enable tracing in tests. | - ---- +We have a top-level `proto` crate, which contains the external and internal gRPC and protobuf schemas. It also exposes the +`tonic`/`prost` file descriptors for each gRPC service for convenience. We then have an internal `proto` crate in `./crates`, +which uses the above file descriptors to generate the actual service traits, and also defines some domain objects and other gRPC +shared utilities and definitions. > [!NOTE] > [`miden-protocol`](https://github.com/0xMiden/miden-protocol) is an important dependency which > contains the core Miden protocol definitions e.g. accounts, notes, transactions etc. - -[![workspace dependency tree](assets/workspace_tree.svg)](assets/workspace_tree.svg) diff --git a/docs/internal/src/components.md b/docs/internal/src/components.md index 9253fed98f..e427c1083f 100644 --- a/docs/internal/src/components.md +++ b/docs/internal/src/components.md @@ -1,6 +1,6 @@ # Node components -The node is split into three distinct components that communicate via gRPC. See the +The node is split into five distinct components that communicate via gRPC. See the [Operator guide#architecture](https://0xmiden.github.io/miden-docs/miden-node/operator/architecture) chapter for an overview of each component. The following sections will describe the inner architecture of each component. diff --git a/docs/internal/src/ntx-builder.md b/docs/internal/src/ntx-builder.md index 27be99a0b7..bc9c3cfbe9 100644 --- a/docs/internal/src/ntx-builder.md +++ b/docs/internal/src/ntx-builder.md @@ -8,13 +8,13 @@ Network accounts are a special type of fully public account which contains no au whose state can therefore be updated by anyone (in theory). Such accounts are required when publicly mutable state is needed. -The issue with publicly mutable state is that transactions against an account must be sequential +An issue with publicly mutable state is that transactions against an account must be sequential and require the previous account commitment in order to create the transaction proof. This conflicts with Miden's client side proving and concurrency model since users would race each other to submit transactions against such an account. -Instead the solution is to have the network be responsible for driving the account state forward, -and users can interact with the account using notes. Notes don't require a specific ordering and +Instead our solution is to have the network be responsible for driving the account state forward, +and users can interact with the account only indirectly using notes. Notes don't require a specific ordering and can be created concurrently without worrying about conflicts. We call these network notes and they always target a specific network account. @@ -53,9 +53,8 @@ argument (default: 5 minutes). Deactivated actors are re-spawned when new notes targeting their account are detected by the coordinator (via the `send_targeted` path). -If an actor repeatedly crashes (shuts down due to a database error), its crash count is tracked by -the coordinator. Once the count reaches the configurable threshold, the account is **deactivated** -and no new actor will be spawned for it. This prevents resource exhaustion from a persistently +Each actors crash count is tracked, and once the count reaches a configurable threshold, the account is +**deactivated** and no new actor will be spawned for it. This prevents resource exhaustion from a persistently failing account. The threshold is configurable via the `--ntx-builder.max-account-crashes` CLI argument (default: 10). diff --git a/docs/internal/src/oddities.md b/docs/internal/src/oddities.md index b7b65e2173..24bca25f8a 100644 --- a/docs/internal/src/oddities.md +++ b/docs/internal/src/oddities.md @@ -13,3 +13,10 @@ between the chain MMR and the block hash: To work-around this the inclusion of a block hash in the chain MMR is delayed by one block. Or put differently, block `N` is responsible for inserting block `N-1` into the chain MMR. This does _not_ break blockchain linkage because the block header (and therefore hash) still includes the previous block's hash. + +## Crate: `rocksdb-cxx-linkage-fix` + +This crate is used to ensure that statically linking the `rocksdb` library works as intended. + +More information can be found in the crate's doc comments, but this crate is required for now to be included +as part of the `build.rs` in the large SMT crate which depends on `rocksdb`. diff --git a/docs/internal/src/rpc.md b/docs/internal/src/rpc.md index 3870dedfe4..361fe8927e 100644 --- a/docs/internal/src/rpc.md +++ b/docs/internal/src/rpc.md @@ -8,16 +8,19 @@ get rejected _before_ reaching the store and block-producer, reducing their load the proofs of submitting transactions. This allows the block-producer to skip proof verification (it trusts the RPC component), reducing the load in this critical component. -## RPC Versioning +## RPC Versioning and the HTTP `ACCEPT` header -The RPC server enforces version requirements against connecting clients that provide the HTTP ACCEPT header. When this header is provided, its corresponding value must follow this format: `application/vnd.miden.0.9.0+grpc`. +The RPC component allows clients to negotiate their desired Miden RPC version using the well-known HTTP `ACCEPT` header, using the following format: -If there is a mismatch in version, clients will encounter an error while executing gRPC requests against the RPC server with the following details: +```sh +application/vnd.miden; version=; genesis= +``` -- gRPC status code: 3 (Invalid Argument) -- gRPC message: Missing required ACCEPT header +The `version` lets the client specify their supported version and the server will attempt to comply if it can. At this early stage, only client versions which are semver compatible with the +server version are likely to be accepted i.e. the server in all likely only supports a _single version_. -The server will reject any version that does not have the same major and minor version to it. This behaviour will change after v1.0.0., at which point only the major version will be taken into account. +The `genesis` property is intended to let the client confirm they are on the correct network, by specifying the network's genesis commitment. This guards against operating on the wrong network, +as well as against network resets. ## Query limits (`GetLimits`) diff --git a/docs/internal/src/store.md b/docs/internal/src/store.md index 67ad1d4d9b..90bef64e68 100644 --- a/docs/internal/src/store.md +++ b/docs/internal/src/store.md @@ -10,10 +10,6 @@ information is always read from disk. We will need to revisit this in the future We have database migration support in place but don't actively use it yet. There is only the latest schema, and we reset chain state (aka nuke the existing database) on each release. -Note that the migration logic includes both a schema number _and_ a hash based on the sql schema. These are both checked -on node startup to ensure that any existing database matches the expected schema. If you're seeing database failures on -startup its likely that you created the database _before_ making schema changes resulting in different schema hashes. - ## RocksDB tree storage The account and nullifier trees are persisted in separate RocksDB instances under @@ -27,7 +23,6 @@ bits vary by depth (8.0–12.0) and memtables are 128 MiB per column family. See full fixed configuration. Runtime-tuneable parameters are documented in the [operator usage guide](https://github.com/0xMiden/node/blob/next/docs/external/src/operator/usage.md#rocksdb-tuning). - ## Architecture The store consists mainly of a gRPC server which answers requests from the RPC and block-producer components, as well as diff --git a/docs/internal/src/validator.md b/docs/internal/src/validator.md new file mode 100644 index 0000000000..336400ae04 --- /dev/null +++ b/docs/internal/src/validator.md @@ -0,0 +1,27 @@ +# Validator Component + +The validator is responsible for verifying each new block and signing it if correct. + +This signature is required _before_ a block may be committed on chain, and thus acts as an +independent safe guard. + +The validator is therefore run completely separate from the main node operations, and is operated +by a separate entity. The validator's public key is published (or at least will be for `mainnet`). + +## Dual purpose: training wheels + +The validator has a 2nd purpose while Miden is maturing. To prevent private state from being lost, and to guard +from potential bugs in the VM/cryptography primitives, Miden will launch with training wheels. Notably, we will +require users to _include_ the private input data along with their transactions. This means users will have privacy +on the _network_ but not from the network operator. + +As part of the transaction submission process, each transaction, its proof, and private inputs, are sent to the validator, +which re-executes the transaction, thereby verifying it and its proof are correct. This also lets us store the private data +as part of our training wheels. + +## Block verification + +The validator ensures that each new block is sequential with the previously signed block. i.e. `header.parent_commitment == last_block.commitment`. +It also checks that the block contains only transactions that it has previously seen and verified. + +Once verified, the block is signed and returned to the sender. diff --git a/proto/proto/types/transaction.proto b/proto/proto/types/transaction.proto index 66504d67a1..e133bcdc0b 100644 --- a/proto/proto/types/transaction.proto +++ b/proto/proto/types/transaction.proto @@ -8,18 +8,39 @@ import "types/primitives.proto"; // TRANSACTION // ================================================================================================ -// Submits proven transaction to the Miden network. +// A proven transaction. +// +// Note that we currently require full transaction transparency for the network operator. +// This is a temporary measure while Miden stabilizes its protocol and proof systems. To +// this end, a transaction submission includes its **private** inputs which the operator +// can use to verify the transaction execution and proofs are correct. +// +// This means the transaction is _not_ private wrt the network operator (but it is still +// private onchain). This requirement will be lifted as Miden matures. message ProvenTransaction { // The transaction proof. // // Encoded using [miden_protocol::transaction::ProvenTransaction::to_bytes]. bytes transaction = 1; - // The inputs used for the transaction proof. + // The private inputs used for the transaction proof. // // Encoded using [miden_protocol::transaction::TransactionInputs::to_bytes]. + // + // Transactions missing this field will be rejected as per the message description. optional bytes transaction_inputs = 2; } +// A proven batch of transactions. +// +// Note that we currently require full transaction transparency for the network operator. +// This is a temporary measure while Miden stabilizes its protocol and proof systems. To +// this end, each transaction includes its **private** inputs which the operator can use +// to verify the transaction execution and proofs are correct. +// +// This means the transaction is _not_ private wrt the network operator (but it is still +// private onchain). This requirement will be lifted as Miden matures. +// +// In addition, in order to verify the batch itself, we also require the proposed batch. message TransactionBatch { // The batch proof. // @@ -28,12 +49,16 @@ message TransactionBatch { // The batch contents of the given proof. // // Encoded using [miden_protocol::batch::ProposedBatch::to_bytes]. + // + // Batches missing this field will be rejected as per the message description. optional bytes proposed_batch = 2; // The transaction inputs for each transaction in the batch. // // Must match the transaction ordering in the batch. // // Encoded using [miden_protocol::transaction::TransactionInputs::to_bytes]. + // + // Batch will be rejected if any transaction's input is missing as per the method description. repeated bytes transaction_inputs = 3; }