Struct DeferredState 

pub struct DeferredState { /* private fields */ }

Deferred graph and eager evaluation state.

Registered original nodes, canonical/helper nodes, evaluation memos, the current root, and the element budget live here. Self::into_witness exports only the original root-reachable graph and releases the state.

Implementations

impl DeferredState

pub fn new(registry: Arc<PrecompileRegistry>) -> Result<Self, PrecompileError>

pub fn extend_precompiles( &mut self, precompiles: PrecompileRegistry, ) -> Result<(), PrecompileError>

Adds precompiles to this state without discarding existing nodes, evaluation memos, root, or budget accounting.

Registration is additive only: duplicate precompile ids panic via PrecompileRegistry::merge, matching setup-time registry construction behavior. The state is cloned before mutation so failed precompile initialization leaves self unchanged.

pub fn registry(&self) -> &PrecompileRegistry

pub fn root(&self) -> Digest

Returns the current deferred root; super::TRUE_DIGEST means no statements are logged.

pub fn get_node(&self, digest: &Digest) -> Option<&Node>

pub fn get_canonical_digest(&self, digest: Digest) -> Option<Digest>

Returns the already-memoized canonical digest for digest, if present.

This is strictly read-only: it does not evaluate digest, validate deferred nodes, insert canonical results, or mutate the memo table. Missing memos and dangling memos whose canonical node is absent from this state both return None.

pub fn get_canonical_node(&self, digest: Digest) -> Option<(Digest, &Node)>

Returns the already-memoized canonical node for digest, if present.

This is strictly read-only and returns only canonical results that are already memoized and stored in this state.

pub fn require_canonical_node( &self, digest: Digest, ) -> Result<(Digest, &Node), PrecompileError>

Returns the already-memoized canonical node for digest or PrecompileError::MissingNode.

This is strictly read-only and never evaluates or mutates deferred state.

pub fn num_elements(&self) -> usize

Returns the approximate number of field elements occupied by registered deferred nodes.

pub fn remaining_elements(&self) -> usize

pub fn decode(&self, tag: Tag) -> Result<NodeType, PrecompileError>

Recognizes tag under the installed registry and returns its declared outer payload shape.

This does not inspect a payload, validate structural child references, or evaluate precompile semantics. Self::register performs those checks for a complete node.

pub fn register(&mut self, node: Node) -> Result<Digest, PrecompileError>

Registers a PrecompileRegistry-valid node in the DAG and evaluates it immediately.

Registration validates the node shape and child references, stores the original node under its own digest, evaluates it under the current registry, stores the canonical result node, preserves helper nodes registered during evaluation, and records the evaluation memo from original digest to canonical digest. The returned digest is always the original node digest. If evaluation fails, registration returns that error immediately. Re-registering an identical successfully registered node is idempotent and budget-free.

pub fn log_statement( &mut self, statement_digest: Digest, ) -> Result<Digest, PrecompileError>

Logs a statement commitment after proving the current root and statement evaluate to TRUE.

The statement digest must already be registered (present in nodes), unless it is the implicit TRUE_DIGEST. On success, this inserts the framework AND node, advances the deferred root, memoizes the new root as TRUE, and returns the new root.

pub fn log_verified_statement( &mut self, statement_digest: Digest, expected_new_root: Digest, ) -> Result<Digest, PrecompileError>

Logs a statement only if its constrained transition matches expected_new_root.

The VM constrains log_deferred as a Poseidon2 fold over the previous deferred root and the statement digest. This helper binds the in-memory deferred DAG to that constrained transition: it validates the expected root before mutating self, then applies the same semantic checks as Self::log_statement.

pub fn evaluate_digest( &mut self, digest: Digest, ) -> Result<Digest, PrecompileError>

Evaluates a registered node addressed by digest and returns the canonical node digest.

Evaluation memoization is an implementation detail: callers receive the canonical digest whether the result was already known or computed by this call. Use Self::get_node with the returned digest to inspect the canonical node contents.

pub fn into_witness(self) -> Result<Option<PrecompileWitness>, IntegrityError>

Consumes completed execution state and exports its root-reachable portable graph.

Executions without logged work return None. Export preserves original node commitments and omits unreachable nodes and evaluation caches; it does not serialize through bytes.

Trait Implementations

impl Clone for DeferredState

fn clone(&self) -> DeferredState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeferredState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DeferredState

fn default() -> Self

Returns the “default value” for a type.