Struct Store 

pub struct Store { /* private fields */ }

Statement store.

Implementations

impl Store

pub fn new_shared<Block, Client, BE>( path: &Path, config: Config, client: Arc<Client>, keystore: Arc<LocalKeystore>, prometheus: Option<&PrometheusRegistry>, task_spawner: Box<dyn SpawnNamed>, ) -> Result<Arc<Store>>

where Block: BlockT, Block::Hash: From<BlockHash>, BE: Backend<Block> + 'static, Client: HeaderBackend<Block> + StorageProvider<Block, BE> + Send + Sync + 'static,

Create a new shared store instance. There should only be one per process. path will be used to open a statement database or create a new one if it does not exist.

pub fn maintain(&self)

Perform periodic store maintenance: permanently delete statements whose purge period has elapsed and refresh store metrics.

Expired and evicted statements are not removed from the database immediately; they are kept in the EXPIRED column for DEFAULT_PURGE_AFTER_SEC (default 48h) to prevent re-acceptance while they may still be propagating over gossip. This method removes those whose purge period has passed.

Runs in a background task on a fixed interval (MAINTENANCE_PERIOD, 29s). Enforcing per-account and global limits — expiring over-quota statements — is handled separately by enforce_limits on its own interval (ENFORCE_LIMITS_PERIOD, 31s), kept distinct to avoid holding the index lock for too long during maintenance.

pub fn as_statement_store_ext(self: Arc<Self>) -> StatementStoreExt

Returns self as StatementStoreExt.

Trait Implementations

impl StatementStore for Store

fn statements(&self) -> Result<Vec<(Hash, Statement)>>

Return every statement currently in the store.

Takes a read lock on the query index, iterates all indexed hashes, reads and SCALE-decodes each statement from the STATEMENTS database column, and skips any entry that fails to decode.

fn statement(&self, hash: &Hash) -> Result<Option<Statement>>

Read a single statement directly from the STATEMENTS database column by hash and decode it. Returns Ok(None) if no statement with that hash is stored.

fn broadcasts(&self, match_all_topics: &[Topic]) -> Result<Vec<Vec<u8>>>

Return the data of all statements matching all of match_all_topics that have no decryption key (i.e. public broadcasts).

Filters the query index by topic (intersection; an empty list matches every broadcast), reads and decodes each match from the STATEMENTS column, and returns the plaintext data, skipping any inconsistent entries.

fn posted( &self, match_all_topics: &[Topic], dest: [u8; 32], ) -> Result<Vec<Vec<u8>>>

Return the (encrypted) data of all statements matching all of match_all_topics whose decryption key equals dest.

Same filtering and DB read as broadcasts, but keyed on dest rather than the absence of a decryption key.

fn posted_clear( &self, match_all_topics: &[Topic], dest: [u8; 32], ) -> Result<Vec<Vec<u8>>>

Like posted but returns the decrypted data.

For each match, looks up the ed25519 key identified by dest in the keystore and decrypts the statement data; statements are skipped when the key is unavailable or decryption fails.

fn broadcasts_stmt(&self, match_all_topics: &[Topic]) -> Result<Vec<Vec<u8>>>

Return the full SCALE-encoded statements matching all of match_all_topics that have no decryption key (i.e. public broadcasts).

Takes a read lock on the query index and filters by the absence of a decryption key and topics (intersection / AND — an empty topic list matches every broadcast), then reads, decodes and re-encodes each match from the STATEMENTS column, skipping inconsistent entries. Unlike broadcasts, which returns only the data, this returns the whole statement.

fn posted_stmt( &self, match_all_topics: &[Topic], dest: [u8; 32], ) -> Result<Vec<Vec<u8>>>

Return the full SCALE-encoded statements matching all of match_all_topics whose decryption key equals dest.

Takes a read lock on the query index and filters by decryption key (dest) and topics (intersection / AND — an empty topic list matches every statement keyed to dest), then reads, decodes and re-encodes each match from the STATEMENTS column, skipping inconsistent entries. Unlike posted, which returns only the (still-encrypted) data, this returns the whole statement.

