416 lines
26 KiB
Rust
416 lines
26 KiB
Rust
// file: ks-store/src/lib.rs
|
|
// version: 18
|
|
|
|
//! Backend-agnostic Solana storage contracts and store facade.
|
|
#![warn(missing_docs)]
|
|
#![deny(unreachable_pub)]
|
|
#![forbid(unsafe_code)]
|
|
|
|
mod constants;
|
|
mod contracts;
|
|
mod postgres;
|
|
mod store;
|
|
|
|
/// Canonical crate-internal tracing target shared through the crate-root facade.
|
|
pub(crate) use self::constants::TRACING_TARGET;
|
|
/// Crate-internal storage symbol `ACCOUNT_OBSERVATIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::ACCOUNT_OBSERVATIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_ACCOUNT_KEYS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_ACCOUNT_KEYS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_ACCOUNT_STATES_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_ACCOUNT_STATES_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_BALANCE_CHANGES_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_BALANCE_CHANGES_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_INNER_INSTRUCTIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_INNER_INSTRUCTIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_INSTRUCTIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_INSTRUCTIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_LOGS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_LOGS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_RETURN_DATA_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_RETURN_DATA_TABLE_NAME;
|
|
/// Crate-internal storage symbol `CORE_TRANSACTIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::CORE_TRANSACTIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `DECODE_COVERAGE_DECLARATIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::DECODE_COVERAGE_DECLARATIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `DECODE_COVERAGE_OBSERVATIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::DECODE_COVERAGE_OBSERVATIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `DECODE_EVENTS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::DECODE_EVENTS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `MATERIALIZED_OUTPUTS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::MATERIALIZED_OUTPUTS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `PROCESSING_LEDGER_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::PROCESSING_LEDGER_TABLE_NAME;
|
|
/// Crate-internal managed PostgreSQL schema compatibility summary shared through the crate-root facade.
|
|
pub(crate) use self::postgres::PostgresSchemaCompatibilitySummary;
|
|
/// Crate-internal storage symbol `PostgresStore` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::PostgresStore;
|
|
/// Crate-internal storage symbol `PostgresStoreOptions` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::PostgresStoreOptions;
|
|
/// Crate-internal storage symbol `PostgresTableDiagnosticSpec` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::PostgresTableDiagnosticSpec;
|
|
/// Crate-internal storage symbol `RAW_TRANSACTIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::RAW_TRANSACTIONS_TABLE_NAME;
|
|
/// Crate-internal storage symbol `STORE_SCHEMA_ADVISORY_LOCK_ID` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::STORE_SCHEMA_ADVISORY_LOCK_ID;
|
|
/// Crate-internal storage symbol `TRANSACTION_OBSERVATIONS_TABLE_NAME` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::TRANSACTION_OBSERVATIONS_TABLE_NAME;
|
|
/// Crate-internal additive PostgreSQL managed-schema initializer shared through the crate-root facade.
|
|
pub(crate) use self::postgres::apply_missing_store_schema;
|
|
/// Crate-internal storage symbol `core_store_schema_statements` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::core_store_schema_statements;
|
|
/// Crate-internal storage symbol `core_store_table_diagnostic_specs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::core_store_table_diagnostic_specs;
|
|
/// Crate-internal storage symbol `decode_store_schema_statements` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::decode_store_schema_statements;
|
|
/// Crate-internal storage symbol `decode_store_table_diagnostic_specs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::decode_store_table_diagnostic_specs;
|
|
/// Crate-internal expected PostgreSQL index inventory shared through the crate-root facade.
|
|
pub(crate) use self::postgres::expected_postgres_index_names;
|
|
/// Crate-internal account-observation key lookup shared through the crate-root facade.
|
|
pub(crate) use self::postgres::has_account_observation_key;
|
|
/// Crate-internal storage symbol `has_raw_transaction_signature` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::has_raw_transaction_signature;
|
|
/// Crate-internal storage symbol `has_transaction_observation_key` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::has_transaction_observation_key;
|
|
/// Crate-internal account-observation insert shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_account_observation;
|
|
/// Crate-internal storage symbol `insert_core_account_keys` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_account_keys;
|
|
/// Crate-internal storage symbol `insert_core_balance_changes` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_balance_changes;
|
|
/// Crate-internal storage symbol `insert_core_inner_instructions` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_inner_instructions;
|
|
/// Crate-internal storage symbol `insert_core_instructions` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_instructions;
|
|
/// Crate-internal storage symbol `insert_core_logs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_logs;
|
|
/// Crate-internal storage symbol `insert_core_transaction` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_core_transaction;
|
|
/// Crate-internal storage symbol `insert_raw_transaction` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_raw_transaction;
|
|
/// Crate-internal storage symbol `insert_transaction_observation` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::insert_transaction_observation;
|
|
/// Crate-internal Core descendant invalidation shared through the crate-root facade.
|
|
pub(crate) use self::postgres::invalidate_core_descendants_in_transaction;
|
|
/// Crate-internal decode descendant invalidation shared through the crate-root facade.
|
|
pub(crate) use self::postgres::invalidate_decode_descendants_in_transaction;
|
|
/// Crate-internal account-state currentness lookup shared through the crate-root facade.
|
|
pub(crate) use self::postgres::is_account_state_current;
|
|
/// Crate-internal storage symbol `is_core_extraction_current` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::is_core_extraction_current;
|
|
/// Crate-internal storage symbol `is_decode_current` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::is_decode_current;
|
|
/// Crate-internal account-observation normalization selection shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_account_observations_for_normalization;
|
|
/// Crate-internal storage symbol `list_core_instruction_replay_inputs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_core_instruction_replay_inputs;
|
|
/// Crate-internal storage symbol `list_core_instructions_for_replay` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_core_instructions_for_replay;
|
|
/// Crate-internal storage symbol `list_decode_coverage_summary` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_decode_coverage_summary;
|
|
/// Crate-internal storage symbol `list_decode_inputs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_decode_inputs;
|
|
/// Crate-internal storage symbol `list_decode_replay_inputs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_decode_replay_inputs;
|
|
/// Crate-internal storage symbol `list_materialized_output_page` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_materialized_output_page;
|
|
/// Crate-internal storage symbol `list_materialized_outputs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_materialized_outputs;
|
|
/// Crate-internal storage symbol `list_raw_transactions_for_core_extraction` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_raw_transactions_for_core_extraction;
|
|
/// Crate-internal storage symbol `list_replay_entity_summaries` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_replay_entity_summaries;
|
|
/// Crate-internal storage symbol `list_replay_program_summaries` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_replay_program_summaries;
|
|
/// Crate-internal storage symbol `list_replay_transaction_candidates` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::list_replay_transaction_candidates;
|
|
/// Crate-internal storage symbol `load_current_schema` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_current_schema;
|
|
/// Crate-internal expected PostgreSQL index counts shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_expected_index_counts;
|
|
/// Crate-internal additive PostgreSQL schema statement planner shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_postgres_schema_addition_statements;
|
|
/// Crate-internal managed PostgreSQL schema compatibility loader shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_postgres_schema_compatibility;
|
|
/// Crate-internal storage symbol `load_server_version` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_server_version;
|
|
/// Crate-internal storage symbol `load_table_statistics` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::load_table_statistics;
|
|
/// Crate-internal account-state failure persistence shared through the crate-root facade.
|
|
pub(crate) use self::postgres::mark_account_state_failed;
|
|
/// Crate-internal storage symbol `mark_core_extraction_failed` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::mark_core_extraction_failed;
|
|
/// Crate-internal storage symbol `mark_decode_failed` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::mark_decode_failed;
|
|
/// Crate-internal account-state persistence shared through the crate-root facade.
|
|
pub(crate) use self::postgres::persist_account_state;
|
|
/// Crate-internal storage symbol `persist_core_extraction` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::persist_core_extraction;
|
|
/// Crate-internal storage symbol `persist_decode_coverage_declarations` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::persist_decode_coverage_declarations;
|
|
/// Crate-internal storage symbol `persist_decode_result` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::persist_decode_result;
|
|
/// Crate-internal storage symbol `persist_materialization_result` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::persist_materialization_result;
|
|
#[cfg(test)]
|
|
/// Crate-internal serialized PostgreSQL test guard shared through the crate-root facade.
|
|
pub(crate) use self::postgres::postgres_test_guard;
|
|
/// Crate-internal storage symbol `raw_store_schema_statements` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::raw_store_schema_statements;
|
|
/// Crate-internal storage symbol `raw_store_table_diagnostic_specs` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::raw_store_table_diagnostic_specs;
|
|
/// Crate-internal instruction lifecycle recomputation shared through the crate-root facade.
|
|
pub(crate) use self::postgres::recompute_instruction_lifecycle_in_transaction;
|
|
/// Crate-internal storage symbol `run_health_check` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::run_health_check;
|
|
/// Crate-internal embedded PostgreSQL table DDL inventory shared through the crate-root facade.
|
|
pub(crate) use self::postgres::store_table_create_statements;
|
|
/// Crate-internal storage symbol `table_exists` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_exists;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_account_keys_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_account_keys_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_account_states_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_account_states_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_balance_changes_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_balance_changes_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_inner_instructions_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_inner_instructions_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_instructions_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_instructions_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_logs_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_logs_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_return_data_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_return_data_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_core_transactions_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_core_transactions_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_decode_coverage_declarations_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_decode_coverage_declarations_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_decode_coverage_observations_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_decode_coverage_observations_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_decode_events_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_decode_events_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_mat_outputs_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_mat_outputs_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_obs_account_observations_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_obs_account_observations_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_obs_transaction_observations_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_obs_transaction_observations_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_ops_processing_ledger_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_ops_processing_ledger_sql;
|
|
/// Crate-internal storage symbol `table_stats_k_sol_raw_transactions_sql` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::table_stats_k_sol_raw_transactions_sql;
|
|
/// Crate-internal storage symbol `update_core_instruction_lifecycle` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::update_core_instruction_lifecycle;
|
|
/// Crate-internal storage symbol `update_raw_payload_lifecycle` shared through the crate-root facade.
|
|
pub(crate) use self::postgres::update_raw_payload_lifecycle;
|
|
/// Crate-internal PostgreSQL SQL-resource canary shared through the crate-root facade.
|
|
pub(crate) use self::postgres::validate_postgres_sql_resources;
|
|
|
|
/// Transitional logical schema contract identifier used until the `0.5.3-pre.3` rebuild.
|
|
pub use self::constants::STORE_SCHEMA_CONTRACT_VERSION;
|
|
/// Account-state normalization processing-stage identifier.
|
|
pub use self::contracts::ACCOUNT_STATE_NORMALIZATION_STAGE;
|
|
/// Generic account acquisition observation insert contract.
|
|
pub use self::contracts::AccountObservationInsert;
|
|
/// Generic account acquisition observation persisted row contract.
|
|
pub use self::contracts::AccountObservationRow;
|
|
/// Failed generic account-state normalization attempt.
|
|
pub use self::contracts::AccountStateNormalizationFailure;
|
|
/// Atomic persistence bundle for one generic Core account state.
|
|
pub use self::contracts::AccountStatePersistenceBundle;
|
|
/// Bounded generic account-observation selection for Core normalization.
|
|
pub use self::contracts::AccountStateSelectionFilter;
|
|
/// Generic account observation to Core account-state storage behavior.
|
|
pub use self::contracts::AccountStateStore;
|
|
/// Transaction acquisition observation origin.
|
|
pub use self::contracts::AcquisitionObservationOrigin;
|
|
/// Generic account acquisition observation status.
|
|
pub use self::contracts::AcquisitionObservationStatus;
|
|
/// Core account key insert contract.
|
|
pub use self::contracts::CoreAccountKeyInsert;
|
|
/// Core account key persisted row contract.
|
|
pub use self::contracts::CoreAccountKeyRow;
|
|
/// Core account key source category.
|
|
pub use self::contracts::CoreAccountKeySource;
|
|
/// Core account-state insert contract.
|
|
pub use self::contracts::CoreAccountStateInsert;
|
|
/// Core account-state persisted row contract.
|
|
pub use self::contracts::CoreAccountStateRow;
|
|
/// Core balance change insert contract.
|
|
pub use self::contracts::CoreBalanceChangeInsert;
|
|
/// Core balance change kind.
|
|
pub use self::contracts::CoreBalanceChangeKind;
|
|
/// Core balance change persisted row contract.
|
|
pub use self::contracts::CoreBalanceChangeRow;
|
|
/// Complete normalized Core extraction write bundle.
|
|
pub use self::contracts::CoreExtractionBundle;
|
|
/// Failure details persisted for one canonical-to-Core extraction attempt.
|
|
pub use self::contracts::CoreExtractionFailure;
|
|
/// Bounded canonical transaction selection filter for Core extraction.
|
|
pub use self::contracts::CoreExtractionSelectionFilter;
|
|
/// Canonical transaction-to-Core extraction storage behavior.
|
|
pub use self::contracts::CoreExtractionStore;
|
|
/// Core inner instruction insert contract.
|
|
pub use self::contracts::CoreInnerInstructionInsert;
|
|
/// Core inner instruction persisted row contract.
|
|
pub use self::contracts::CoreInnerInstructionRow;
|
|
/// Core instruction insert contract.
|
|
pub use self::contracts::CoreInstructionInsert;
|
|
/// Core instruction lifecycle mark request.
|
|
pub use self::contracts::CoreInstructionLifecycleMark;
|
|
/// Core instruction processing state.
|
|
pub use self::contracts::CoreInstructionProcessingState;
|
|
/// Core instruction replay filter contract.
|
|
pub use self::contracts::CoreInstructionReplayFilter;
|
|
/// Logical top-level or CPI instruction row selected for replay.
|
|
pub use self::contracts::CoreInstructionReplayRow;
|
|
/// Core instruction persisted row contract.
|
|
pub use self::contracts::CoreInstructionRow;
|
|
/// Logical scope of one replayable Core instruction.
|
|
pub use self::contracts::CoreInstructionScope;
|
|
/// Core log insert contract.
|
|
pub use self::contracts::CoreLogInsert;
|
|
/// Core log persisted row contract.
|
|
pub use self::contracts::CoreLogRow;
|
|
/// Core return-data insert contract.
|
|
pub use self::contracts::CoreReturnDataInsert;
|
|
/// Core return-data persisted row contract.
|
|
pub use self::contracts::CoreReturnDataRow;
|
|
/// Core transaction insert contract.
|
|
pub use self::contracts::CoreTransactionInsert;
|
|
/// Core transaction persisted row contract.
|
|
pub use self::contracts::CoreTransactionRow;
|
|
/// Core Solana storage behavior.
|
|
pub use self::contracts::CoreTransactionStore;
|
|
/// One bounded page with a refreshed total row count.
|
|
pub use self::contracts::CountedPageSlice;
|
|
/// Default repository page size.
|
|
pub use self::contracts::DEFAULT_PAGE_SIZE;
|
|
/// One machine-readable decoder coverage declaration row.
|
|
pub use self::contracts::DecodeCoverageDeclarationInsert;
|
|
/// One observed coverage classification row owned by one decode attempt.
|
|
pub use self::contracts::DecodeCoverageObservationInsert;
|
|
/// One row of aggregated decoder coverage diagnostics.
|
|
pub use self::contracts::DecodeCoverageSummaryRow;
|
|
/// Failed decode attempt persisted in the common processing ledger.
|
|
pub use self::contracts::DecodeFailure;
|
|
/// One processor-owned decoded observation row.
|
|
pub use self::contracts::DecodeObservationInsert;
|
|
/// Atomic persistence bundle for one decoder and one contextual input.
|
|
pub use self::contracts::DecodePersistenceBundle;
|
|
/// Contextual instruction decode and materialization storage behavior.
|
|
pub use self::contracts::DecodePipelineStore;
|
|
/// Source-neutral external decode schema provenance.
|
|
pub use self::contracts::DecodeSchemaProvenance;
|
|
/// Bounded contextual instruction selection filter for decode campaigns.
|
|
pub use self::contracts::DecodeSelectionFilter;
|
|
/// Insert or upsert result contract returned by repositories.
|
|
pub use self::contracts::InsertOutcome;
|
|
/// Maximum number of account observations selected by one normalization query.
|
|
pub use self::contracts::MAX_ACCOUNT_STATE_SELECTION_ROWS;
|
|
/// Maximum canonical transactions selected by one Core extraction batch.
|
|
pub use self::contracts::MAX_CORE_EXTRACTION_SELECTION_ROWS;
|
|
/// Maximum contextual inputs selected by one decode processing batch.
|
|
pub use self::contracts::MAX_DECODE_SELECTION_ROWS;
|
|
/// Maximum number of materialized rows returned by one bounded query.
|
|
pub use self::contracts::MAX_MATERIALIZED_OUTPUT_QUERY_ROWS;
|
|
/// Maximum encoded opaque page-cursor length.
|
|
pub use self::contracts::MAX_PAGE_CURSOR_LENGTH;
|
|
/// Maximum repository page size.
|
|
pub use self::contracts::MAX_PAGE_SIZE;
|
|
/// Atomic persistence bundle for one materializer and one decoded observation.
|
|
pub use self::contracts::MaterializationPersistenceBundle;
|
|
/// Bounded read-only materialized output selection.
|
|
pub use self::contracts::MaterializedOutputFilter;
|
|
/// One processor-owned generic materialized output row.
|
|
pub use self::contracts::MaterializedOutputInsert;
|
|
/// Cursor-paginated materialized output filter.
|
|
pub use self::contracts::MaterializedOutputPageFilter;
|
|
/// One materialized output returned by a bounded query.
|
|
pub use self::contracts::MaterializedOutputQueryRow;
|
|
/// Page request contract for repository list operations.
|
|
pub use self::contracts::PageRequest;
|
|
/// One bounded repository page and its optional continuation cursor.
|
|
pub use self::contracts::PageSlice;
|
|
/// Stable processing ledger identity.
|
|
pub use self::contracts::ProcessingLedgerIdentity;
|
|
/// Stable processing ledger status.
|
|
pub use self::contracts::ProcessingLedgerStatus;
|
|
/// Raw payload lifecycle mark request.
|
|
pub use self::contracts::RawPayloadLifecycleMark;
|
|
/// Raw payload processing state.
|
|
pub use self::contracts::RawPayloadProcessingState;
|
|
/// Raw payload retention state.
|
|
pub use self::contracts::RawPayloadRetentionState;
|
|
/// Canonical raw Solana transaction insert contract.
|
|
pub use self::contracts::RawTransactionInsert;
|
|
/// Canonical raw Solana transaction persisted row contract.
|
|
pub use self::contracts::RawTransactionRow;
|
|
/// Raw transaction storage behavior.
|
|
pub use self::contracts::RawTransactionStore;
|
|
/// Bounded read-only filter for Core entity summaries.
|
|
pub use self::contracts::ReplayEntityFilter;
|
|
/// Core entity kind used while filtering replay candidates.
|
|
pub use self::contracts::ReplayEntityKind;
|
|
/// Aggregated mint, owner, or account-key occurrences from Core facts.
|
|
pub use self::contracts::ReplayEntitySummary;
|
|
/// Bounded read-only filter for program summaries.
|
|
pub use self::contracts::ReplayProgramFilter;
|
|
/// Program occurrence scope used while filtering replay candidates.
|
|
pub use self::contracts::ReplayProgramScope;
|
|
/// Aggregated program occurrences across top-level instructions, inner instructions, and logs.
|
|
pub use self::contracts::ReplayProgramSummary;
|
|
/// One raw transaction candidate enriched with Core and processing diagnostics.
|
|
pub use self::contracts::ReplayTransactionCandidate;
|
|
/// Bounded read-only filter for transaction replay candidates.
|
|
pub use self::contracts::ReplayTransactionFilter;
|
|
/// Sort direction for repository list operations.
|
|
pub use self::contracts::SortDirection;
|
|
/// Store backend diagnostic descriptor.
|
|
pub use self::contracts::StoreBackendDescriptor;
|
|
/// Backend-neutral diagnostic snapshot.
|
|
pub use self::contracts::StoreBackendDiagnostics;
|
|
/// Store configuration summary safe for UI and logs.
|
|
pub use self::contracts::StoreConfigurationSummary;
|
|
/// Store backend health snapshot.
|
|
pub use self::contracts::StoreHealthSnapshot;
|
|
/// Store backend health status.
|
|
pub use self::contracts::StoreHealthStatus;
|
|
/// Store health storage behavior.
|
|
pub use self::contracts::StoreHealthStore;
|
|
/// Store initialization status.
|
|
pub use self::contracts::StoreInitializationStatus;
|
|
/// Initialization and model-verification summary captured while opening a store.
|
|
pub use self::contracts::StoreInitializationSummary;
|
|
/// Store migration diagnostic snapshot contract.
|
|
pub use self::contracts::StoreMigrationSnapshot;
|
|
/// Store migration status contract.
|
|
pub use self::contracts::StoreMigrationStatus;
|
|
/// Store model verification status.
|
|
pub use self::contracts::StoreModelVerificationStatus;
|
|
/// Verification summary for one logical store model.
|
|
pub use self::contracts::StoreModelVerificationSummary;
|
|
/// Count summary for one backend object category without exposing physical names.
|
|
pub use self::contracts::StoreObjectVerificationSummary;
|
|
/// Read-only diagnostics for one logical store resource.
|
|
pub use self::contracts::StoreResourceDiagnostics;
|
|
/// Read-only statistics for one logical store resource.
|
|
pub use self::contracts::StoreResourceStatistics;
|
|
/// Complete runtime summary safe for application diagnostics.
|
|
pub use self::contracts::StoreRuntimeSummary;
|
|
/// Transaction acquisition observation insert contract.
|
|
pub use self::contracts::TransactionObservationInsert;
|
|
/// Transaction acquisition observation persisted row contract.
|
|
pub use self::contracts::TransactionObservationRow;
|
|
/// Storage error helper functions.
|
|
pub use self::contracts::storage_contract_error;
|
|
/// Backend-agnostic persistent store facade.
|
|
pub use self::store::Store;
|
|
/// Backend-agnostic options used to open one persistent store.
|
|
pub use self::store::StoreOpenOptions;
|
|
/// Current normalized Core replay input contract version.
|
|
pub use ks_lib::MD_CORE_REPLAY_INPUT_CONTRACT_VERSION;
|
|
/// Decoder replay input containing one instruction plus extracted transaction context.
|
|
pub use ks_lib::MdCoreInstructionReplayInput;
|