v0.3.6-pre.009-fix.001

crates/ksp-job-backfill-lib/src/request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/request.rs
-// version: 3
+// version: 4
 
 use sha2::Digest; // rust-rules: trait-import
 
@@ -25,7 +25,7 @@ pub enum BackfillCommitment {
     Finalized,
 }
 
-impl BackfillCommitment {
+impl crate::BackfillCommitment {
     /// Returns the stable Backfill commitment code.
     #[must_use]
     pub const fn code(self) -> &'static str {
@@ -52,7 +52,7 @@ impl BackfillCommitment {
 #[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct BackfillSignature(std::string::String);
 
-impl BackfillSignature {
+impl crate::BackfillSignature {
     /// Creates one bounded Base58-shaped signature text.
     pub fn new(value: impl std::convert::Into<std::string::String>) -> ksp_core_lib::Result<Self> {
         let value = value.into();
@@ -74,7 +74,7 @@ impl BackfillSignature {
     }
 }
 
-impl std::fmt::Debug for BackfillSignature {
+impl std::fmt::Debug for crate::BackfillSignature {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         return formatter.write_str("BackfillSignature(..)");
     }
@@ -93,7 +93,7 @@ pub enum BackfillScopeKind {
     ExplicitSignatures,
 }
 
-impl BackfillScopeKind {
+impl crate::BackfillScopeKind {
     /// Returns the stable scope code used by diagnostics and scope fingerprinting.
     #[must_use]
     pub const fn code(self) -> &'static str {
@@ -109,9 +109,9 @@ impl BackfillScopeKind {
 #[derive(Clone, Eq, PartialEq)]
 enum BackfillScopeValue {
     LatestAddress { address: ksp_core_lib::Pubkey },
-    BeforeAddress { address: ksp_core_lib::Pubkey, anchor: BackfillSignature },
-    AfterAddress { address: ksp_core_lib::Pubkey, anchor: BackfillSignature },
-    ExplicitSignatures { signatures: std::vec::Vec<BackfillSignature> },
+    BeforeAddress { address: ksp_core_lib::Pubkey, anchor: crate::BackfillSignature },
+    AfterAddress { address: ksp_core_lib::Pubkey, anchor: crate::BackfillSignature },
+    ExplicitSignatures { signatures: std::vec::Vec<crate::BackfillSignature> },
 }
 
 /// Validated bounded discovery scope for one historical Backfill Job.
@@ -120,7 +120,7 @@ pub struct BackfillScope {
     value: BackfillScopeValue,
 }
 
-impl BackfillScope {
+impl crate::BackfillScope {
     /// Creates a scope starting at the newest known history for one address.
     #[must_use]
     pub const fn latest_address(address: ksp_core_lib::Pubkey) -> Self {
@@ -129,18 +129,18 @@ impl BackfillScope {
 
     /// Creates a scope reading history older than one exclusive address anchor.
     #[must_use]
-    pub fn before_address(address: ksp_core_lib::Pubkey, anchor: BackfillSignature) -> Self {
+    pub fn before_address(address: ksp_core_lib::Pubkey, anchor: crate::BackfillSignature) -> Self {
         return Self { value: BackfillScopeValue::BeforeAddress { address, anchor } };
     }
 
     /// Creates a scope reading the bounded newer history closest to one exclusive address anchor.
     #[must_use]
-    pub fn after_address(address: ksp_core_lib::Pubkey, anchor: BackfillSignature) -> Self {
+    pub fn after_address(address: ksp_core_lib::Pubkey, anchor: crate::BackfillSignature) -> Self {
         return Self { value: BackfillScopeValue::AfterAddress { address, anchor } };
     }
 
     /// Creates an explicit signature scope with stable first-occurrence deduplication.
-    pub fn explicit_signatures(signatures: std::vec::Vec<BackfillSignature>) -> ksp_core_lib::Result<Self> {
+    pub fn explicit_signatures(signatures: std::vec::Vec<crate::BackfillSignature>) -> ksp_core_lib::Result<Self> {
         if signatures.is_empty() || signatures.len() > crate::MAX_BACKFILL_CANDIDATES {
             return std::result::Result::Err(request_error("scope.signatures"));
         }
@@ -159,12 +159,12 @@ impl BackfillScope {
 
     /// Returns the stable category of this scope.
     #[must_use]
-    pub const fn kind(&self) -> BackfillScopeKind {
+    pub const fn kind(&self) -> crate::BackfillScopeKind {
         return match &self.value {
-            BackfillScopeValue::LatestAddress { .. } => BackfillScopeKind::LatestAddress,
-            BackfillScopeValue::BeforeAddress { .. } => BackfillScopeKind::BeforeAddress,
-            BackfillScopeValue::AfterAddress { .. } => BackfillScopeKind::AfterAddress,
-            BackfillScopeValue::ExplicitSignatures { .. } => BackfillScopeKind::ExplicitSignatures,
+            BackfillScopeValue::LatestAddress { .. } => crate::BackfillScopeKind::LatestAddress,
+            BackfillScopeValue::BeforeAddress { .. } => crate::BackfillScopeKind::BeforeAddress,
+            BackfillScopeValue::AfterAddress { .. } => crate::BackfillScopeKind::AfterAddress,
+            BackfillScopeValue::ExplicitSignatures { .. } => crate::BackfillScopeKind::ExplicitSignatures,
         };
     }
 
@@ -181,7 +181,7 @@ impl BackfillScope {
 
     /// Returns the exclusive anchor used by before/after scopes.
     #[must_use]
-    pub const fn anchor(&self) -> std::option::Option<&BackfillSignature> {
+    pub const fn anchor(&self) -> std::option::Option<&crate::BackfillSignature> {
         return match &self.value {
             BackfillScopeValue::BeforeAddress { anchor, .. } | BackfillScopeValue::AfterAddress { anchor, .. } => std::option::Option::Some(anchor),
             BackfillScopeValue::LatestAddress { .. } | BackfillScopeValue::ExplicitSignatures { .. } => std::option::Option::None,
@@ -190,7 +190,7 @@ impl BackfillScope {
 
     /// Returns the stable deduplicated explicit signature list, when this is an explicit scope.
     #[must_use]
-    pub fn signatures(&self) -> std::option::Option<&[BackfillSignature]> {
+    pub fn signatures(&self) -> std::option::Option<&[crate::BackfillSignature]> {
         return match &self.value {
             BackfillScopeValue::ExplicitSignatures { signatures } => std::option::Option::Some(signatures.as_slice()),
             BackfillScopeValue::LatestAddress { .. } | BackfillScopeValue::BeforeAddress { .. } | BackfillScopeValue::AfterAddress { .. } => {
@@ -200,7 +200,7 @@ impl BackfillScope {
     }
 }
 
-impl std::fmt::Debug for BackfillScope {
+impl std::fmt::Debug for crate::BackfillScope {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut debug = formatter.debug_struct("BackfillScope");
         debug.field("kind", &self.kind());
@@ -223,7 +223,7 @@ impl std::fmt::Debug for BackfillScope {
 #[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct BackfillScopeFingerprint([u8; 32]);
 
-impl BackfillScopeFingerprint {
+impl crate::BackfillScopeFingerprint {
     /// Returns the exact deterministic fingerprint bytes.
     #[must_use]
     pub const fn as_bytes(&self) -> &[u8; 32] {
@@ -231,7 +231,7 @@ impl BackfillScopeFingerprint {
     }
 }
 
-impl std::fmt::Debug for BackfillScopeFingerprint {
+impl std::fmt::Debug for crate::BackfillScopeFingerprint {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         return formatter.write_str("BackfillScopeFingerprint(..)");
     }
@@ -243,26 +243,26 @@ pub struct BackfillRequest {
     job_id: ksp_job_api::JobId,
     network: ksp_store_lib::RawNetworkId,
     role: ksp_onchain_transport_lib::HttpRoleName,
-    commitment: BackfillCommitment,
-    scope: BackfillScope,
+    commitment: crate::BackfillCommitment,
+    scope: crate::BackfillScope,
     page_size: usize,
     max_pages: usize,
     max_candidates: usize,
     hydration_concurrency: usize,
     min_context_slot: std::option::Option<u64>,
-    scope_fingerprint: BackfillScopeFingerprint,
+    scope_fingerprint: crate::BackfillScopeFingerprint,
     checkpoint: std::option::Option<crate::BackfillCheckpoint>,
 }
 
-impl BackfillRequest {
+impl crate::BackfillRequest {
     /// Creates and validates one fully explicit bounded Backfill request.
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         job_id: ksp_job_api::JobId,
         network: ksp_store_lib::RawNetworkId,
         role: ksp_onchain_transport_lib::HttpRoleName,
-        commitment: BackfillCommitment,
-        scope: BackfillScope,
+        commitment: crate::BackfillCommitment,
+        scope: crate::BackfillScope,
         page_size: usize,
         max_pages: usize,
         max_candidates: usize,
@@ -284,7 +284,7 @@ impl BackfillRequest {
         if role.as_str().is_empty() || role.as_str().trim() != role.as_str() {
             return std::result::Result::Err(request_error("role"));
         }
-        if scope.kind() == BackfillScopeKind::ExplicitSignatures {
+        if scope.kind() == crate::BackfillScopeKind::ExplicitSignatures {
             if min_context_slot.is_some() {
                 return std::result::Result::Err(request_error("min_context_slot"));
             }
@@ -333,13 +333,13 @@ impl BackfillRequest {
 
     /// Returns the narrowed commitment used by discovery and hydration.
     #[must_use]
-    pub const fn commitment(&self) -> BackfillCommitment {
+    pub const fn commitment(&self) -> crate::BackfillCommitment {
         return self.commitment;
     }
 
     /// Returns the validated discovery scope.
     #[must_use]
-    pub const fn scope(&self) -> &BackfillScope {
+    pub const fn scope(&self) -> &crate::BackfillScope {
         return &self.scope;
     }
 
@@ -378,7 +378,7 @@ impl BackfillRequest {
     /// Transport role, provider, endpoint and protocol are deliberately excluded. They describe
     /// acquisition provenance, not transaction or scope identity.
     #[must_use]
-    pub const fn scope_fingerprint(&self) -> BackfillScopeFingerprint {
+    pub const fn scope_fingerprint(&self) -> crate::BackfillScopeFingerprint {
         return self.scope_fingerprint;
     }
 
@@ -399,7 +399,7 @@ impl BackfillRequest {
     }
 }
 
-impl std::fmt::Debug for BackfillRequest {
+impl std::fmt::Debug for crate::BackfillRequest {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         return formatter
             .debug_struct("BackfillRequest")
@@ -421,13 +421,13 @@ impl std::fmt::Debug for BackfillRequest {
 
 fn fingerprint_scope(
     network: &ksp_store_lib::RawNetworkId,
-    commitment: BackfillCommitment,
-    scope: &BackfillScope,
+    commitment: crate::BackfillCommitment,
+    scope: &crate::BackfillScope,
     page_size: usize,
     max_pages: usize,
     max_candidates: usize,
     min_context_slot: std::option::Option<u64>,
-) -> BackfillScopeFingerprint {
+) -> crate::BackfillScopeFingerprint {
     let mut hasher = sha2::Sha256::new();
     hasher.update(b"ksp.job.backfill.scope.v1\0");
     hash_bytes(&mut hasher, network.as_str().as_bytes());
@@ -455,7 +455,7 @@ fn fingerprint_scope(
         std::option::Option::None => hasher.update([0_u8]),
     }
     let bytes: [u8; 32] = hasher.finalize().into();
-    return BackfillScopeFingerprint(bytes);
+    return crate::BackfillScopeFingerprint(bytes);
 }
 
 fn hash_bytes(hasher: &mut sha2::Sha256, value: &[u8]) {