324 lines
20 KiB
Rust
324 lines
20 KiB
Rust
// file: kb_pipeline/src/lib.rs
|
|
// version: 29
|
|
|
|
//! Pipeline orchestration primitives.
|
|
#![warn(missing_docs)]
|
|
#![deny(unreachable_pub)]
|
|
#![forbid(unsafe_code)]
|
|
|
|
mod backfill;
|
|
mod constants;
|
|
mod core_extraction;
|
|
mod decode_replay;
|
|
mod plan;
|
|
mod solana_ata_execution;
|
|
mod solana_ata_stateful;
|
|
mod solana_elgamal_registry_stateful;
|
|
mod solana_execution;
|
|
mod solana_memo_execution;
|
|
mod solana_stateful;
|
|
mod solana_token_2022_correlation;
|
|
mod solana_token_2022_crypto_preflight;
|
|
mod solana_token_2022_devnet_execution;
|
|
mod solana_token_2022_devnet_scenarios;
|
|
mod solana_token_2022_execution_orchestration;
|
|
mod solana_token_2022_preflight;
|
|
mod solana_token_2022_proof_orchestration;
|
|
mod solana_token_2022_stateful;
|
|
mod solana_token_2022_validation;
|
|
mod solana_token_execution;
|
|
mod solana_token_lifecycle;
|
|
mod solana_token_stateful;
|
|
|
|
/// Canonical tracing target for this crate.
|
|
pub(crate) use crate::constants::TRACING_TARGET;
|
|
|
|
/// Address category used by targeted history backfills.
|
|
pub use crate::backfill::BackfillAddressKind;
|
|
/// Chronological direction relative to an anchor signature.
|
|
pub use crate::backfill::BackfillDirection;
|
|
/// Application progress and cancellation observer.
|
|
pub use crate::backfill::BackfillObserver;
|
|
/// Operator-visible backfill progress event.
|
|
pub use crate::backfill::BackfillProgressEvent;
|
|
/// Backfill progress severity.
|
|
pub use crate::backfill::BackfillProgressLevel;
|
|
/// Complete bounded backfill request.
|
|
pub use crate::backfill::BackfillRequest;
|
|
/// Candidate source used by one campaign.
|
|
pub use crate::backfill::BackfillSource;
|
|
/// Final backfill counters and pagination information.
|
|
pub use crate::backfill::BackfillSummary;
|
|
/// Executes one bounded HTTP backfill.
|
|
pub use crate::backfill::execute_http_backfill;
|
|
/// Stable canonical to core processor name.
|
|
pub use crate::core_extraction::CORE_EXTRACTION_PROCESSOR_NAME;
|
|
/// Current canonical to core extractor version.
|
|
pub use crate::core_extraction::CORE_EXTRACTION_PROCESSOR_VERSION;
|
|
/// Stable canonical to core processing stage.
|
|
pub use crate::core_extraction::CORE_EXTRACTION_STAGE;
|
|
/// Core extraction progress and cancellation observer.
|
|
pub use crate::core_extraction::CoreExtractionObserver;
|
|
/// Operator-visible core extraction progress event.
|
|
pub use crate::core_extraction::CoreExtractionProgressEvent;
|
|
/// Core extraction progress severity.
|
|
pub use crate::core_extraction::CoreExtractionProgressLevel;
|
|
/// Complete bounded core extraction request.
|
|
pub use crate::core_extraction::CoreExtractionRequest;
|
|
/// Core extraction source selection.
|
|
pub use crate::core_extraction::CoreExtractionSource;
|
|
/// Final core extraction counters.
|
|
pub use crate::core_extraction::CoreExtractionSummary;
|
|
/// Executes one bounded canonical transaction to core extraction campaign.
|
|
pub use crate::core_extraction::execute_core_extraction;
|
|
/// Extracts one canonical raw transaction into a complete core write bundle.
|
|
pub use crate::core_extraction::extract_raw_transaction_to_core;
|
|
/// Current common decode pipeline orchestration version.
|
|
pub use crate::decode_replay::DECODE_PIPELINE_VERSION;
|
|
/// Deterministic policy used when several decoders recognize one input.
|
|
pub use crate::decode_replay::DecodeDispatchPolicy;
|
|
/// Aggregated terminal counters for one decoder version.
|
|
pub use crate::decode_replay::DecodeProcessorSummary;
|
|
/// Progress and cooperative cancellation contract implemented by applications.
|
|
pub use crate::decode_replay::DecodeReplayObserver;
|
|
/// One operator-visible decode replay progress event.
|
|
pub use crate::decode_replay::DecodeReplayProgressEvent;
|
|
/// Decode replay progress severity.
|
|
pub use crate::decode_replay::DecodeReplayProgressLevel;
|
|
/// Complete bounded contextual decode replay request.
|
|
pub use crate::decode_replay::DecodeReplayRequest;
|
|
/// Final counters for one bounded contextual decode replay campaign.
|
|
pub use crate::decode_replay::DecodeReplaySummary;
|
|
/// Stable processing ledger stage used by decoded event materializers.
|
|
pub use crate::decode_replay::EVENT_MATERIALIZATION_STAGE;
|
|
/// Stable processing ledger stage used by contextual instruction decoders.
|
|
pub use crate::decode_replay::INSTRUCTION_DECODE_STAGE;
|
|
/// Executes one bounded contextual instruction decode and optional materialization campaign.
|
|
pub use crate::decode_replay::execute_decode_replay;
|
|
/// Creates one stable process-local contextual decode campaign identifier.
|
|
pub use crate::decode_replay::new_decode_campaign_id;
|
|
/// Pipeline stage identifier.
|
|
pub use crate::plan::PipelineStage;
|
|
/// Replay selection scope.
|
|
pub use crate::plan::ReplayScope;
|
|
/// Complete request for one Devnet ATA execution.
|
|
pub use crate::solana_ata_execution::DevnetSplAssociatedTokenAccountExecutionRequest;
|
|
/// Complete result of one Devnet ATA execution.
|
|
pub use crate::solana_ata_execution::DevnetSplAssociatedTokenAccountExecutionSummary;
|
|
/// Executes one Devnet ATA simulation or explicitly authorized submission.
|
|
pub use crate::solana_ata_execution::execute_devnet_spl_associated_token_account;
|
|
/// Simulates one Devnet ATA operation after stateful preflight.
|
|
pub use crate::solana_ata_execution::simulate_devnet_spl_associated_token_account;
|
|
/// Stateful ATA invariants observed after a confirmed execution.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountPostExecutionReport;
|
|
/// One ATA stateful readiness check.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountStatefulCheck;
|
|
/// One ATA stateful readiness fact.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountStatefulFact;
|
|
/// Complete ATA stateful readiness report.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountStatefulReadinessReport;
|
|
/// Complete ATA stateful readiness request.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountStatefulReadinessRequest;
|
|
/// ATA stateful readiness outcome.
|
|
pub use crate::solana_ata_stateful::SplAssociatedTokenAccountStatefulReadinessStatus;
|
|
/// Verifies final ATA account relationships after a confirmed execution.
|
|
pub use crate::solana_ata_stateful::inspect_spl_associated_token_account_post_execution;
|
|
/// Inspects Localnet or Devnet ATA state required before simulation.
|
|
pub use crate::solana_ata_stateful::inspect_spl_associated_token_account_stateful_readiness;
|
|
/// Exact byte length of one SPL ElGamal registry account.
|
|
pub use crate::solana_elgamal_registry_stateful::ELGAMAL_REGISTRY_STATEFUL_ACCOUNT_BYTES;
|
|
/// One bounded SPL ElGamal registry RPC read request.
|
|
pub use crate::solana_elgamal_registry_stateful::ElGamalRegistryStatefulReadRequest;
|
|
/// One bounded registry RPC read and validated administrative projection.
|
|
pub use crate::solana_elgamal_registry_stateful::ElGamalRegistryStatefulReadResult;
|
|
/// One contextually validated SPL ElGamal registry state snapshot.
|
|
pub use crate::solana_elgamal_registry_stateful::ElGamalRegistryStatefulSnapshot;
|
|
/// Validates one complete RPC registry response before parsing and routing.
|
|
pub use crate::solana_elgamal_registry_stateful::materialize_elgamal_registry_account_info_result;
|
|
/// Parses, validates the official owner-derived PDA, and materializes one registry snapshot.
|
|
pub use crate::solana_elgamal_registry_stateful::materialize_elgamal_registry_stateful_snapshot;
|
|
/// Reads, validates, and routes one exact SPL ElGamal registry account.
|
|
pub use crate::solana_elgamal_registry_stateful::read_elgamal_registry_stateful_snapshot;
|
|
/// Complete request for one bounded Devnet System transfer.
|
|
pub use crate::solana_execution::DevnetSystemTransferRequest;
|
|
/// Complete result of one Devnet System transfer and post-validation.
|
|
pub use crate::solana_execution::DevnetSystemTransferSummary;
|
|
/// No-op observer for execution orchestration.
|
|
pub use crate::solana_execution::NoopSolanaExecutionObserver;
|
|
/// Composite execution, backfill, extraction and decode observer.
|
|
pub use crate::solana_execution::SolanaExecutionObserver;
|
|
/// One operator-visible execution progress event.
|
|
pub use crate::solana_execution::SolanaExecutionProgressEvent;
|
|
/// Execution progress severity.
|
|
pub use crate::solana_execution::SolanaExecutionProgressLevel;
|
|
/// Executes one bounded Devnet System transfer and canonical replay validation.
|
|
pub use crate::solana_execution::execute_devnet_system_transfer;
|
|
/// Complete request for one SPL Memo v4 Devnet execution.
|
|
pub use crate::solana_memo_execution::DevnetMemoExecutionRequest;
|
|
/// Complete result of one SPL Memo v4 Devnet execution and post-validation.
|
|
pub use crate::solana_memo_execution::DevnetMemoExecutionSummary;
|
|
/// Executes one SPL Memo v4 Devnet simulation or explicitly authorized submission.
|
|
pub use crate::solana_memo_execution::execute_devnet_memo;
|
|
/// One machine-readable stateful readiness check.
|
|
pub use crate::solana_stateful::SolanaCoreStatefulCheck;
|
|
/// One contextual fact measured during stateful readiness inspection.
|
|
pub use crate::solana_stateful::SolanaCoreStatefulFact;
|
|
/// Complete stateful readiness report produced before simulation.
|
|
pub use crate::solana_stateful::SolanaCoreStatefulReadinessReport;
|
|
/// Complete request for one native Solana stateful readiness inspection.
|
|
pub use crate::solana_stateful::SolanaCoreStatefulReadinessRequest;
|
|
/// Stateful readiness outcome for one native Solana operation.
|
|
pub use crate::solana_stateful::SolanaCoreStatefulReadinessStatus;
|
|
/// Inspects Localnet or Devnet state required before simulation.
|
|
pub use crate::solana_stateful::inspect_solana_core_stateful_readiness;
|
|
/// Correlation outcome between one committed instruction fact and one final state snapshot.
|
|
pub use crate::solana_token_2022_correlation::Token2022CorrelationStatus;
|
|
/// Deterministic correlation report for one instruction output and one final snapshot.
|
|
pub use crate::solana_token_2022_correlation::Token2022StateCorrelationReport;
|
|
/// Correlates one materialized instruction fact with one authoritative Token-2022 snapshot.
|
|
pub use crate::solana_token_2022_correlation::correlate_token_2022_instruction_with_snapshot;
|
|
/// Maximum proof context-state accounts accepted by one Token-2022 cryptographic preflight.
|
|
pub use crate::solana_token_2022_crypto_preflight::MAX_TOKEN_2022_PROOF_CONTEXTS;
|
|
/// Complete Token-2022 cryptographic preflight report.
|
|
pub use crate::solana_token_2022_crypto_preflight::Token2022CryptographicPreflightReport;
|
|
/// One bounded Token-2022 cryptographic preflight request.
|
|
pub use crate::solana_token_2022_crypto_preflight::Token2022CryptographicPreflightRequest;
|
|
/// One validated proof context-state result.
|
|
pub use crate::solana_token_2022_crypto_preflight::Token2022ProofContextReport;
|
|
/// One exact pre-verified proof context-state requirement.
|
|
pub use crate::solana_token_2022_crypto_preflight::Token2022ProofContextRequirement;
|
|
/// Generic metadata bytes retained by every ZK proof context-state account.
|
|
pub use crate::solana_token_2022_crypto_preflight::ZK_PROOF_CONTEXT_META_BYTES;
|
|
/// Reads and validates pre-verified proof context-state accounts before simulation.
|
|
pub use crate::solana_token_2022_crypto_preflight::inspect_token_2022_cryptographic_preflight;
|
|
/// Complete request for one public Devnet Token-2022 execution.
|
|
pub use crate::solana_token_2022_devnet_execution::DevnetSplToken2022ExecutionRequest;
|
|
/// Complete result of one public Devnet Token-2022 execution.
|
|
pub use crate::solana_token_2022_devnet_execution::DevnetSplToken2022ExecutionSummary;
|
|
/// Executes one public Devnet Token-2022 simulation or authorized submission.
|
|
pub use crate::solana_token_2022_devnet_execution::execute_devnet_spl_token_2022;
|
|
/// Simulates one public Devnet Token-2022 operation.
|
|
pub use crate::solana_token_2022_devnet_execution::simulate_devnet_spl_token_2022;
|
|
/// Stable family of one Devnet SPL validation scenario.
|
|
pub use crate::solana_token_2022_devnet_scenarios::DevnetSplValidationFamily;
|
|
/// Current implementation status of one Devnet SPL validation scenario.
|
|
pub use crate::solana_token_2022_devnet_scenarios::DevnetSplValidationImplementationStatus;
|
|
/// One independent Devnet validation scenario required by milestone 0.4.6.
|
|
pub use crate::solana_token_2022_devnet_scenarios::DevnetSplValidationScenario;
|
|
/// Returns the ordered Devnet SPL scenario inventory required by milestone 0.4.6.
|
|
pub use crate::solana_token_2022_devnet_scenarios::devnet_spl_validation_scenarios;
|
|
/// Maximum distinct signers accepted by one Token-2022 execution envelope.
|
|
pub use crate::solana_token_2022_execution_orchestration::MAX_TOKEN_2022_EXECUTION_SIGNERS;
|
|
/// One explicit stateful postcondition retained after confirmation.
|
|
pub use crate::solana_token_2022_execution_orchestration::Token2022ExecutionPostcondition;
|
|
/// Explicit result of one Token-2022 stateful postcondition.
|
|
pub use crate::solana_token_2022_execution_orchestration::Token2022ExecutionPostconditionStatus;
|
|
/// Deterministic report authorizing or refusing Token-2022 signing and submission.
|
|
pub use crate::solana_token_2022_execution_orchestration::Token2022ExecutionReadinessReport;
|
|
/// Complete request checked before Token-2022 transaction signing.
|
|
pub use crate::solana_token_2022_execution_orchestration::Token2022ExecutionReadinessRequest;
|
|
/// Aggregates explicit postconditions without inventing success.
|
|
pub use crate::solana_token_2022_execution_orchestration::summarize_token_2022_postconditions;
|
|
/// Validates exact-message simulation, preflights, signers, and submission policy.
|
|
pub use crate::solana_token_2022_execution_orchestration::validate_token_2022_execution_readiness;
|
|
/// Maximum distinct Token-2022 accounts accepted by one preflight inspection.
|
|
pub use crate::solana_token_2022_preflight::MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS;
|
|
/// Maximum aggregate account-data budget accepted by one preflight inspection.
|
|
pub use crate::solana_token_2022_preflight::MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES;
|
|
/// One validated account result in a Token-2022 preflight report.
|
|
pub use crate::solana_token_2022_preflight::Token2022PreflightAccountReport;
|
|
/// Complete bounded Token-2022 stateful preflight report.
|
|
pub use crate::solana_token_2022_preflight::Token2022PreflightReport;
|
|
/// One bounded Token-2022 preflight request.
|
|
pub use crate::solana_token_2022_preflight::Token2022PreflightRequest;
|
|
/// One exact Token-2022 account requirement for a stateful preflight.
|
|
pub use crate::solana_token_2022_preflight::Token2022PreflightRequirement;
|
|
/// Inspects all bounded Token-2022 state required before simulation.
|
|
pub use crate::solana_token_2022_preflight::inspect_token_2022_preflight;
|
|
/// Maximum proof references accepted by one confidential Token-2022 operation.
|
|
pub use crate::solana_token_2022_proof_orchestration::MAX_TOKEN_2022_OPERATION_PROOFS;
|
|
/// One deterministic mixed-proof orchestration report.
|
|
pub use crate::solana_token_2022_proof_orchestration::Token2022ProofOrchestrationReport;
|
|
/// One bounded mixed-proof orchestration request.
|
|
pub use crate::solana_token_2022_proof_orchestration::Token2022ProofOrchestrationRequest;
|
|
/// Validates mixed inline/context-state proofs before transaction assembly.
|
|
pub use crate::solana_token_2022_proof_orchestration::orchestrate_token_2022_proofs;
|
|
/// Maximum complete Token-2022 account data accepted by one bounded RPC read.
|
|
pub use crate::solana_token_2022_stateful::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES;
|
|
/// Optional external identities required to validate cross-account Token-2022 state.
|
|
pub use crate::solana_token_2022_stateful::Token2022StatefulContext;
|
|
/// One bounded Token-2022 account read request.
|
|
pub use crate::solana_token_2022_stateful::Token2022StatefulReadRequest;
|
|
/// One bounded RPC read and its contextually validated projections.
|
|
pub use crate::solana_token_2022_stateful::Token2022StatefulReadResult;
|
|
/// One contextually validated Token-2022 state snapshot and its owned projections.
|
|
pub use crate::solana_token_2022_stateful::Token2022StatefulSnapshotBundle;
|
|
/// Contextually validates and materializes one already parsed Token-2022 account snapshot.
|
|
pub use crate::solana_token_2022_stateful::materialize_parsed_token_2022_stateful_snapshot;
|
|
/// Contextually validates one parsed Token-2022 snapshot with external cross-account identities.
|
|
pub use crate::solana_token_2022_stateful::materialize_parsed_token_2022_stateful_snapshot_with_context;
|
|
/// Validates one complete RPC account response before Token-2022 parsing and routing.
|
|
pub use crate::solana_token_2022_stateful::materialize_token_2022_account_info_result;
|
|
/// Parses, contextually validates, and materializes one bounded Token-2022 account snapshot.
|
|
pub use crate::solana_token_2022_stateful::materialize_token_2022_stateful_snapshot;
|
|
/// Reads, validates, parses, and routes one bounded Token-2022 account snapshot.
|
|
pub use crate::solana_token_2022_stateful::read_token_2022_stateful_snapshot;
|
|
/// Maximum evidence records retained per Token-2022 validation scenario.
|
|
pub use crate::solana_token_2022_validation::MAX_TOKEN_2022_VALIDATION_EVIDENCE;
|
|
/// Required environment for one Token-2022 validation scenario.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationEnvironment;
|
|
/// One bounded validation evidence record.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationEvidence;
|
|
/// Canonical machine-readable Token-2022 validation matrix.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationMatrix;
|
|
/// One scenario declared in the canonical Token-2022 validation matrix.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationMatrixScenario;
|
|
/// Complete Token-2022 milestone validation report.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationReport;
|
|
/// One declared Token-2022 validation scenario.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationScenario;
|
|
/// Exact observed status of one Token-2022 validation scenario.
|
|
pub use crate::solana_token_2022_validation::Token2022ValidationStatus;
|
|
/// Loads and validates the canonical Token-2022 validation matrix.
|
|
pub use crate::solana_token_2022_validation::load_token_2022_validation_matrix;
|
|
/// Validates the canonical Token-2022 validation matrix contract and evidence.
|
|
pub use crate::solana_token_2022_validation::validate_token_2022_validation_matrix;
|
|
/// Validates a bounded Token-2022 milestone evidence report.
|
|
pub use crate::solana_token_2022_validation::validate_token_2022_validation_report;
|
|
/// Complete request for one Devnet classic SPL Token execution.
|
|
pub use crate::solana_token_execution::DevnetSplTokenExecutionRequest;
|
|
/// Complete result of one Devnet classic SPL Token execution.
|
|
pub use crate::solana_token_execution::DevnetSplTokenExecutionSummary;
|
|
/// Executes one Devnet classic SPL Token simulation or authorized submission.
|
|
pub use crate::solana_token_execution::execute_devnet_spl_token;
|
|
/// Simulates one Devnet classic SPL Token operation after stateful preflight.
|
|
pub use crate::solana_token_execution::simulate_devnet_spl_token;
|
|
/// Explicit request to prepare fresh raw accounts for one SPL Token Devnet lifecycle.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecyclePreparationRequest;
|
|
/// One confirmed raw account creation retained by lifecycle preparation.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecyclePreparationStep;
|
|
/// Complete fresh-account preparation result for one SPL Token Devnet lifecycle.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecyclePreparationSummary;
|
|
/// Request for one destructive, explicitly authorized SPL Token Devnet lifecycle.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecycleRequest;
|
|
/// Result retained for one fully post-validated lifecycle transaction.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecycleStepSummary;
|
|
/// Complete result of the controlled SPL Token Devnet lifecycle.
|
|
pub use crate::solana_token_lifecycle::DevnetSplTokenLifecycleSummary;
|
|
/// Executes initialize, mint, transfer, approve/revoke, burn and close on Devnet.
|
|
pub use crate::solana_token_lifecycle::execute_devnet_spl_token_lifecycle;
|
|
/// Creates and verifies fresh raw Token-owned accounts for one Devnet lifecycle.
|
|
pub use crate::solana_token_lifecycle::prepare_devnet_spl_token_lifecycle_accounts;
|
|
/// One machine-readable classic SPL Token stateful check.
|
|
pub use crate::solana_token_stateful::SplTokenStatefulCheck;
|
|
/// One contextual fact measured during classic SPL Token state inspection.
|
|
pub use crate::solana_token_stateful::SplTokenStatefulFact;
|
|
/// Complete classic SPL Token stateful readiness report.
|
|
pub use crate::solana_token_stateful::SplTokenStatefulReadinessReport;
|
|
/// Complete request for one classic SPL Token stateful readiness inspection.
|
|
pub use crate::solana_token_stateful::SplTokenStatefulReadinessRequest;
|
|
/// Stateful readiness outcome for one classic SPL Token operation.
|
|
pub use crate::solana_token_stateful::SplTokenStatefulReadinessStatus;
|
|
/// Inspects Localnet or Devnet Token state before simulation.
|
|
pub use crate::solana_token_stateful::inspect_spl_token_stateful_readiness;
|