Struct Balance 

pub struct Balance;

Pipeline marker for balance.

Trait Implementations

impl Handler for Balance

type Batch = HashMap<Key, (i128, i128)>

Combine deltas observed in this checkpoint by (owner, coin_type) so a single combined merge operand is staged per key instead of many small ones.

type Store = Store<RpcStoreSchema>

fn batch(&self, batch: &mut Self::Batch, values: IntoIter<Delta>)

Add values from processing a checkpoint to the current batch. Checkpoints are guaranteed to be presented to the batch in checkpoint order. The handler takes ownership of the iterator and consumes all values.

fn commit<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, batch: &'life1 Self::Batch, conn: &'life2 mut Connection<'a, Schema>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Take a batch of values and commit them to the database, returning the number of rows affected.

const MIN_EAGER_ROWS: usize = 50usize

If at least this many rows are pending, the committer will commit them eagerly.

const MAX_PENDING_ROWS: usize = 5_000usize

Soft cap: once this many rows are pending, the collector stops eagerly draining its input channel and yields to the flush phase. Receive is never hard-gated — unlike concurrent pipelines, a missing predecessor may be buried in the input channel, and blocking receive would risk deadlock. The cap only bounds receive-to-flush latency in the happy path.

const MAX_BATCH_CHECKPOINTS: usize = 300usize

Maximum number of checkpoints to try and write in a single batch. The larger this number is, the more chances the pipeline has to merge redundant writes, but the longer each write transaction is likely to be.

impl Processor for Balance

const NAME: &'static str = "balance"

Used to identify the pipeline in logs and metrics.

type Value = Delta

The type of value being inserted by the handler.

fn process<'life0, 'life1, 'async_trait>( &'life0 self, checkpoint: &'life1 Arc<Checkpoint>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Delta>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The processing logic for turning a checkpoint into rows of the table.

impl Restore for Balance

fn restore( &self, schema: &Self::Schema, object: &Object, batch: &mut Batch, ) -> Result<()>

Stage merge operands derived from a single live object. Two sources contribute to a balance row, both recoverable from the live object set:

• Coin half: address-owned (and consensus-address-owned) Coin<T> objects. The coin’s balance field is credited to the (owner, coin_type) row’s coin component. Mirrors index_object’s coin path in sui-core::rpc_index.

• Address half: dynamic-field objects parented to SUI_ACCUMULATOR_ROOT_OBJECT_ID. These carry the per-(owner, coin_type) accumulator balance, which the tip pipeline would otherwise re-derive from AccumulatorWrite events. Mirrors get_address_balance_info in sui-core::rpc_index.

Everything else (shared / immutable objects, non-coin address-owned objects, dynamic fields under other parents) contributes no balance row.

type Schema = RpcStoreSchema

The portion of the schema this pipeline writes to during restore. Typically a struct of DbMap fields scoped to the CFs this pipeline owns. The driver supplies an &Self::Schema on every restore call.