117 lines
8.6 KiB
Rust
117 lines
8.6 KiB
Rust
// file: crates/ksp-worker-raw-transaction-ingest-lib/src/lib.rs
|
|
// version: 20
|
|
|
|
#![warn(missing_docs)]
|
|
#![deny(unreachable_pub)]
|
|
#![forbid(unsafe_code)]
|
|
|
|
//! Source-neutral runtime foundation for continuous KSP RAW transaction ingestion.
|
|
//!
|
|
//! This tranche owns the concrete Worker family identity, validated technical settings
|
|
//! and the caller-runtime-owned lifecycle with private child-task supervision. This tranche also
|
|
//! owns bounded source-neutral admission, common RAW canonicalization/assembly and backend-neutral
|
|
//! Store persistence in normal mode plus concrete latest-value snapshots projected onto Worker API. `pre.003` keeps the bounded 1..32 caller-composed
|
|
//! aggregate and adds a productive standard Solana `logsSubscribe` + observed HTTP `getTransaction` source beside Yellowstone while simultaneous multi-source
|
|
//! activation remains gated until the dedicated supervisor tranche. Both live source families converge into one source-neutral hydration coordinator contract and
|
|
//! the existing central admission path. Yellowstone Transaction/TransactionStatus/Block and standard logs notifications become signature/slot references;
|
|
//! BlockMeta/Slot remain continuity-only signals. Hydration is coalesced by network/signature/commitment under bounded in-flight and pending budgets. A bounded run-local processing frontier projects hydration pending,
|
|
//! oldest pending slot and highest unblocked actually observed slot. The productive source now also projects safe Transport reconnect/replay state and faults
|
|
//! conservatively when Transport proves a replay-retention continuity gap; history remediation remains outside this crate.
|
|
|
|
mod admission;
|
|
mod error;
|
|
mod identity;
|
|
mod persistence;
|
|
mod runtime;
|
|
mod runtime_resources;
|
|
mod settings;
|
|
mod snapshot;
|
|
|
|
/// Error code used when durable Store content conflicts with one admitted canonical RAW transaction.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT;
|
|
/// Error code used when one monotone Worker counter or snapshot sequence cannot advance without wrapping.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED;
|
|
/// Error code used when private Worker tasks cannot drain before the configured shutdown deadline.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT;
|
|
/// Error code used when the RAW transaction ingest Worker reaches an invalid runtime or lifecycle condition.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_RUNTIME_INVALID;
|
|
/// Error code used when RAW transaction ingest Worker settings violate one bounded runtime invariant.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID;
|
|
/// Error code used when one private source task terminates with a classified failure.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED;
|
|
/// Error code used when Store persistence fails for one admitted canonical RAW transaction.
|
|
pub use self::error::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED;
|
|
/// Stable Worker kind code used by the continuous RAW transaction ingest vertical.
|
|
pub use self::identity::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE;
|
|
/// Cloneable external control handle for one continuous RAW transaction ingest Worker.
|
|
pub use self::runtime::RawTransactionIngestHandle;
|
|
/// Runtime-neutral boxed future resolving after one RAW transaction ingest Worker has fully reached a terminal lifecycle state.
|
|
pub use self::runtime::RawTransactionIngestTerminalFuture;
|
|
/// Entry point owning synchronous validation and task launch for one RAW transaction ingest Worker run.
|
|
pub use self::runtime::RawTransactionIngestWorker;
|
|
/// Maximum number of logical live sources accepted by one runtime-resource aggregate.
|
|
pub use self::runtime_resources::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES;
|
|
/// Caller-composed bounded runtime resources for supported continuous RAW transaction live-source families.
|
|
pub use self::runtime_resources::RawTransactionIngestRuntimeResources;
|
|
/// Validated standard Solana `logsSubscribe` + HTTP hydration source contract owned by the continuous RAW transaction ingest Worker.
|
|
pub use self::runtime_resources::RawTransactionIngestStandardLogsSource;
|
|
/// Validated Yellowstone + HTTP source contract owned by the continuous RAW transaction ingest Worker.
|
|
pub use self::runtime_resources::RawTransactionIngestYellowstoneSource;
|
|
/// Default bounded admission queue capacity for one RAW transaction ingest Worker.
|
|
pub use self::settings::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY;
|
|
/// Default number of concurrent Store persistence operations for one RAW transaction ingest Worker.
|
|
pub use self::settings::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY;
|
|
/// Default cooperative shutdown drain deadline for one RAW transaction ingest Worker.
|
|
pub use self::settings::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT;
|
|
/// Maximum bounded admission queue capacity for one RAW transaction ingest Worker.
|
|
pub use self::settings::MAX_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY;
|
|
/// Maximum number of concurrent Store persistence operations for one RAW transaction ingest Worker.
|
|
pub use self::settings::MAX_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY;
|
|
/// Maximum cooperative shutdown drain deadline for one RAW transaction ingest Worker.
|
|
pub use self::settings::MAX_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT;
|
|
/// Minimum bounded admission queue capacity for one RAW transaction ingest Worker.
|
|
pub use self::settings::MIN_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY;
|
|
/// Minimum number of concurrent Store persistence operations for one RAW transaction ingest Worker.
|
|
pub use self::settings::MIN_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY;
|
|
/// Minimum cooperative shutdown drain deadline for one RAW transaction ingest Worker.
|
|
pub use self::settings::MIN_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT;
|
|
/// Validated source-neutral runtime settings for one continuous RAW transaction ingest Worker.
|
|
pub use self::settings::RawTransactionIngestSettings;
|
|
/// Complete safe latest-value snapshot of one continuous RAW transaction ingest Worker.
|
|
pub use self::snapshot::RawTransactionIngestSnapshot;
|
|
/// Runtime-neutral boxed future resolving to one newer concrete RAW transaction ingest Worker snapshot.
|
|
pub use self::snapshot::RawTransactionIngestSnapshotFuture;
|
|
/// Cloneable latest-value source exposing concrete and common Worker snapshots from one shared watch state.
|
|
pub use self::snapshot::RawTransactionIngestSnapshotSource;
|
|
/// Source-neutral lifecycle state of the productive RAW transaction ingest source.
|
|
pub use self::snapshot::RawTransactionIngestSourceState;
|
|
|
|
/// Receiver-side owner of the private bounded RAW transaction admission queue.
|
|
pub(crate) use self::admission::RawTransactionAdmission;
|
|
/// Crate-private source-neutral ingress sent through the bounded central admission queue.
|
|
pub(crate) use self::admission::RawTransactionIngress;
|
|
/// Creates one terminal content-conflict error without copying conflicting material into diagnostics.
|
|
pub(crate) use self::error::content_conflict_error;
|
|
/// Creates one terminal counter-exhaustion error without exposing runtime material.
|
|
pub(crate) use self::error::counter_exhausted_error;
|
|
/// Creates one runtime-domain error without copying runtime/provider/Store values into diagnostics.
|
|
pub(crate) use self::error::runtime_error;
|
|
/// Creates one settings-domain error without copying caller-supplied values into diagnostics.
|
|
pub(crate) use self::error::settings_error;
|
|
/// Creates one terminal Store error while retaining only the already-safe lower-layer ErrorCode.
|
|
pub(crate) use self::error::store_error;
|
|
/// Canonical entity disposition produced by one successful Worker Store persistence attempt.
|
|
pub(crate) use self::persistence::RawTransactionIngestEntityPersistence;
|
|
/// Observation disposition produced by one successful Worker Store persistence attempt.
|
|
pub(crate) use self::persistence::RawTransactionIngestObservationPersistence;
|
|
/// Classified successful outcome of one atomic Worker Store persistence attempt.
|
|
pub(crate) use self::persistence::RawTransactionIngestPersistenceOutcome;
|
|
/// Private backend-neutral Store persistence port used by the Worker and deterministic tests.
|
|
pub(crate) use self::persistence::RawTransactionIngestPersistencePort;
|
|
/// Persists one already-canonical Worker acquisition through the private Store port in `Normal` mode.
|
|
pub(crate) use self::persistence::persist_raw_transaction_ingest_acquisition;
|
|
/// Private latest-value processing-frontier projection emitted by the productive source task.
|
|
pub(crate) use self::snapshot::RawTransactionIngestProcessingFrontierProjection;
|
|
/// Private latest-value publisher and checked counter owner shared by the Worker supervisor.
|
|
pub(crate) use self::snapshot::RawTransactionIngestSnapshotPublisher;
|