fn posted_clear_stmt( &self, match_all_topics: &[Topic], dest: [u8; 32], ) -> Result<Vec<Vec<u8>>>

Return, for each statement matching all of match_all_topics whose decryption key equals dest, the SCALE-encoded statement concatenated with its decrypted data.

Filters as posted_stmt, then for each match looks up the ed25519 key identified by dest in the keystore and decrypts the statement data, appending the plaintext to the encoded statement. Statements are skipped when the key is unavailable or decryption fails.

fn submit(&self, statement: Statement, source: StatementSource) -> SubmitResult

Submit a statement to the store, validating it and enforcing constraints.

Runs the following pipeline, short-circuiting on the first failure:

1. Expiry check — reject if the statement’s expiration timestamp is already in the past (SubmitResult::Invalid(InvalidReason::AlreadyExpired)).
2. Encoding size check — reject if the encoded statement exceeds MAX_STATEMENT_SIZE (InvalidReason::EncodingTooLarge).
3. Duplicate check — a statement already in the store is reported Known: the hash covers the whole content, so a duplicate carries nothing to renew. A recently evicted statement may be resubmitted (renewed) by Chain and Local sources but not by Network (SubmitResult::KnownExpired).
4. Proof & signature — extract the account from the proof and verify the signature (InvalidReason::NoProof / InvalidReason::BadProof).
5. Allowance — read the account’s allowance (StatementAllowance: max count and size) directly from chain state at the best block (via the statement_allowance_key storage key — not a runtime call); reject with SubmitResult::Rejected(NoAllowance) if none is set. The best block is used for responsiveness; a statement accepted here may later be evicted when limits are enforced against the finalized block.
6. Constraint check & eviction — check the account’s record, enforcing per-account limits (count, size, one statement per channel, higher priority replaces lower) and global limits (DEFAULT_MAX_TOTAL_STATEMENTS, DEFAULT_MAX_TOTAL_SIZE), evicting lower-priority statements of the same account as needed (SubmitResult::Rejected if it still does not fit).
7. Persist — commit the statement, its index rows, any evictions and the refreshed counters atomically, then update the caches and the in-memory query index.

Returns SubmitResult::New on success.

fn remove(&self, hash: &Hash) -> Result<()>

Soft-delete a statement by hash: drop it and its index rows from the database, and record it in the EXPIRED column so it cannot be re-accepted until its purge period elapses (see maintain). No-op if the statement is unknown.

fn remove_by(&self, who: [u8; 32]) -> Result<()>

Remove every statement authored by who, applying the same soft-delete as remove to each, in a single atomic commit.

fn take_recent_statements(&self) -> Result<Vec<(u64, Hash, Statement)>>

Return recent statements with their admission sequence numbers, oldest admission first, and clear the internal index.

fn admission_watermark(&self) -> Result<u64>

One past the newest assigned admission sequence number.

fn admitted_statements( &self, cursor: u64, watermark: u64, scan_limit: usize, filter: &mut dyn FnMut(&Hash, &[u8], &Statement) -> FilterDecision, ) -> Result<AdmittedBatch>

Walk the admission journal from cursor (inclusive) towards watermark (exclusive), collecting statements through a filter callback.

fn has_statement(&self, hash: &Hash) -> bool

Check if statement exists in the store

fn statements_by_hashes( &self, hashes: &[Hash], filter: &mut dyn FnMut(&Hash, &[u8], &Statement) -> FilterDecision, ) -> Result<(Vec<(Hash, Statement)>, usize)>

Fetch statements by their hashes with a filter callback.

impl StatementStoreSubscriptionApi for Store

fn subscribe_statement( &self, topic_filter: OptimizedTopicFilter, ) -> Result<(Vec<Vec<u8>>, Sender<StatementEvent>, SubscriptionStatementsStream)>

Subscribe to statements matching the topic filter.