Struct CommitmentPipeline 

pub struct CommitmentPipeline<S, M = MemoryMmrStore> {
    state_store: S,
    risk_store: S,
    command_mmr: HypercallMmr<M>,
    obligation_mmr: HypercallMmr<M>,
    intent_mmr: HypercallMmr<M>,
    version: Version,
    prune_window: u64,
}

The commitment pipeline.

Generic over the store backend (S) so it works with both FastMemoryStore (tests) and RocksDbStore (production).

Two separate JMTs:

• State tree: accounts, positions, orders, instruments, oracles, global
• Risk tree: per-account risk metrics (equity, margin, scanning risk)

Plus three MMRs for append-only data (command log, obligations, intents).

Fields

state_store: S

risk_store: S

command_mmr: HypercallMmr<M>

obligation_mmr: HypercallMmr<M>

intent_mmr: HypercallMmr<M>

version: Version

prune_window: u64

Implementations

impl CommitmentPipeline<RocksDbStore, RocksDbMmrStore>

pub fn checkpoint_inherited_state_root(&self, version: Version) -> Result<bool>

pub fn checkpoint_inherited_risk_root(&self, version: Version) -> Result<bool>

pub fn prune_stores(&self, prune_to: Version) -> Result<(usize, usize)>

pub fn compact_stores(&self) -> Result<()>

impl<S: TreeReader + TreeWriter> CommitmentPipeline<S, MemoryMmrStore>

pub fn new(state_store: S, risk_store: S, prune_window: u64) -> Self

Create a new pipeline starting at version 0.

impl<S, M> CommitmentPipeline<S, M>

where S: TreeReader + TreeWriter, M: MmrMetadataStore + SupportedMmrStore + PrepareMmrStore, for<'a> &'a M: MMRStoreReadOps<MmrHash> + MMRStoreWriteOps<MmrHash>,

pub fn new_with_mmrs( state_store: S, risk_store: S, command_mmr_store: M, obligation_mmr_store: M, intent_mmr_store: M, prune_window: u64, ) -> Result<Self>

pub fn with_version(self, version: Version) -> Self

Resume from a known version (e.g., after loading from disk).

pub fn version(&self) -> Version

Current version (number of committed batches).

pub fn prune_window(&self) -> u64

Configured number of recent versions to keep available for proofs.

pub fn prepare_commit( &self, delta: &StateDelta, ) -> Result<PreparedBatchCommitment>

Prepare a batch commitment without mutating the backing stores.

pub fn apply_prepared_commit( &mut self, prepared: PreparedBatchCommitment, ) -> Result<BatchCommitment>

Apply a prepared batch commitment after the caller’s durability boundary.

pub fn commit(&mut self, delta: &StateDelta) -> Result<BatchCommitment>

Commit a batch of state changes and return the new roots.

This is the main entry point for callers that do not need to interpose another durability boundary between root computation and store mutation.

pub fn append_command(&mut self, command_hash: [u8; 32]) -> Result<()>

Append a command hash to the command MMR.

pub fn append_obligation(&mut self, obligation_hash: [u8; 32]) -> Result<()>

Append an obligation to the obligation MMR.

pub fn append_intent(&mut self, intent_hash: [u8; 32]) -> Result<()>

Append a user intent to the intent MMR.

fn latest_root(&self, store: &S, version: Version) -> Result<RootHash>

fn prepare_state_delta( &self, delta: &StateDelta, version: Version, ) -> Result<(RootHash, usize, Option<TreeUpdateBatch>)>

fn prepare_risk_delta( &self, risk_updates: &[RiskUpdate], version: Version, ) -> Result<(RootHash, usize, Option<TreeUpdateBatch>)>