Struct SpeculativeSim 

pub struct SpeculativeSim { /* private fields */ }

Optimistic simulation results plus a handle to their deferred validation.

Returned by FreshnessController::run as soon as the optimistic sims finish (without awaiting RPC). Read optimistic immediately, then await validate for the verdict.

Cancellation (best-effort)

Dropping this — or calling into_optimistic — sets a cancel flag and aborts the background task. Cancellation is cooperative and best-effort, not instantaneous: run_validator is synchronous, so an abort cannot preempt it once it is running. Instead the validator checks the flag at several checkpoints — before each fetch, and (on the first pass) after a fetch returns but before it records observations or queues corrections — so a cancel observed at a checkpoint skips the side effects downstream of it. A validator already executing a synchronous step (e.g. mid-fetch) completes that step before reaching the next checkpoint, and corrections accumulated up to a fetch that completed in the final loop iteration may still be queued for flow-back (the post-loop queue is not guarded by an immediately-preceding checkpoint). The intent is that a dropped speculation stops doing further work and, in the common case, does not flow corrections back into the cache; it does not guarantee that an in-flight or just-completed fetch’s correction is withheld.

Implementations

impl SpeculativeSim

pub fn optimistic(&self) -> &[CallSimulationResult]

The optimistic results, readable before validation completes.

These (and the re-run results in Validation::Corrected) carry an empty token_deltas map: the optimistic loop does not run transfer tracking, so the signed per-token balance deltas populated by the committing simulate_call_with_balance_deltas path are not available here.

pub fn into_optimistic(self) -> Vec<CallSimulationResult>

Consume the handle and return the optimistic results, aborting the background validation task.

Because this takes self by value, it and validate are mutually exclusive: only one of them can ever run for a given SpeculativeSim, and each takes the handle.

pub async fn validate(self) -> Result<Validation>

Await the deferred validation verdict.

If the background task failed to complete (e.g. it panicked), returns an error. This consumes self, so it is mutually exclusive with the cancel paths (into_optimistic / drop) — a handle that is awaited here is never cancelled.

Trait Implementations

impl Drop for SpeculativeSim

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.