Sasedev/khadhroony-bot3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.1.0-pre.061

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-07-28 18:41:30 +02:00
parent c7bad46f50
commit f40fb78817
527 changed files with 4598 additions and 4114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
kb-pipeline/src/core_extraction.rs
View File

@@ -221,11 +221,11 @@ pub struct CoreExtractionSummary {
pub extracted: u64,
/// Number failing extraction or persistence.
pub failed: u64,
/// Number admitted but cancelled before a terminal result.
/// Number admitted but canceled before a terminal result.
pub cancelled_candidates: u64,
/// Number never admitted after cancellation.
pub not_started: u64,
/// Whether the campaign was cancelled.
/// Whether the campaign was canceled.
pub cancelled: bool,
/// Campaign start timestamp.
pub started_at: std::string::String,

57
kb-pipeline/src/decode_replay.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/decode_replay.rs
// version: 1
// version: 2
//! Common contextual instruction decode and optional materialization pipeline.
@@ -168,8 +168,10 @@ pub struct DecodeProcessorSummary {
pub ignored: u64,
/// Number recognized but unsupported.
pub unsupported: u64,
/// Number failing decode, validation or persistence.
/// Number returning an explicit decoder failure outcome.
pub failed: u64,
/// Number interrupted by orchestration, storage or other processing errors.
pub processing_errors: u64,
/// Number of materialized outputs committed.
pub materialized_outputs: u64,
/// Number of materializer policy refusals committed to the ledger.
@@ -193,8 +195,10 @@ pub struct DecodeReplaySummary {
pub unmatched: u64,
/// Number never decoded because cancellation was already requested.
pub not_started: u64,
/// Number of input-level failures.
/// Number of inputs returning an explicit decoder failure outcome.
pub failed_inputs: u64,
/// Number of inputs interrupted by orchestration, storage or other processing errors.
pub processing_error_inputs: u64,
/// Whether cooperative cancellation was observed.
pub cancelled: bool,
/// Per-decoder counters ordered by name and version.
@@ -213,7 +217,8 @@ struct DecodeItemOutcome {
program_id: std::string::String,
started: bool,
unmatched: bool,
failed: bool,
decode_failed: bool,
processing_error: bool,
cancelled: bool,
processors: std::vec::Vec<crate::DecodeProcessorSummary>,
}
@@ -455,7 +460,7 @@ where
let mut settled = 0_u64;
while let std::option::Option::Some(outcome) = stream.next().await {
settled += 1;
let level = if outcome.failed {
let level = if outcome.decode_failed || outcome.processing_error {
crate::DecodeReplayProgressLevel::Error
} else if outcome.cancelled {
crate::DecodeReplayProgressLevel::Warning
@@ -465,13 +470,14 @@ where
observer.on_progress(&crate::DecodeReplayProgressEvent::new(
level,
format!(
"decode replay input terminal signature={} slot={} instruction_path={} program_id={} unmatched={} failed={} cancelled={} processors={:?}",
"decode replay input terminal signature={} slot={} instruction_path={} program_id={} unmatched={} decode_failed={} processing_error={} cancelled={} processors={:?}",
outcome.signature,
outcome.slot,
outcome.instruction_path,
outcome.program_id,
outcome.unmatched,
outcome.failed,
outcome.decode_failed,
outcome.processing_error,
outcome.cancelled,
outcome.processors
),
@@ -489,6 +495,7 @@ where
unmatched: 0,
not_started: 0,
failed_inputs: 0,
processing_error_inputs: 0,
cancelled: observer.is_cancelled(),
processors: std::vec::Vec::new(),
started_at,
@@ -502,9 +509,12 @@ where
if outcome.unmatched {
summary.unmatched += 1;
}
if outcome.failed {
if outcome.decode_failed {
summary.failed_inputs += 1;
}
if outcome.processing_error {
summary.processing_error_inputs += 1;
}
if outcome.cancelled && !outcome.started {
summary.not_started += 1;
}
@@ -518,12 +528,12 @@ where
.cmp(&right.processor_name)
.then(left.processor_version.cmp(&right.processor_version));
});
if summary.unmatched > 0 || summary.failed_inputs > 0 {
tracing::error!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay completed with failures");
if summary.unmatched > 0 || summary.failed_inputs > 0 || summary.processing_error_inputs > 0 {
tracing::error!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, processing_error_inputs = summary.processing_error_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay completed with failures");
} else if summary.cancelled {
tracing::warn!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay cancelled");
tracing::warn!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, processing_error_inputs = summary.processing_error_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay cancelled");
} else {
tracing::info!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay completed");
tracing::info!(target: crate::TRACING_TARGET, action = "execute_campaign", campaign_id = %summary.campaign_id, selected = summary.selected, started = summary.started, completed = summary.completed, unmatched = summary.unmatched, not_started = summary.not_started, failed_inputs = summary.failed_inputs, processing_error_inputs = summary.processing_error_inputs, cancelled = summary.cancelled, processors = ?summary.processors, started_at = %summary.started_at, finished_at = %summary.finished_at, "contextual decode replay completed");
}
return std::result::Result::Ok(summary);
}
@@ -551,7 +561,8 @@ where
program_id: input.program_id.clone(),
started: false,
unmatched: false,
failed: false,
decode_failed: false,
processing_error: false,
cancelled: true,
processors: std::vec::Vec::new(),
};
@@ -566,7 +577,8 @@ where
program_id: input.program_id.clone(),
started: true,
unmatched: true,
failed: false,
decode_failed: false,
processing_error: false,
cancelled: false,
processors: std::vec::Vec::new(),
};
@@ -583,7 +595,8 @@ where
.collect::<std::vec::Vec<_>>();
tracing::debug!(target: crate::TRACING_TARGET, action = "dispatch_input", campaign_id = %campaign_id, signature = %input.signature, slot = input.slot, instruction_path = %input.instruction_path, program_id = %input.program_id, dispatch_policy = ?request.dispatch_policy, selected_decoders = ?selected_decoder_identities, "dispatch contextual decode replay input");
let mut processors = std::vec::Vec::new();
let mut failed = false;
let mut decode_failed = false;
let mut processing_error = false;
for ranked_decoder in selected {
if observer.is_cancelled() {
break;
@@ -607,12 +620,12 @@ where
std::result::Result::Ok(value) => {
tracing::debug!(target: crate::TRACING_TARGET, action = "invoke_decoder", campaign_id = %campaign_id, signature = %input.signature, instruction_path = %input.instruction_path, program_id = %input.program_id, processor_name = %value.processor_name, processor_version = %value.processor_version, summary = ?value, "contextual instruction decoder completed");
if value.failed > 0 {
failed = true;
decode_failed = true;
}
processors.push(value);
},
std::result::Result::Err(error) => {
failed = true;
processing_error = true;
processors.push(crate::DecodeProcessorSummary {
processor_name: ranked_decoder.identity.name.clone(),
processor_version: ranked_decoder.identity.version.clone(),
@@ -621,7 +634,8 @@ where
decoded: 0,
ignored: 0,
unsupported: 0,
failed: 1,
failed: 0,
processing_errors: 1,
materialized_outputs: 0,
materialization_refused: 0,
});
@@ -642,7 +656,7 @@ where
}
}
let cancelled = observer.is_cancelled();
tracing::debug!(target: crate::TRACING_TARGET, action = "complete_input", campaign_id = %campaign_id, signature = %input.signature, slot = input.slot, instruction_path = %input.instruction_path, program_id = %input.program_id, failed, cancelled, processors = ?processors, "contextual decode replay input completed");
tracing::debug!(target: crate::TRACING_TARGET, action = "complete_input", campaign_id = %campaign_id, signature = %input.signature, slot = input.slot, instruction_path = %input.instruction_path, program_id = %input.program_id, decode_failed, processing_error, cancelled, processors = ?processors, "contextual decode replay input completed");
return DecodeItemOutcome {
signature: input.signature.clone(),
slot: input.slot,
@@ -650,7 +664,8 @@ where
program_id: input.program_id.clone(),
started: true,
unmatched: false,
failed,
decode_failed,
processing_error,
cancelled,
processors,
};
@@ -709,6 +724,7 @@ where
ignored: 0,
unsupported: 0,
failed: 0,
processing_errors: 0,
materialized_outputs: 0,
materialization_refused: 0,
};
@@ -1326,6 +1342,7 @@ fn merge_processor_summary(
summary.ignored += value.ignored;
summary.unsupported += value.unsupported;
summary.failed += value.failed;
summary.processing_errors += value.processing_errors;
summary.materialized_outputs += value.materialized_outputs;
summary.materialization_refused += value.materialization_refused;
return;

166
kb-pipeline/src/lib.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/lib.rs
// version: 16
// version: 17
#![forbid(unsafe_code)]
#![deny(unreachable_pub)]
@@ -15,12 +15,12 @@ mod plan;
mod solana_ata_stateful;
mod solana_elgamal_registry_stateful;
mod solana_stateful;
mod solana_token2022_correlation;
mod solana_token2022_crypto_preflight;
mod solana_token2022_execution_orchestration;
mod solana_token2022_preflight;
mod solana_token2022_proof_orchestration;
mod solana_token2022_stateful;
mod solana_token_2022_correlation;
mod solana_token_2022_crypto_preflight;
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_stateful;
/// Address category used by one targeted backfill campaign.
@@ -133,6 +133,82 @@ pub use self::solana_stateful::SolanaCoreStatefulReadinessRequest;
pub use self::solana_stateful::SolanaCoreStatefulReadinessStatus;
/// Inspects state required before simulating one native Solana operation.
pub use self::solana_stateful::inspect_solana_core_stateful_readiness;
/// Correlation outcome between one committed instruction fact and one final state snapshot.
pub use self::solana_token_2022_correlation::Token2022CorrelationStatus;
/// Deterministic correlation report for one instruction output and one final snapshot.
pub use self::solana_token_2022_correlation::Token2022StateCorrelationReport;
/// Correlates one materialized instruction fact with one authoritative Token-2022 snapshot.
pub use self::solana_token_2022_correlation::correlate_token_2022_instruction_with_snapshot;
/// Maximum number of distinct proof context-state accounts accepted by one preflight.
pub use self::solana_token_2022_crypto_preflight::MAX_TOKEN_2022_PROOF_CONTEXTS;
/// Token-2022 cryptographic preflight report.
pub use self::solana_token_2022_crypto_preflight::Token2022CryptographicPreflightReport;
/// Token-2022 cryptographic preflight request.
pub use self::solana_token_2022_crypto_preflight::Token2022CryptographicPreflightRequest;
/// One validated proof context report.
pub use self::solana_token_2022_crypto_preflight::Token2022ProofContextReport;
/// One required proof context-state account.
pub use self::solana_token_2022_crypto_preflight::Token2022ProofContextRequirement;
/// Encoded proof context metadata bytes.
pub use self::solana_token_2022_crypto_preflight::ZK_PROOF_CONTEXT_META_BYTES;
/// Inspects bounded Token-2022 cryptographic proof contexts.
pub use self::solana_token_2022_crypto_preflight::inspect_token_2022_cryptographic_preflight;
/// Maximum number of distinct signers accepted by one Token-2022 execution envelope.
pub use self::solana_token_2022_execution_orchestration::MAX_TOKEN_2022_EXECUTION_SIGNERS;
/// One explicit stateful postcondition retained after Token-2022 execution.
pub use self::solana_token_2022_execution_orchestration::Token2022ExecutionPostcondition;
/// Result of one stateful postcondition after Token-2022 execution.
pub use self::solana_token_2022_execution_orchestration::Token2022ExecutionPostconditionStatus;
/// Deterministic Token-2022 execution-readiness report.
pub use self::solana_token_2022_execution_orchestration::Token2022ExecutionReadinessReport;
/// Complete deterministic Token-2022 execution-readiness request.
pub use self::solana_token_2022_execution_orchestration::Token2022ExecutionReadinessRequest;
/// Aggregates Token-2022 postconditions without inventing success.
pub use self::solana_token_2022_execution_orchestration::summarize_token_2022_postconditions;
/// Validates the complete Token-2022 execution envelope before signing.
pub use self::solana_token_2022_execution_orchestration::validate_token_2022_execution_readiness;
/// Migrated MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS contract.
pub use self::solana_token_2022_preflight::MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS;
/// Migrated MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES contract.
pub use self::solana_token_2022_preflight::MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES;
/// Migrated Token2022PreflightAccountReport contract.
pub use self::solana_token_2022_preflight::Token2022PreflightAccountReport;
/// Migrated Token2022PreflightReport contract.
pub use self::solana_token_2022_preflight::Token2022PreflightReport;
/// Migrated Token2022PreflightRequest contract.
pub use self::solana_token_2022_preflight::Token2022PreflightRequest;
/// Migrated Token2022PreflightRequirement contract.
pub use self::solana_token_2022_preflight::Token2022PreflightRequirement;
/// Migrated inspect_token_2022_preflight contract.
pub use self::solana_token_2022_preflight::inspect_token_2022_preflight;
/// Maximum number of proofs accepted for one Token-2022 operation.
pub use self::solana_token_2022_proof_orchestration::MAX_TOKEN_2022_OPERATION_PROOFS;
/// Token-2022 proof orchestration report.
pub use self::solana_token_2022_proof_orchestration::Token2022ProofOrchestrationReport;
/// Token-2022 proof orchestration request.
pub use self::solana_token_2022_proof_orchestration::Token2022ProofOrchestrationRequest;
/// Validates mixed inline and context-state proof orchestration.
pub use self::solana_token_2022_proof_orchestration::orchestrate_token_2022_proofs;
/// Migrated MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES contract.
pub use self::solana_token_2022_stateful::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES;
/// Migrated Token2022StatefulContext contract.
pub use self::solana_token_2022_stateful::Token2022StatefulContext;
/// Migrated Token2022StatefulReadRequest contract.
pub use self::solana_token_2022_stateful::Token2022StatefulReadRequest;
/// Migrated Token2022StatefulReadResult contract.
pub use self::solana_token_2022_stateful::Token2022StatefulReadResult;
/// Migrated Token2022StatefulSnapshotBundle contract.
pub use self::solana_token_2022_stateful::Token2022StatefulSnapshotBundle;
/// Migrated materialize_parsed_token_2022_stateful_snapshot contract.
pub use self::solana_token_2022_stateful::materialize_parsed_token_2022_stateful_snapshot;
/// Migrated materialize_parsed_token_2022_stateful_snapshot_with_context contract.
pub use self::solana_token_2022_stateful::materialize_parsed_token_2022_stateful_snapshot_with_context;
/// Migrated materialize_token_2022_account_info_result contract.
pub use self::solana_token_2022_stateful::materialize_token_2022_account_info_result;
/// Migrated materialize_token_2022_stateful_snapshot contract.
pub use self::solana_token_2022_stateful::materialize_token_2022_stateful_snapshot;
/// Migrated read_token_2022_stateful_snapshot contract.
pub use self::solana_token_2022_stateful::read_token_2022_stateful_snapshot;
/// One machine-readable classic SPL Token stateful check.
pub use self::solana_token_stateful::SplTokenStatefulCheck;
/// One contextual classic SPL Token stateful fact.
@@ -145,82 +221,6 @@ pub use self::solana_token_stateful::SplTokenStatefulReadinessRequest;
pub use self::solana_token_stateful::SplTokenStatefulReadinessStatus;
/// Inspects Localnet or Devnet classic SPL Token state required before simulation.
pub use self::solana_token_stateful::inspect_spl_token_stateful_readiness;
/// Correlation outcome between one committed instruction fact and one final state snapshot.
pub use self::solana_token2022_correlation::Token2022CorrelationStatus;
/// Deterministic correlation report for one instruction output and one final snapshot.
pub use self::solana_token2022_correlation::Token2022StateCorrelationReport;
/// Correlates one materialized instruction fact with one authoritative Token-2022 snapshot.
pub use self::solana_token2022_correlation::correlate_token2022_instruction_with_snapshot;
/// Maximum number of distinct proof context-state accounts accepted by one preflight.
pub use self::solana_token2022_crypto_preflight::MAX_TOKEN2022_PROOF_CONTEXTS;
/// Token-2022 cryptographic preflight report.
pub use self::solana_token2022_crypto_preflight::Token2022CryptographicPreflightReport;
/// Token-2022 cryptographic preflight request.
pub use self::solana_token2022_crypto_preflight::Token2022CryptographicPreflightRequest;
/// One validated proof context report.
pub use self::solana_token2022_crypto_preflight::Token2022ProofContextReport;
/// One required proof context-state account.
pub use self::solana_token2022_crypto_preflight::Token2022ProofContextRequirement;
/// Encoded proof context metadata bytes.
pub use self::solana_token2022_crypto_preflight::ZK_PROOF_CONTEXT_META_BYTES;
/// Inspects bounded Token-2022 cryptographic proof contexts.
pub use self::solana_token2022_crypto_preflight::inspect_token2022_cryptographic_preflight;
/// Maximum number of distinct signers accepted by one Token-2022 execution envelope.
pub use self::solana_token2022_execution_orchestration::MAX_TOKEN2022_EXECUTION_SIGNERS;
/// One explicit stateful postcondition retained after Token-2022 execution.
pub use self::solana_token2022_execution_orchestration::Token2022ExecutionPostcondition;
/// Result of one stateful postcondition after Token-2022 execution.
pub use self::solana_token2022_execution_orchestration::Token2022ExecutionPostconditionStatus;
/// Deterministic Token-2022 execution-readiness report.
pub use self::solana_token2022_execution_orchestration::Token2022ExecutionReadinessReport;
/// Complete deterministic Token-2022 execution-readiness request.
pub use self::solana_token2022_execution_orchestration::Token2022ExecutionReadinessRequest;
/// Aggregates Token-2022 postconditions without inventing success.
pub use self::solana_token2022_execution_orchestration::summarize_token2022_postconditions;
/// Validates the complete Token-2022 execution envelope before signing.
pub use self::solana_token2022_execution_orchestration::validate_token2022_execution_readiness;
/// Migrated MAX_TOKEN2022_PREFLIGHT_ACCOUNTS contract.
pub use self::solana_token2022_preflight::MAX_TOKEN2022_PREFLIGHT_ACCOUNTS;
/// Migrated MAX_TOKEN2022_PREFLIGHT_TOTAL_BYTES contract.
pub use self::solana_token2022_preflight::MAX_TOKEN2022_PREFLIGHT_TOTAL_BYTES;
/// Migrated Token2022PreflightAccountReport contract.
pub use self::solana_token2022_preflight::Token2022PreflightAccountReport;
/// Migrated Token2022PreflightReport contract.
pub use self::solana_token2022_preflight::Token2022PreflightReport;
/// Migrated Token2022PreflightRequest contract.
pub use self::solana_token2022_preflight::Token2022PreflightRequest;
/// Migrated Token2022PreflightRequirement contract.
pub use self::solana_token2022_preflight::Token2022PreflightRequirement;
/// Migrated inspect_token2022_preflight contract.
pub use self::solana_token2022_preflight::inspect_token2022_preflight;
/// Maximum number of proofs accepted for one Token-2022 operation.
pub use self::solana_token2022_proof_orchestration::MAX_TOKEN2022_OPERATION_PROOFS;
/// Token-2022 proof orchestration report.
pub use self::solana_token2022_proof_orchestration::Token2022ProofOrchestrationReport;
/// Token-2022 proof orchestration request.
pub use self::solana_token2022_proof_orchestration::Token2022ProofOrchestrationRequest;
/// Validates mixed inline and context-state proof orchestration.
pub use self::solana_token2022_proof_orchestration::orchestrate_token2022_proofs;
/// Migrated MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES contract.
pub use self::solana_token2022_stateful::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES;
/// Migrated Token2022StatefulContext contract.
pub use self::solana_token2022_stateful::Token2022StatefulContext;
/// Migrated Token2022StatefulReadRequest contract.
pub use self::solana_token2022_stateful::Token2022StatefulReadRequest;
/// Migrated Token2022StatefulReadResult contract.
pub use self::solana_token2022_stateful::Token2022StatefulReadResult;
/// Migrated Token2022StatefulSnapshotBundle contract.
pub use self::solana_token2022_stateful::Token2022StatefulSnapshotBundle;
/// Migrated materialize_parsed_token2022_stateful_snapshot contract.
pub use self::solana_token2022_stateful::materialize_parsed_token2022_stateful_snapshot;
/// Migrated materialize_parsed_token2022_stateful_snapshot_with_context contract.
pub use self::solana_token2022_stateful::materialize_parsed_token2022_stateful_snapshot_with_context;
/// Migrated materialize_token2022_account_info_result contract.
pub use self::solana_token2022_stateful::materialize_token2022_account_info_result;
/// Migrated materialize_token2022_stateful_snapshot contract.
pub use self::solana_token2022_stateful::materialize_token2022_stateful_snapshot;
/// Migrated read_token2022_stateful_snapshot contract.
pub use self::solana_token2022_stateful::read_token2022_stateful_snapshot;
/// Canonical tracing target for pipeline orchestration.
pub(crate) use self::constants::TRACING_TARGET;

12
kb-pipeline/src/solana_ata_stateful.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/solana_ata_stateful.rs
// version: 2
// version: 3
//! Stateful Localnet and Devnet readiness checks for ATA operations.
@@ -1023,17 +1023,17 @@ mod tests {
},
2_100_000,
);
let ata = super::derive_ata(&wallet, &mint, kb_program_ids::SPL_TOKEN2022_PROGRAM_ID)
let ata = super::derive_ata(&wallet, &mint, kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID)
.unwrap_or_else(|error| panic!("ATA derivation failed: {error}"));
let mut cache = super::AccountCache::new();
cache.insert(
mint.0.clone(),
std::option::Option::Some(mint_account(kb_program_ids::SPL_TOKEN2022_PROGRAM_ID)),
std::option::Option::Some(mint_account(kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID)),
);
cache.insert(
ata.0,
std::option::Option::Some(token_account(
kb_program_ids::SPL_TOKEN2022_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
&mint,
&pubkey(kb_program_ids::CONFIG_PROGRAM_ID),
)),
@@ -1116,13 +1116,13 @@ mod tests {
mint: mint.clone(),
token_program: kb_lib::ExSplAssociatedTokenProgram::Token2022,
};
let ata = super::derive_ata(&wallet, &mint, kb_program_ids::SPL_TOKEN2022_PROGRAM_ID)
let ata = super::derive_ata(&wallet, &mint, kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID)
.unwrap_or_else(|error| panic!("ATA derivation failed: {error}"));
let mut cache = super::AccountCache::new();
cache.insert(
ata.0,
std::option::Option::Some(token_account(
kb_program_ids::SPL_TOKEN2022_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
&mint,
&wallet,
)),

28
kb-pipeline/src/solana_elgamal_registry_stateful.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/solana_elgamal_registry_stateful.rs
// version: 3
// version: 4
//! Contextual SPL ElGamal registry account-state validation and materialization routing.
@@ -95,12 +95,12 @@ pub fn materialize_elgamal_registry_account_info_result(
),
));
}
if account.owner.0 != kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID {
if account.owner.0 != kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID {
return std::result::Result::Err(kb_core::Error::new(
"elgamal_registry_stateful_owner_mismatch",
format!(
"SPL ElGamal registry owner must be {}, got {}",
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
account.owner.0
),
));
@@ -159,10 +159,10 @@ pub fn materialize_elgamal_registry_stateful_snapshot(
slot: u64,
data: &[u8],
) -> std::result::Result<crate::ElGamalRegistryStatefulSnapshot, String> {
if owner_program_id != kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID {
if owner_program_id != kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID {
return std::result::Result::Err(format!(
"SPL ElGamal registry snapshot owner must be {}, got {owner_program_id}",
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID
));
}
let state = match kb_lib::decoder_spl_elgamal_registry_parse_elgamal_registry_state(data) {
@@ -178,7 +178,7 @@ pub fn materialize_elgamal_registry_stateful_snapshot(
},
};
let program_id = match solana_pubkey::Pubkey::from_str(
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
@@ -216,7 +216,7 @@ mod tests {
fn registry_fixture(owner: &solana_pubkey::Pubkey) -> (std::string::String, [u8; 64]) {
let program_id = match solana_pubkey::Pubkey::from_str(
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(_) => solana_pubkey::Pubkey::default(),
@@ -235,7 +235,7 @@ mod tests {
let (registry, data) = registry_fixture(&owner);
let snapshot = crate::materialize_elgamal_registry_stateful_snapshot(
registry.as_str(),
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
55,
&data,
);
@@ -257,21 +257,21 @@ mod tests {
let (registry, data) = registry_fixture(&owner);
let foreign = crate::materialize_elgamal_registry_stateful_snapshot(
registry.as_str(),
kb_program_ids::SPL_TOKEN2022_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
55,
&data,
);
assert!(foreign.is_err());
let wrong = crate::materialize_elgamal_registry_stateful_snapshot(
solana_pubkey::Pubkey::new_from_array([10u8; 32]).to_string().as_str(),
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
55,
&data,
);
assert!(wrong.is_err());
let invalid = crate::materialize_elgamal_registry_stateful_snapshot(
registry.as_str(),
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID,
55,
&data[..63],
);
@@ -295,7 +295,7 @@ mod tests {
account: std::option::Option::Some(kb_onchain_transport::AccountInfoValue {
lamports: 1,
owner: kb_lib::MdProgramId(
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID.to_string(),
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID.to_string(),
),
executable: false,
rent_epoch: 0,
@@ -327,7 +327,7 @@ mod tests {
let base = kb_onchain_transport::AccountInfoValue {
lamports: 1,
owner: kb_lib::MdProgramId(
kb_program_ids::SPL_TOKEN2022_ELGAMAL_REGISTRY_PROGRAM_ID.to_string(),
kb_program_ids::SPL_TOKEN_2022_ELGAMAL_REGISTRY_PROGRAM_ID.to_string(),
),
executable: false,
rent_epoch: 0,
@@ -353,7 +353,7 @@ mod tests {
crate::materialize_elgamal_registry_account_info_result(&request, &missing).is_err()
);
let mut foreign = base.clone();
foreign.owner = kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN2022_PROGRAM_ID.to_string());
foreign.owner = kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID.to_string());
let foreign = kb_onchain_transport::AccountInfoResult {
context: kb_onchain_transport::RpcResponseContext {
slot: 80,

20
kb-pipeline/src/solana_token2022_correlation.rs → kb-pipeline/src/solana_token_2022_correlation.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/solana_token2022_correlation.rs
// version: 1
// file: kb-pipeline/src/solana_token_2022_correlation.rs
// version: 2
//! Deterministic Token-2022 instruction-to-state correlation.
@@ -36,7 +36,7 @@ pub struct Token2022StateCorrelationReport {
}
/// Correlates one materialized instruction fact with one authoritative Token-2022 snapshot.
pub fn correlate_token2022_instruction_with_snapshot(
pub fn correlate_token_2022_instruction_with_snapshot(
correlation_key: &str,
account: &kb_lib::MdPubkey,
instruction_output: &kb_lib::MtApiMaterializedOutput,
@@ -49,7 +49,7 @@ pub fn correlate_token2022_instruction_with_snapshot(
}
if snapshot.account_key != account.0 {
return std::result::Result::Err(kb_core::Error::new(
"token2022_correlation_account_mismatch",
"token_2022_correlation_account_mismatch",
format!(
"Token-2022 correlation expected account {}, got snapshot {}",
account.0, snapshot.account_key
@@ -67,7 +67,7 @@ pub fn correlate_token2022_instruction_with_snapshot(
};
if fact_code.is_empty() {
return std::result::Result::Err(kb_core::Error::new(
"token2022_correlation_fact_missing",
"token_2022_correlation_fact_missing",
"Token-2022 correlation requires riskKind or operation in the instruction output",
));
}
@@ -177,7 +177,7 @@ mod tests {
fn known_fact_is_confirmed_or_contradicted_by_the_final_extension_inventory() {
let snapshot = snapshot(&["pausable"]);
let account = kb_lib::MdPubkey(snapshot.account_key.clone());
let confirmed = super::correlate_token2022_instruction_with_snapshot(
let confirmed = super::correlate_token_2022_instruction_with_snapshot(
"corr:pause",
&account,
&output("riskKind", "mint_activity_paused"),
@@ -188,7 +188,7 @@ mod tests {
assert_eq!(confirmed.status, super::Token2022CorrelationStatus::Confirmed);
assert_eq!(confirmed.extension_present, std::option::Option::Some(true));
}
let contradicted = super::correlate_token2022_instruction_with_snapshot(
let contradicted = super::correlate_token_2022_instruction_with_snapshot(
"corr:fee",
&account,
&output("operation", "initialize_transfer_fee_config"),
@@ -205,7 +205,7 @@ mod tests {
fn unsupported_fact_is_explicitly_not_applicable_without_inventing_a_conclusion() {
let snapshot = snapshot(&[]);
let account = kb_lib::MdPubkey(snapshot.account_key.clone());
let report = super::correlate_token2022_instruction_with_snapshot(
let report = super::correlate_token_2022_instruction_with_snapshot(
"corr:unknown",
&account,
&output("operation", "unknown_future_operation"),
@@ -223,7 +223,7 @@ mod tests {
fn correlation_identity_and_account_mismatch_fail_closed() {
let snapshot = snapshot(&["memo_transfer"]);
let account = kb_lib::MdPubkey(snapshot.account_key.clone());
let empty = super::correlate_token2022_instruction_with_snapshot(
let empty = super::correlate_token_2022_instruction_with_snapshot(
"",
&account,
&output("riskKind", "required_transfer_memos_enabled"),
@@ -231,7 +231,7 @@ mod tests {
);
assert!(empty.is_err());
let wrong = kb_lib::MdPubkey(solana_pubkey::Pubkey::new_from_array([8u8; 32]).to_string());
let mismatch = super::correlate_token2022_instruction_with_snapshot(
let mismatch = super::correlate_token_2022_instruction_with_snapshot(
"corr:mismatch",
&wrong,
&output("riskKind", "required_transfer_memos_enabled"),

28
kb-pipeline/src/solana_token2022_crypto_preflight.rs → kb-pipeline/src/solana_token_2022_crypto_preflight.rs
View File

@@ -1,10 +1,10 @@
// file: kb-pipeline/src/solana_token2022_crypto_preflight.rs
// version: 2
// file: kb-pipeline/src/solana_token_2022_crypto_preflight.rs
// version: 3
//! Bounded cryptographic preflight for Token-2022 proof context-state accounts.
/// Maximum number of distinct proof context-state accounts accepted by one request.
pub const MAX_TOKEN2022_PROOF_CONTEXTS: usize = 8;
pub const MAX_TOKEN_2022_PROOF_CONTEXTS: usize = 8;
/// Generic metadata bytes retained by every ZK ElGamal proof context-state account.
pub const ZK_PROOF_CONTEXT_META_BYTES: usize = 33;
@@ -61,7 +61,7 @@ pub struct Token2022CryptographicPreflightReport {
}
/// Reads and validates all pre-verified proof context-state accounts required by one operation.
pub async fn inspect_token2022_cryptographic_preflight(
pub async fn inspect_token_2022_cryptographic_preflight(
pool: &kb_onchain_transport::HttpEndpointPool,
request: &crate::Token2022CryptographicPreflightRequest,
) -> kb_core::Result<crate::Token2022CryptographicPreflightReport> {
@@ -110,12 +110,12 @@ fn validate_proof_context_requirements(
"Token-2022 cryptographic preflight query_role must not be empty",
));
}
if request.proof_contexts.len() > crate::MAX_TOKEN2022_PROOF_CONTEXTS {
if request.proof_contexts.len() > crate::MAX_TOKEN_2022_PROOF_CONTEXTS {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_limit_exceeded",
"token_2022_proof_context_limit_exceeded",
format!(
"Token-2022 cryptographic preflight accepts at most {} proof contexts",
crate::MAX_TOKEN2022_PROOF_CONTEXTS
crate::MAX_TOKEN_2022_PROOF_CONTEXTS
),
));
}
@@ -130,7 +130,7 @@ fn validate_proof_context_requirements(
if let std::option::Option::Some(index) = indexes.get(requirement.account.0.as_str()) {
if &unique[*index] != requirement {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_conflicting_duplicate",
"token_2022_proof_context_conflicting_duplicate",
format!(
"Token-2022 proof context {} has conflicting requirements",
requirement.account.0
@@ -153,7 +153,7 @@ fn validate_proof_context_account(
std::option::Option::Some(value) => value,
std::option::Option::None => {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_missing",
"token_2022_proof_context_missing",
format!(
"Token-2022 proof context account {} does not exist",
requirement.account.0
@@ -163,7 +163,7 @@ fn validate_proof_context_account(
};
if account.owner.0 != kb_program_ids::ZK_ELGAMAL_PROOF_PROGRAM_ID {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_owner_mismatch",
"token_2022_proof_context_owner_mismatch",
format!(
"Token-2022 proof context owner must be {}, got {}",
kb_program_ids::ZK_ELGAMAL_PROOF_PROGRAM_ID,
@@ -173,14 +173,14 @@ fn validate_proof_context_account(
}
if account.executable {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_executable",
"token_2022_proof_context_executable",
"Token-2022 proof context account must not be executable",
));
}
let expected_size = requirement.proof_type.context_state_size();
if account.space != expected_size as u64 || account.data.len() != expected_size {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_size_mismatch",
"token_2022_proof_context_size_mismatch",
format!(
"Token-2022 proof context {} must contain exactly {expected_size} bytes, got space {} and data {}",
requirement.account.0,
@@ -197,7 +197,7 @@ fn validate_proof_context_account(
let discriminator = account.data[32];
if discriminator != requirement.proof_type.discriminator() {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_type_mismatch",
"token_2022_proof_context_type_mismatch",
format!(
"Token-2022 proof context {} discriminator {} does not match expected {}",
requirement.account.0,
@@ -216,7 +216,7 @@ fn validate_proof_context_account(
let retained_authority = bs58::encode(&account.data[..32]).into_string();
if retained_authority != expected_authority.0 {
return std::result::Result::Err(kb_core::Error::new(
"token2022_proof_context_authority_mismatch",
"token_2022_proof_context_authority_mismatch",
format!(
"Token-2022 proof context {} retains authority {}, expected {}",
requirement.account.0, retained_authority, expected_authority.0

50
kb-pipeline/src/solana_token2022_execution_orchestration.rs → kb-pipeline/src/solana_token_2022_execution_orchestration.rs
View File

@@ -1,10 +1,10 @@
// file: kb-pipeline/src/solana_token2022_execution_orchestration.rs
// version: 1
// file: kb-pipeline/src/solana_token_2022_execution_orchestration.rs
// version: 2
//! Final Token-2022 execution-readiness and stateful postcondition contracts.
/// Maximum number of distinct transaction signers accepted by one Token-2022 execution envelope.
pub const MAX_TOKEN2022_EXECUTION_SIGNERS: usize = 16;
pub const MAX_TOKEN_2022_EXECUTION_SIGNERS: usize = 16;
/// Result of one stateful postcondition checked after a confirmed Token-2022 transaction.
#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
@@ -76,7 +76,7 @@ pub struct Token2022ExecutionReadinessReport {
}
/// Validates the complete Token-2022 execution envelope before transaction signing.
pub fn validate_token2022_execution_readiness(
pub fn validate_token_2022_execution_readiness(
request: &crate::Token2022ExecutionReadinessRequest,
) -> kb_core::Result<crate::Token2022ExecutionReadinessReport> {
if request.plan.operation_code.trim().is_empty() {
@@ -86,7 +86,7 @@ pub fn validate_token2022_execution_readiness(
}
if request.plan.operation_code != request.proof_orchestration.operation_code {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_operation_mismatch",
"token_2022_execution_operation_mismatch",
"Token-2022 plan and proof orchestration operation codes must match",
));
}
@@ -95,19 +95,19 @@ pub fn validate_token2022_execution_readiness(
|| request.message_hash != request.simulated_message_hash
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_simulation_message_mismatch",
"token_2022_execution_simulation_message_mismatch",
"Token-2022 simulation must be bound to the exact compiled message hash",
));
}
if !request.simulated || !request.simulation_succeeded {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_simulation_required",
"token_2022_execution_simulation_required",
"Token-2022 execution requires one successful exact-message simulation",
));
}
if !request.proof_orchestration.simulation_required {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_proof_policy_mismatch",
"token_2022_execution_proof_policy_mismatch",
"Token-2022 proof orchestration must require simulation",
));
}
@@ -115,7 +115,7 @@ pub fn validate_token2022_execution_readiness(
|| request.cryptographic_preflight.commitment != "confirmed"
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_preflight_commitment_mismatch",
"token_2022_execution_preflight_commitment_mismatch",
"Token-2022 stateful and cryptographic preflights must use confirmed commitment",
));
}
@@ -128,19 +128,19 @@ pub fn validate_token2022_execution_readiness(
};
if request.submit && !request.operator_confirmed {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_confirmation_required",
"token_2022_execution_confirmation_required",
"Token-2022 submission requires explicit operator confirmation",
));
}
if request.submit && !request.proof_orchestration.send_authorized {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_proof_send_not_authorized",
"token_2022_execution_proof_send_not_authorized",
"Token-2022 proof orchestration did not authorize submission",
));
}
if request.submit && request.plan.policy.dry_run {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_dry_run_blocks_submission",
"token_2022_execution_dry_run_blocks_submission",
"Token-2022 plan remains dry-run and cannot be submitted",
));
}
@@ -169,7 +169,7 @@ pub fn validate_token2022_execution_readiness(
}
/// Aggregates explicit postconditions without converting unsupported checks into success.
pub fn summarize_token2022_postconditions(
pub fn summarize_token_2022_postconditions(
postconditions: &[crate::Token2022ExecutionPostcondition],
) -> crate::Token2022ExecutionPostconditionStatus {
if postconditions.iter().any(|item| {
@@ -189,14 +189,14 @@ fn validate_signers(
required: &[kb_lib::ExApiRequiredSigner],
resolved: &[kb_lib::MdPubkey],
) -> kb_core::Result<std::vec::Vec<kb_lib::MdPubkey>> {
if required.len() > crate::MAX_TOKEN2022_EXECUTION_SIGNERS
|| resolved.len() > crate::MAX_TOKEN2022_EXECUTION_SIGNERS
if required.len() > crate::MAX_TOKEN_2022_EXECUTION_SIGNERS
|| resolved.len() > crate::MAX_TOKEN_2022_EXECUTION_SIGNERS
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_signer_limit_exceeded",
"token_2022_execution_signer_limit_exceeded",
format!(
"Token-2022 execution accepts at most {} signers",
crate::MAX_TOKEN2022_EXECUTION_SIGNERS
crate::MAX_TOKEN_2022_EXECUTION_SIGNERS
),
));
}
@@ -214,7 +214,7 @@ fn validate_signers(
for signer in required_unique.values() {
if !resolved_set.contains(signer.0.as_str()) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_execution_signer_unresolved",
"token_2022_execution_signer_unresolved",
format!("Token-2022 required signer {} is unresolved", signer.0),
));
}
@@ -235,7 +235,7 @@ mod tests {
..std::default::Default::default()
};
let plan = kb_lib::ExApiPreparedExecutionPlan {
executor_name: "kb-lib.executor.spl.token2022".to_string(),
executor_name: "kb-lib.executor.spl.token_2022".to_string(),
executor_version: "0.4.6".to_string(),
intent_id: "intent".to_string(),
operation_code: "spl_token_2022.confidential_transfer".to_string(),
@@ -284,7 +284,7 @@ mod tests {
#[test]
fn exact_message_preflights_and_signers_authorize_submission() {
let report = super::validate_token2022_execution_readiness(&request())
let report = super::validate_token_2022_execution_readiness(&request())
.expect("complete Token-2022 readiness must succeed");
assert!(report.send_authorized);
assert_eq!(report.context_slot, 101);
@@ -295,13 +295,13 @@ mod tests {
fn message_mismatch_missing_signer_and_dry_run_fail_closed() {
let mut mismatched = request();
mismatched.simulated_message_hash = "other".to_string();
assert!(super::validate_token2022_execution_readiness(&mismatched).is_err());
assert!(super::validate_token_2022_execution_readiness(&mismatched).is_err());
let mut missing = request();
missing.resolved_signers.clear();
assert!(super::validate_token2022_execution_readiness(&missing).is_err());
assert!(super::validate_token_2022_execution_readiness(&missing).is_err());
let mut dry_run = request();
dry_run.plan.policy.dry_run = true;
assert!(super::validate_token2022_execution_readiness(&dry_run).is_err());
assert!(super::validate_token_2022_execution_readiness(&dry_run).is_err());
}
#[test]
@@ -314,7 +314,7 @@ mod tests {
diagnostic: "no supported final-state assertion".to_string(),
};
assert_eq!(
super::summarize_token2022_postconditions(&[not_applicable]),
super::summarize_token_2022_postconditions(&[not_applicable]),
crate::Token2022ExecutionPostconditionStatus::NotApplicable
);
let contradicted = crate::Token2022ExecutionPostcondition {
@@ -324,7 +324,7 @@ mod tests {
diagnostic: "final extension inventory contradicts the expected effect".to_string(),
};
assert_eq!(
super::summarize_token2022_postconditions(&[contradicted]),
super::summarize_token_2022_postconditions(&[contradicted]),
crate::Token2022ExecutionPostconditionStatus::Contradicted
);
}

42
kb-pipeline/src/solana_token2022_preflight.rs → kb-pipeline/src/solana_token_2022_preflight.rs
View File

@@ -1,12 +1,12 @@
// file: kb-pipeline/src/solana_token2022_preflight.rs
// version: 2
// file: kb-pipeline/src/solana_token_2022_preflight.rs
// version: 3
//! Bounded Token-2022 stateful preflight orchestration.
/// Maximum distinct Token-2022 accounts accepted by one preflight inspection.
pub const MAX_TOKEN2022_PREFLIGHT_ACCOUNTS: usize = 16;
pub const MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS: usize = 16;
/// Maximum aggregate account-data budget accepted by one preflight inspection.
pub const MAX_TOKEN2022_PREFLIGHT_TOTAL_BYTES: usize = 262_144;
pub const MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES: usize = 262_144;
/// One exact Token-2022 account requirement for a stateful preflight.
#[derive(Clone, Debug, PartialEq)]
@@ -81,7 +81,7 @@ pub struct Token2022PreflightReport {
}
/// Inspects all bounded Token-2022 state required before simulation.
pub async fn inspect_token2022_preflight(
pub async fn inspect_token_2022_preflight(
pool: &kb_onchain_transport::HttpEndpointPool,
request: &crate::Token2022PreflightRequest,
) -> kb_core::Result<crate::Token2022PreflightReport> {
@@ -110,7 +110,8 @@ pub async fn inspect_token2022_preflight(
max_data_bytes: requirement.max_data_bytes,
context: requirement.context.clone(),
};
let read_result = match crate::read_token2022_stateful_snapshot(pool, &read_request).await {
let read_result = match crate::read_token_2022_stateful_snapshot(pool, &read_request).await
{
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
@@ -153,18 +154,19 @@ fn validate_and_deduplicate_requirements(
"Token-2022 preflight query_role must not be empty",
));
}
if request.max_accounts == 0 || request.max_accounts > crate::MAX_TOKEN2022_PREFLIGHT_ACCOUNTS {
if request.max_accounts == 0 || request.max_accounts > crate::MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS
{
return std::result::Result::Err(kb_core::Error::config(format!(
"Token-2022 preflight max_accounts must be between 1 and {}",
crate::MAX_TOKEN2022_PREFLIGHT_ACCOUNTS
crate::MAX_TOKEN_2022_PREFLIGHT_ACCOUNTS
)));
}
if request.max_total_data_bytes == 0
|| request.max_total_data_bytes > crate::MAX_TOKEN2022_PREFLIGHT_TOTAL_BYTES
|| request.max_total_data_bytes > crate::MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES
{
return std::result::Result::Err(kb_core::Error::config(format!(
"Token-2022 preflight max_total_data_bytes must be between 1 and {}",
crate::MAX_TOKEN2022_PREFLIGHT_TOTAL_BYTES
crate::MAX_TOKEN_2022_PREFLIGHT_TOTAL_BYTES
)));
}
if request.requirements.is_empty() {
@@ -181,7 +183,7 @@ fn validate_and_deduplicate_requirements(
));
}
if requirement.max_data_bytes == 0
|| requirement.max_data_bytes > crate::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES
|| requirement.max_data_bytes > crate::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES
{
return std::result::Result::Err(kb_core::Error::config(format!(
"Token-2022 preflight account {} has invalid max_data_bytes {}",
@@ -191,7 +193,7 @@ fn validate_and_deduplicate_requirements(
if let std::option::Option::Some(index) = indexes.get(requirement.account.0.as_str()) {
if &unique[*index] != requirement {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_conflicting_duplicate",
"token_2022_preflight_conflicting_duplicate",
format!(
"Token-2022 preflight account {} has conflicting requirements",
requirement.account.0
@@ -209,7 +211,7 @@ fn validate_and_deduplicate_requirements(
.saturating_add(if request.elgamal_registry.is_some() { 1 } else { 0 });
if total_accounts > request.max_accounts {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_account_limit_exceeded",
"token_2022_preflight_account_limit_exceeded",
format!(
"Token-2022 preflight requires {total_accounts} distinct accounts above limit {}",
request.max_accounts
@@ -228,7 +230,7 @@ fn validate_and_deduplicate_requirements(
});
if requested_data_bytes > request.max_total_data_bytes {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_data_budget_exceeded",
"token_2022_preflight_data_budget_exceeded",
format!(
"Token-2022 preflight requests {requested_data_bytes} bytes above aggregate limit {}",
request.max_total_data_bytes
@@ -246,7 +248,7 @@ fn validate_snapshot_requirement(
.snapshot
.outputs
.iter()
.find(|output| return output.payload_json["domain"] == "spl_token2022_account_state");
.find(|output| return output.payload_json["domain"] == "spl_token_2022_account_state");
let token_output = match token_output {
std::option::Option::Some(value) => value,
std::option::Option::None => {
@@ -264,7 +266,7 @@ fn validate_snapshot_requirement(
if let std::option::Option::Some(expected_mint) = requirement.expected_mint.as_ref() {
if base_fields["mint"].as_str() != std::option::Option::Some(expected_mint.0.as_str()) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_mint_mismatch",
"token_2022_preflight_mint_mismatch",
format!(
"Token-2022 account {} mint does not match expected {}",
requirement.account.0, expected_mint.0
@@ -276,7 +278,7 @@ fn validate_snapshot_requirement(
if let std::option::Option::Some(expected_owner) = requirement.expected_owner.as_ref() {
if base_fields["owner"].as_str() != std::option::Option::Some(expected_owner.0.as_str()) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_owner_mismatch",
"token_2022_preflight_owner_mismatch",
format!(
"Token-2022 account {} owner does not match expected {}",
requirement.account.0, expected_owner.0
@@ -288,7 +290,7 @@ fn validate_snapshot_requirement(
if let std::option::Option::Some(expected_decimals) = requirement.expected_decimals {
if base_fields["decimals"].as_u64() != std::option::Option::Some(expected_decimals as u64) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_decimals_mismatch",
"token_2022_preflight_decimals_mismatch",
format!(
"Token-2022 mint {} decimals do not match expected {expected_decimals}",
requirement.account.0
@@ -305,7 +307,7 @@ fn validate_snapshot_requirement(
.any(|value| return value == required_extension)
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_preflight_extension_missing",
"token_2022_preflight_extension_missing",
format!(
"Token-2022 account {} is missing required extension {required_extension}",
requirement.account.0
@@ -414,7 +416,7 @@ mod tests {
output_key: "state".to_string(),
family: kb_lib::MdMaterializedEventFamily::TokenAccount,
payload_json: serde_json::json!({
"domain":"spl_token2022_account_state",
"domain":"spl_token_2022_account_state",
"baseFields":{"mint":mint.0,"owner":owner.0}
}),
}],

38
kb-pipeline/src/solana_token2022_proof_orchestration.rs → kb-pipeline/src/solana_token_2022_proof_orchestration.rs
View File

@@ -1,10 +1,10 @@
// file: kb-pipeline/src/solana_token2022_proof_orchestration.rs
// version: 2
// file: kb-pipeline/src/solana_token_2022_proof_orchestration.rs
// version: 3
//! Deterministic orchestration contract for mixed Token-2022 proof locations.
/// Maximum proof references accepted by one confidential Token-2022 operation.
pub const MAX_TOKEN2022_OPERATION_PROOFS: usize = 5;
pub const MAX_TOKEN_2022_OPERATION_PROOFS: usize = 5;
/// One bounded proof-orchestration request prepared before transaction assembly.
#[derive(Clone, Debug, Eq, PartialEq)]
@@ -45,7 +45,7 @@ pub struct Token2022ProofOrchestrationReport {
}
/// Validates mixed inline/context-state proof orchestration before transaction assembly.
pub fn orchestrate_token2022_proofs(
pub fn orchestrate_token_2022_proofs(
request: &crate::Token2022ProofOrchestrationRequest,
cryptographic_preflight: &crate::Token2022CryptographicPreflightReport,
) -> kb_core::Result<crate::Token2022ProofOrchestrationReport> {
@@ -54,12 +54,12 @@ pub fn orchestrate_token2022_proofs(
"Token-2022 proof orchestration operation_code must not be empty",
));
}
if request.proofs.len() > crate::MAX_TOKEN2022_OPERATION_PROOFS {
if request.proofs.len() > crate::MAX_TOKEN_2022_OPERATION_PROOFS {
return std::result::Result::Err(kb_core::Error::new(
"token2022_operation_proof_limit_exceeded",
"token_2022_operation_proof_limit_exceeded",
format!(
"Token-2022 proof orchestration accepts at most {} proofs",
crate::MAX_TOKEN2022_OPERATION_PROOFS
crate::MAX_TOKEN_2022_OPERATION_PROOFS
),
));
}
@@ -70,7 +70,7 @@ pub fn orchestrate_token2022_proofs(
}
if request.submit && !request.operator_confirmed {
return std::result::Result::Err(kb_core::Error::new(
"token2022_submission_confirmation_required",
"token_2022_submission_confirmation_required",
"Token-2022 submission requires explicit operator confirmation",
));
}
@@ -83,7 +83,7 @@ pub fn orchestrate_token2022_proofs(
let kind_code = proof_kind_code(proof.kind).to_string();
if !kinds.insert(kind_code.clone()) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_duplicate_proof_kind",
"token_2022_duplicate_proof_kind",
format!(
"Token-2022 operation {} contains duplicate proof kind {kind_code}",
request.operation_code
@@ -97,7 +97,7 @@ pub fn orchestrate_token2022_proofs(
kb_lib::ExSplTokenConfidentialProofLocation::InstructionOffset { offset } => {
if !offsets.insert(*offset) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_duplicate_inline_proof_offset",
"token_2022_duplicate_inline_proof_offset",
format!(
"Token-2022 operation {} reuses inline proof offset {offset}",
request.operation_code
@@ -109,7 +109,7 @@ pub fn orchestrate_token2022_proofs(
kb_lib::ExSplTokenConfidentialProofLocation::ContextStateAccount { account } => {
if !context_accounts.insert(account.0.clone()) {
return std::result::Result::Err(kb_core::Error::new(
"token2022_duplicate_context_state_account",
"token_2022_duplicate_context_state_account",
format!(
"Token-2022 operation {} reuses context-state account {}",
request.operation_code, account.0
@@ -154,7 +154,7 @@ fn validate_context_reports(
) -> kb_core::Result<()> {
if requirements.len() != report.proof_contexts.len() {
return std::result::Result::Err(kb_core::Error::new(
"token2022_context_preflight_count_mismatch",
"token_2022_context_preflight_count_mismatch",
format!(
"Token-2022 operation requires {} context states, preflight contains {}",
requirements.len(),
@@ -167,7 +167,7 @@ fn validate_context_reports(
|| requirement.proof_type.discriminator() != observed.proof_discriminator
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_context_preflight_mismatch",
"token_2022_context_preflight_mismatch",
format!(
"Token-2022 proof context {} does not match the ordered operation requirement",
observed.account.0
@@ -266,7 +266,7 @@ mod tests {
fn mixed_proofs_require_sysvar_and_preserve_ordered_contexts() {
let context = pubkey(1);
let request = crate::Token2022ProofOrchestrationRequest {
operation_code: "spl_token2022.confidential_transfer".to_string(),
operation_code: "spl_token_2022.confidential_transfer".to_string(),
proofs: vec![
kb_lib::ExSplTokenConfidentialProofReference {
kind: kb_lib::ExSplTokenConfidentialProofKind::CiphertextCommitmentEquality,
@@ -295,7 +295,7 @@ mod tests {
kb_lib::ExSolanaCoreZkElGamalProofType::BatchedRangeProofU128,
)],
};
let report = crate::orchestrate_token2022_proofs(&request, &preflight)
let report = crate::orchestrate_token_2022_proofs(&request, &preflight)
.expect("mixed proof orchestration must succeed");
assert!(report.instructions_sysvar_required);
assert_eq!(report.inline_offsets, vec![1]);
@@ -308,7 +308,7 @@ mod tests {
fn context_only_proofs_do_not_require_instructions_sysvar() {
let context = pubkey(2);
let request = crate::Token2022ProofOrchestrationRequest {
operation_code: "spl_token2022.empty_confidential_account".to_string(),
operation_code: "spl_token_2022.empty_confidential_account".to_string(),
proofs: vec![kb_lib::ExSplTokenConfidentialProofReference {
kind: kb_lib::ExSplTokenConfidentialProofKind::ZeroCiphertext,
location: kb_lib::ExSplTokenConfidentialProofLocation::ContextStateAccount {
@@ -329,7 +329,7 @@ mod tests {
kb_lib::ExSolanaCoreZkElGamalProofType::ZeroCiphertext,
)],
};
let report = crate::orchestrate_token2022_proofs(&request, &preflight)
let report = crate::orchestrate_token_2022_proofs(&request, &preflight)
.expect("context-only orchestration must succeed");
assert!(!report.instructions_sysvar_required);
assert!(report.send_authorized);
@@ -364,10 +364,10 @@ mod tests {
context_slot: 0,
proof_contexts: vec![],
};
assert!(crate::orchestrate_token2022_proofs(&duplicate_offset, &empty).is_err());
assert!(crate::orchestrate_token_2022_proofs(&duplicate_offset, &empty).is_err());
let mut unconfirmed = duplicate_offset;
unconfirmed.proofs.clear();
unconfirmed.submit = true;
assert!(crate::orchestrate_token2022_proofs(&unconfirmed, &empty).is_err());
assert!(crate::orchestrate_token_2022_proofs(&unconfirmed, &empty).is_err());
}
}

121
kb-pipeline/src/solana_token2022_stateful.rs → kb-pipeline/src/solana_token_2022_stateful.rs
View File

@@ -1,5 +1,5 @@
// file: kb-pipeline/src/solana_token2022_stateful.rs
// version: 5
// file: kb-pipeline/src/solana_token_2022_stateful.rs
// version: 6
//! Contextual Token-2022 account-state validation and materialization routing.
@@ -11,7 +11,7 @@ pub struct Token2022StatefulContext {
}
/// Maximum complete Token-2022 account data accepted by one bounded RPC read.
pub const MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES: usize = 65_536;
pub const MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES: usize = 65_536;
/// One bounded Token-2022 account read request.
#[derive(Clone, Debug, PartialEq)]
@@ -42,7 +42,7 @@ pub struct Token2022StatefulReadResult {
}
/// Reads, validates, parses, and routes one bounded Token-2022 account snapshot.
pub async fn read_token2022_stateful_snapshot(
pub async fn read_token_2022_stateful_snapshot(
pool: &kb_onchain_transport::HttpEndpointPool,
request: &crate::Token2022StatefulReadRequest,
) -> kb_core::Result<crate::Token2022StatefulReadResult> {
@@ -52,11 +52,11 @@ pub async fn read_token2022_stateful_snapshot(
));
}
if request.max_data_bytes == 0
|| request.max_data_bytes > crate::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES
|| request.max_data_bytes > crate::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES
{
return std::result::Result::Err(kb_core::Error::config(format!(
"Token-2022 stateful read max_data_bytes must be between 1 and {}",
crate::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES
crate::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES
)));
}
let config = match kb_onchain_transport::GetAccountInfoConfig::new_with_data(
@@ -74,26 +74,26 @@ pub async fn read_token2022_stateful_snapshot(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
return crate::materialize_token2022_account_info_result(request, &result);
return crate::materialize_token_2022_account_info_result(request, &result);
}
/// Validates one complete RPC account response before Token-2022 parsing and routing.
pub fn materialize_token2022_account_info_result(
pub fn materialize_token_2022_account_info_result(
request: &crate::Token2022StatefulReadRequest,
result: &kb_onchain_transport::AccountInfoResult,
) -> kb_core::Result<crate::Token2022StatefulReadResult> {
if request.max_data_bytes == 0
|| request.max_data_bytes > crate::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES
|| request.max_data_bytes > crate::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES
{
return std::result::Result::Err(kb_core::Error::config(format!(
"Token-2022 stateful read max_data_bytes must be between 1 and {}",
crate::MAX_TOKEN2022_STATEFUL_ACCOUNT_BYTES
crate::MAX_TOKEN_2022_STATEFUL_ACCOUNT_BYTES
)));
}
if let std::option::Option::Some(min_context_slot) = request.min_context_slot {
if result.context.slot < min_context_slot {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_context_slot_too_old",
"token_2022_stateful_context_slot_too_old",
format!(
"Token-2022 account context slot {} is below requested minimum {min_context_slot}",
result.context.slot
@@ -105,24 +105,24 @@ pub fn materialize_token2022_account_info_result(
std::option::Option::Some(value) => value,
std::option::Option::None => {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_account_missing",
"token_2022_stateful_account_missing",
format!("Token-2022 account {} does not exist", request.account.0),
));
},
};
if account.executable {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_account_executable",
"token_2022_stateful_account_executable",
format!("Token-2022 state account {} must not be executable", request.account.0),
));
}
if account.owner.0 != kb_program_ids::SPL_TOKEN2022_PROGRAM_ID {
if account.owner.0 != kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_owner_mismatch",
"token_2022_stateful_owner_mismatch",
format!(
"Token-2022 state account {} owner must be {}, got {}",
request.account.0,
kb_program_ids::SPL_TOKEN2022_PROGRAM_ID,
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID,
account.owner.0
),
));
@@ -130,7 +130,7 @@ pub fn materialize_token2022_account_info_result(
if account.space > request.max_data_bytes as u64 || account.data.len() > request.max_data_bytes
{
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_account_too_large",
"token_2022_stateful_account_too_large",
format!(
"Token-2022 account {} reports {} bytes and returned {} bytes above limit {}",
request.account.0,
@@ -142,7 +142,7 @@ pub fn materialize_token2022_account_info_result(
}
if account.space != account.data.len() as u64 {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_account_data_incomplete",
"token_2022_stateful_account_data_incomplete",
format!(
"Token-2022 account {} reports {} bytes but returned {} decoded bytes",
request.account.0,
@@ -151,19 +151,19 @@ pub fn materialize_token2022_account_info_result(
),
));
}
let state = match kb_lib::decoder_spl_token2022_parse_token2022_state(
let state = match kb_lib::decoder_spl_token_2022_parse_token_2022_state(
request.kind,
account.data.as_slice(),
) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_parse_failed",
"token_2022_stateful_parse_failed",
error,
));
},
};
let snapshot = match crate::materialize_parsed_token2022_stateful_snapshot_with_context(
let snapshot = match crate::materialize_parsed_token_2022_stateful_snapshot_with_context(
request.account.0.as_str(),
result.context.slot,
&state,
@@ -172,7 +172,7 @@ pub fn materialize_token2022_account_info_result(
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => {
return std::result::Result::Err(kb_core::Error::new(
"token2022_stateful_projection_failed",
"token_2022_stateful_projection_failed",
error,
));
},
@@ -200,24 +200,24 @@ pub struct Token2022StatefulSnapshotBundle {
}
/// Parse, contextually validate, and materialize one bounded Token-2022 account snapshot.
pub fn materialize_token2022_stateful_snapshot(
pub fn materialize_token_2022_stateful_snapshot(
account_key: &str,
owner_program_id: &str,
slot: u64,
kind: kb_lib::DcToken2022StateKind,
data: &[u8],
) -> std::result::Result<crate::Token2022StatefulSnapshotBundle, String> {
if owner_program_id != kb_program_ids::SPL_TOKEN2022_PROGRAM_ID {
if owner_program_id != kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID {
return std::result::Result::Err(format!(
"Token-2022 state snapshot owner must be {}, got {owner_program_id}",
kb_program_ids::SPL_TOKEN2022_PROGRAM_ID
kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID
));
}
let state = match kb_lib::decoder_spl_token2022_parse_token2022_state(kind, data) {
let state = match kb_lib::decoder_spl_token_2022_parse_token_2022_state(kind, data) {
std::result::Result::Ok(value) => value,
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
return crate::materialize_parsed_token2022_stateful_snapshot_with_context(
return crate::materialize_parsed_token_2022_stateful_snapshot_with_context(
account_key,
slot,
&state,
@@ -226,12 +226,12 @@ pub fn materialize_token2022_stateful_snapshot(
}
/// Contextually validate and materialize one already parsed Token-2022 account snapshot.
pub fn materialize_parsed_token2022_stateful_snapshot(
pub fn materialize_parsed_token_2022_stateful_snapshot(
account_key: &str,
slot: u64,
state: &kb_lib::DcToken2022State,
) -> std::result::Result<crate::Token2022StatefulSnapshotBundle, String> {
return crate::materialize_parsed_token2022_stateful_snapshot_with_context(
return crate::materialize_parsed_token_2022_stateful_snapshot_with_context(
account_key,
slot,
state,
@@ -240,7 +240,7 @@ pub fn materialize_parsed_token2022_stateful_snapshot(
}
/// Contextually validate one parsed Token-2022 snapshot with external cross-account identities.
pub fn materialize_parsed_token2022_stateful_snapshot_with_context(
pub fn materialize_parsed_token_2022_stateful_snapshot_with_context(
account_key: &str,
slot: u64,
state: &kb_lib::DcToken2022State,
@@ -273,7 +273,7 @@ pub fn materialize_parsed_token2022_stateful_snapshot_with_context(
std::result::Result::Ok(()) => {},
std::result::Result::Err(error) => return std::result::Result::Err(error),
}
let account_output = match kb_lib::materializer_token_materialize_token2022_state_snapshot(
let account_output = match kb_lib::materializer_token_materialize_token_2022_state_snapshot(
account_key,
slot,
state,
@@ -283,7 +283,7 @@ pub fn materialize_parsed_token2022_stateful_snapshot_with_context(
};
let mut outputs = std::vec![account_output];
if state.kind == kb_lib::DcToken2022StateKind::Mint {
let metadata_outputs = match kb_lib::materializer_metadata_materialize_token2022_snapshot(
let metadata_outputs = match kb_lib::materializer_metadata_materialize_token_2022_snapshot(
account_key,
slot,
state,
@@ -293,7 +293,7 @@ pub fn materialize_parsed_token2022_stateful_snapshot_with_context(
};
outputs.extend(metadata_outputs);
}
let fee_outputs = match kb_lib::materializer_fees_materialize_token2022_state_snapshots(
let fee_outputs = match kb_lib::materializer_fees_materialize_token_2022_state_snapshots(
account_key,
slot,
state,
@@ -302,7 +302,7 @@ pub fn materialize_parsed_token2022_stateful_snapshot_with_context(
std::result::Result::Err(error) => return std::result::Result::Err(error),
};
outputs.extend(fee_outputs);
let admin_outputs = match kb_lib::materializer_admin_materialize_token2022_state_snapshots(
let admin_outputs = match kb_lib::materializer_admin_materialize_token_2022_state_snapshots(
account_key,
slot,
state,
@@ -438,8 +438,11 @@ mod tests {
fn mint_snapshot_routes_account_and_metadata_outputs_once() {
let account_key = account_key(7);
let state = mint_state(account_key.as_str());
let bundle =
crate::materialize_parsed_token2022_stateful_snapshot(account_key.as_str(), 42, &state);
let bundle = crate::materialize_parsed_token_2022_stateful_snapshot(
account_key.as_str(),
42,
&state,
);
assert_eq!(
bundle.as_ref().map(|value| return value.outputs.len()),
std::result::Result::Ok(3)
@@ -462,7 +465,7 @@ mod tests {
let account_address = account_key(8);
let mut state = mint_state(account_address.as_str());
state.extensions[0].value_fields["mint"] = serde_json::json!(account_key(9));
let result = crate::materialize_parsed_token2022_stateful_snapshot(
let result = crate::materialize_parsed_token_2022_stateful_snapshot(
account_address.as_str(),
42,
&state,
@@ -474,7 +477,7 @@ mod tests {
fn owner_and_account_identity_fail_closed_before_projection() {
let account_key = account_key(10);
let data = [0u8; 82];
let wrong_owner = crate::materialize_token2022_stateful_snapshot(
let wrong_owner = crate::materialize_token_2022_stateful_snapshot(
account_key.as_str(),
kb_program_ids::SPL_TOKEN_PROGRAM_ID,
1,
@@ -484,7 +487,7 @@ mod tests {
assert!(wrong_owner.is_err());
let state = mint_state(account_key.as_str());
let malformed_key =
crate::materialize_parsed_token2022_stateful_snapshot("not-base58-0", 1, &state);
crate::materialize_parsed_token_2022_stateful_snapshot("not-base58-0", 1, &state);
assert!(malformed_key.is_err());
}
@@ -499,7 +502,7 @@ mod tests {
extensions: std::vec::Vec::new(),
};
let bundle =
crate::materialize_parsed_token2022_stateful_snapshot(account_key.as_str(), 9, &state);
crate::materialize_parsed_token_2022_stateful_snapshot(account_key.as_str(), 9, &state);
assert_eq!(
bundle.as_ref().map(|value| return value.outputs.len()),
std::result::Result::Ok(1)
@@ -525,7 +528,7 @@ mod tests {
}),
}],
};
let missing = crate::materialize_parsed_token2022_stateful_snapshot(
let missing = crate::materialize_parsed_token_2022_stateful_snapshot(
account_address.as_str(),
44,
&state,
@@ -534,7 +537,7 @@ mod tests {
let wrong_context = crate::Token2022StatefulContext {
expected_group_address: std::option::Option::Some(account_key(14)),
};
let wrong = crate::materialize_parsed_token2022_stateful_snapshot_with_context(
let wrong = crate::materialize_parsed_token_2022_stateful_snapshot_with_context(
account_address.as_str(),
44,
&state,
@@ -544,7 +547,7 @@ mod tests {
let context = crate::Token2022StatefulContext {
expected_group_address: std::option::Option::Some(group_address),
};
let valid = crate::materialize_parsed_token2022_stateful_snapshot_with_context(
let valid = crate::materialize_parsed_token_2022_stateful_snapshot_with_context(
account_address.as_str(),
44,
&state,
@@ -570,8 +573,11 @@ mod tests {
value_fields: serde_json::json!({"withheldAmount":"7"}),
}],
};
let mint_bundle =
crate::materialize_parsed_token2022_stateful_snapshot(mint_address.as_str(), 50, &mint);
let mint_bundle = crate::materialize_parsed_token_2022_stateful_snapshot(
mint_address.as_str(),
50,
&mint,
);
assert_eq!(
mint_bundle.as_ref().map(|bundle| return bundle.outputs.len()),
std::result::Result::Ok(2)
@@ -596,7 +602,7 @@ mod tests {
value_fields: serde_json::json!({"withheldAmount":"ciphertext"}),
}],
};
let account_bundle = crate::materialize_parsed_token2022_stateful_snapshot(
let account_bundle = crate::materialize_parsed_token_2022_stateful_snapshot(
account_address.as_str(),
51,
&account,
@@ -624,8 +630,11 @@ mod tests {
value_hex: "02".to_string(),
value_fields: serde_json::json!({"state": 2}),
});
let bundle =
crate::materialize_parsed_token2022_stateful_snapshot(account_key.as_str(), 17, &state);
let bundle = crate::materialize_parsed_token_2022_stateful_snapshot(
account_key.as_str(),
17,
&state,
);
assert_eq!(
bundle.as_ref().map(|value| return value.outputs.len()),
std::result::Result::Ok(4)
@@ -637,7 +646,7 @@ mod tests {
.iter()
.filter(|output| {
return output.payload_json["domain"]
== serde_json::json!("token2022_extension_admin_state");
== serde_json::json!("token_2022_extension_admin_state");
})
.count();
}),
@@ -663,14 +672,14 @@ mod tests {
},
account: std::option::Option::Some(kb_onchain_transport::AccountInfoValue {
lamports: 1,
owner: kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN2022_PROGRAM_ID.to_string()),
owner: kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID.to_string()),
executable: false,
rent_epoch: 0,
space: 82,
data: std::vec![0; 82],
}),
};
let materialized = crate::materialize_token2022_account_info_result(&request, &result);
let materialized = crate::materialize_token_2022_account_info_result(&request, &result);
assert_eq!(
materialized.as_ref().map(|value| return value.context_slot),
std::result::Result::Ok(41)
@@ -694,7 +703,7 @@ mod tests {
};
let base = kb_onchain_transport::AccountInfoValue {
lamports: 1,
owner: kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN2022_PROGRAM_ID.to_string()),
owner: kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN_2022_PROGRAM_ID.to_string()),
executable: false,
rent_epoch: 0,
space: 82,
@@ -707,7 +716,7 @@ mod tests {
},
account: std::option::Option::Some(base.clone()),
};
assert!(crate::materialize_token2022_account_info_result(&request, &stale).is_err());
assert!(crate::materialize_token_2022_account_info_result(&request, &stale).is_err());
let mut foreign = base.clone();
foreign.owner = kb_lib::MdProgramId(kb_program_ids::SPL_TOKEN_PROGRAM_ID.to_string());
let foreign = kb_onchain_transport::AccountInfoResult {
@@ -717,7 +726,7 @@ mod tests {
},
account: std::option::Option::Some(foreign),
};
assert!(crate::materialize_token2022_account_info_result(&request, &foreign).is_err());
assert!(crate::materialize_token_2022_account_info_result(&request, &foreign).is_err());
let mut executable = base.clone();
executable.executable = true;
let executable = kb_onchain_transport::AccountInfoResult {
@@ -727,7 +736,7 @@ mod tests {
},
account: std::option::Option::Some(executable),
};
assert!(crate::materialize_token2022_account_info_result(&request, &executable).is_err());
assert!(crate::materialize_token_2022_account_info_result(&request, &executable).is_err());
let mut incomplete = base;
incomplete.data.pop();
let incomplete = kb_onchain_transport::AccountInfoResult {
@@ -737,6 +746,6 @@ mod tests {
},
account: std::option::Option::Some(incomplete),
};
assert!(crate::materialize_token2022_account_info_result(&request, &incomplete).is_err());
assert!(crate::materialize_token_2022_account_info_result(&request, &incomplete).is_err());
}
}